commit 74c0407173d7e0a7539ef886127833dbabb06a55
Author: Jennifer Taylor <dragonminded@dragonminded.com>
Date:   Sun Dec 8 21:43:49 2019 +0000

    Initial commit of BEMANI Utilities to GitHub.

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c4534bd
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,13 @@
+__pycache__
+*.swp
+*.swo
+*.pyc
+*.pyo
+.mypy_cache/
+*.c
+*.o
+*.so
+build/
+.hg/
+.hgignore
+.venv/
diff --git a/2dxutils b/2dxutils
new file mode 100755
index 0000000..b2a5837
--- /dev/null
+++ b/2dxutils
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.twodxutils "$@"
diff --git a/BACKEND.md b/BACKEND.md
new file mode 100644
index 0000000..cdf8c94
--- /dev/null
+++ b/BACKEND.md
@@ -0,0 +1,98 @@
+The backend services component is responsible for parsing game requests
+and generating an appropriate response. It is divided into a dispatch
+layer and a series of folders each representing a game series. There is
+also a data layer filled with database access functions. Each game
+series knows how to dispatch a request to an appropriate game class
+given a model string and the Node structure (as detailed in PROTOCOL).
+Each game class inherits from the base backend class which provides common
+functionality such as boot requests, PASELI, and card lookup routines.
+Both the base backend class and the game classes use the data layer to
+determine appropriate responses given a request.
+
+A rough sketch of how the pieces fit together is as follows:
+
+                      ------------
+                      | Dispatch |
+                      ------------
+                           |
+                           |
+                           V
+       --------     --------------     --------------
+       | Base |<--->| Game Class |<--->| Data Class |
+       --------     --------------     --------------
+
+Dispatch is responsible for taking a tree of Node objects and determining
+which game class should handle it. It will extract the modelstring and
+root Node's name in order to determine which game and what request is
+being made. It will extract the PCBID of the request and optionally compare
+it against known PCBIDs if enforcing mode is enabled. If the PCBID is tied
+to an arcade, it will look up the details of that arcade in order to allow
+an operator to override PASELI settings. Then, it create a database connection
+using the Data class and instantiates the appropriate game class with the
+Data class and modelstring provided on instantiation. Then, it attempts to
+call the `handle_<request>_<method>_request` method on the instantiated game
+class. The <request> portion represents the name of the root Node object, and
+the <method> portion represents the string method found as an attribute on the
+root node. If that doesn't exist, it falls back to the `handle_<request>_request`
+method. Some series prefer to handle everything in one request method, manually
+examining the method, and some prefer to have individual methods per request
+and method combination. If neither of these exists, then it is assumed that
+the game does not handle this packet and an appropriate error is generated.
+
+Under most circumstances, code has been copied forward to new games in a series
+instead of made common. This is because games tend to subtly change their
+expectations of the network protocol under the assumption that the player will
+never go back to older versions of the game or server. A conscious decision was
+made to copy-paste code instead of trying to refactor it to be common, specifically
+to represent the reality that while the code appears identical/similar enough,
+its really up to the game engineers how to implement and things are subtly different.
+In some cases, a packet truly doesn't change across versions and in that case
+game series will chose to factor out common code, but in many cases the choice was
+made to sacrifice ease of maintainability for stability across versions.
+
+All game classes should inherit from Base. It has several
+`handle_<request>_request` handlers for basic functions such as PASELI, bootup,
+and card lookup routines. Base assumes that `has_profile`, `get_profile`,
+`put_profile`, and `bind_profile` are subclassed by any game wishing to provide
+complex profile handling, but provides default handlers which should work for any
+simple game. It also provides `get_play_statistics` and `update_play_statistics`
+which all games should use during their respective profile fetch and save. Base
+handles looking up a user's PASELI balance if the PCBID of the request is in an
+arcade and that arcade is set to non-infinite PASELI.
+
+Each game class is expected to have a few properties. The 'game' property should
+be a string name and is used for all DB operations when referring to a game
+series. The 'version' property should be an integer and is used for all DB
+operations when referring to a specific version of a game. Game code is free to
+choose what these values are set to, but currently all games use constants
+defined in `bemani/common/constants.py` for easier sharing with the BEMAPI REST
+server and the frontend. This is how Base can provide statistics, profile lookup
+and card manager services without knowing anything about what game is subclassin
+g it. Aside from that, games are free to handle packets in any way they see fit.
+
+In general, the tables provided by the database are indexed document stores.
+Most BEMANI games are implemented entirely client-side and simply expect the
+server to return the data it sent to it on the last profile save. For that to
+work, there are a few database abstractions in use across various games. The
+'profile' table stores JSON data given a specific game, so it is appropriate
+for game-specific data. The 'game_settings' table stores JSON data given
+a game series, so it is appropriate for data that is consistent across an
+entire series. Note that this does not include scores! The 'achievement' table
+stores JSON data given a specific game, an identifier and an identifier type.
+This table is perfect for item data such as unlocks or event progress. The
+'score' table stores JSON given a game and song ID, as does the 'score_history'
+table. Note that the song ID is an internal representation and translated
+through the 'music' table. This is to allow game series to renumber their
+songs while still keeping score history across versions. It also allows the
+server to preserve scores across multiple versions of a game. Note that all above
+tables are accessed through the Data class instead of directly creating SQL
+in the game classes.
+
+In some cases, we access a remote version of the Data classes instead of the
+MySQL version directly. The remote version in turn contacts any remote BEMAPI
+REST servers as well as the local database and then sums up the information before
+returning it to the game layer. In this way, we support fetching scores and
+rivaling across networks using the BEMAPI REST API in a manner that is virtually
+transparent to individual game implementations. Crucially, it is not used in
+the API implementation itself nor in the frontend, ensuring that both only
+respond with data that is contained on this instance directly.
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..ee58756
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,25 @@
+include bemani/frontend/templates/*.html
+include bemani/frontend/templates/admin/*.html
+include bemani/frontend/templates/account/*.html
+include bemani/frontend/static/*.css
+include bemani/frontend/static/*.js
+include bemani/frontend/static/*.gif
+include bemani/frontend/static/*.png
+include bemani/frontend/static/components/*.js
+include bemani/frontend/static/controllers/*.js
+include bemani/frontend/static/controllers/admin/*.js
+include bemani/frontend/static/controllers/account/*.js
+include bemani/frontend/static/controllers/arcade/*.js
+include bemani/frontend/static/controllers/common/*.js
+include bemani/frontend/static/controllers/iidx/*.js
+include bemani/frontend/static/controllers/popn/*.js
+include bemani/frontend/static/controllers/jubeat/*.js
+include bemani/frontend/static/controllers/bishi/*.js
+include bemani/frontend/static/controllers/ddr/*.js
+include bemani/frontend/static/controllers/reflec/*.js
+include bemani/frontend/static/controllers/sdvx/*.js
+include bemani/frontend/static/controllers/museca/*.js
+exclude bemani/protocol/lz77.py
+exclude bemani/protocol/stream.py
+exclude bemani/protocol/binary.py
+exclude bemani/protocol/xml.py
diff --git a/PROTOCOL.md b/PROTOCOL.md
new file mode 100644
index 0000000..f008ca6
--- /dev/null
+++ b/PROTOCOL.md
@@ -0,0 +1,59 @@
+The eAmusement protocol layer is divided into the main encoder/decoder class,
+a class for parsing old-style XML, a class for parsing new-style binary tree
+structure, a class representing a single node in a tree, and a few helper
+classes to tie the whole system together. Each message as sent to or received
+from a game can be represented as a tree of nodes. A node can either have
+additional nodes as children, or it can have a data value. Both types of node
+can have attributes. Given a tree of nodes, the encoder will output valid
+binary data suitable for returning to a game over HTTP, including any optional
+encryption or compression. Given binary data posted over HTTP from a game, the
+decoder will output a tree of nodes.
+
+A rough sketch of how the pieces fit together is as follows:
+
+            ------------------             --------
+            | EAmuseProtocol |------------>| Lz77 |
+            ------------------             --------
+                 |      |
+                 |      -------------------
+                 |                        |
+                 V                        V
+          ---------------           ------------------
+          | XmlEncoding |           | BinaryEncoding |
+          ---------------           ------------------
+             |       ^                 ^         |
+             |       |   ----------    |         |
+             |       --->| Stream |<----         |
+             |           ----------              |
+             |                                   |
+             |            --------               |
+             ------------>| Node |<---------------
+                          --------
+
+A packet will come in as data representing XML or a binary packet. It is
+optionally wrapped with Lz77 compression. That is optionally wrapped with
+RC4 encryption. Note that a packet may be encrypted and not compressed, but
+a packet with both compression and encryption will have RC4 as the outermost
+layer, followed by Lz77, followed finally by the raw data either as XML or
+binary.
+
+EAmuseProtocol is responsible for encryption/decryption using inlined RC4
+code, Lz77 compression/decompression using the Lz77 helper class, and finally
+uses either the XmlEncoding or BinaryEncoding class to convert to/from a
+tree of Node objects. Both XmlEncoding and BinaryEncoding use the Stream class
+as a helper for creating and dissecting raw binary data that will be exchanged
+with EamuseProtocol. Finally, Node is a representation of one element in the
+tree, having a name, an optional value and optional children which are also
+instances of the Node class.
+
+This setup is designed from the perspective of having a HTTP server such as
+flask pass binary data to EAmuseProtocol, and retrieve encoded responses from
+it. Game server code is expected to receive a tree in the form of a root Node
+instance. It will use various helper methods to walk the tree, decide on an
+appropriate response and then build that response using additional helper
+methods on the Node class. In this way, the game server component can work
+entirely on nodes, decoupled from the wire protocol itself and the HTTP request
+details.
+
+For details on how each piece works, see the respective classes as they have
+complete docstrings and type hints.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..daeca92
--- /dev/null
+++ b/README.md
@@ -0,0 +1,594 @@
+Introduction
+------------
+A collection of programs for working with various games in the BEMANI series. This
+could be untangled quite a bit into various modules that provide simpler pieces.
+However, this is how it ended up evolving over time. This repository includes
+utilities for unpacking (and sometimes repacking) various file formats, emulating
+network services for various games, utilities for sniffing, redirecting and
+reconstructing network packets, utilities for gathering information about various
+game music databases and associated tooling that makes developing the previous
+utilities easier. It is meant to be a complete ecosystem for somebody looking to
+provide hobby network services to themselves in order to preserve a particular era
+of gaming that is no longer officially supported.
+
+Thanks to Tau for the great writeup on the binary network format. Thanks to some
+rando on stack overflow for RC4 code for Python. Thanks to some other rando on
+stack overflow for sample sniffer code for Python. Thanks to Tau again for the
+great logging in easerver to compare my original output to. Thanks to PKGINGO for
+encouragement and well-received excitement about progress. Thanks to Sarah and Alice
+for being good RE partners for several games, and sharing good finds. Thanks to
+helvetica for helping with game RE and retweeting cute anime ladies onto my feed
+every goddamn night.
+
+2dxutils
+========
+A utility for unpacking and repacking `.2dx` files. This isn't the best utility and
+I think there are more complete and more accurate programs out there. However,
+they all lack source as far as I could tell, so I developed this. Run it like
+`./2dxutils --help` to see help output and determine how to use this.
+
+api
+===
+Development version of this repository's BEMAPI implementation. Run it like
+`./api --help` to see help output and determine how to use this. Much like
+"services" and "frontend", this should be pointed at the development version of
+your services config file, which holds information about the MySQL database that
+this should connect to as well as what game series are supported. See
+`config/server.yaml` for an example file that you can modify.
+
+Do not use this utility to serve production traffic. Instead, see
+`bemani/wsgi/api.wsgi` for a ready-to-go WSGI file that can be used with uWSGI
+and nginx.
+
+arcutils
+========
+A utility for unpacking `.arc` files. This does not currently repack files. However,
+the format is so trivial that adding such a feature would be fairly easy. Run it
+like `./arcutils --help` to see help output and determine how to use this.
+
+bemanishark
+===========
+A wire sniffer that can decode eAmuse packets and print them. Run it on a computer
+that can sniff traffic between an eAmusement server and a supported game and it will
+spit out the requests and responses XML-formatted identically to the legacy easerver
+XML output. This works on both binary and XML traffic. Note that it does not have the
+capability to sniff SSL-encrypted traffic, so don't even bother trying to run this
+at an arcade with official support.
+
+Run it like `sudo ./bemanishark` to invoke. Will run indefinitely until killed
+(Ctrl-C will suffice). Run like `./bemanishark --help for options. Without options,
+it assumes you want to sniff port 80 for all addresses. Note that it doesn't support
+the Base64 binary blob formats found in SN1 and 2. Note also that over time it will
+start to lose packets. This is a bug that I never figured out, and it appears to be
+the OS failing to send over some packets resulting in a failure to reassemble the
+TCP stream.
+
+This utility might be better if rewritten to be a plugin for Wireshark instead of
+a standalone sniffing utility, but I don't have the time.
+
+binutils
+========
+A utility for unpacking raw binxml files (files that use the same encoding scheme
+as the binary network protocol) to their XML representation. This is useful for
+examining raw binary blobs or digging into unknown file formats that contain binxml.
+Run it like `./binutils --help` to see help and learn how to use this.
+
+cardconvert
+===========
+A command-line utility for converting between card numbers written on the back of a
+card and the card ID stored in the RFID of the card. Run it like `./cardconvert --help`
+to see how to use this. This will sanitize input, so you can feed it card numbers
+with or without spaces, and you can mix up 1 and I as well as 0 and O, and it will
+properly handle decoding. This supports both new and old style cards.
+
+dbutils
+=======
+A command-line utility for working with the DB used by "api", "services" and "frontend".
+This utility includes options for creating tables in a newly-created DB, granting and
+revoking admin rights to the frontend, generating migration scripts for live DBs, and
+upgrading live DBs based on previously created migration scripts. Its driven by alembic
+under the hood. You will use `create on initial setup to generate a working MySQL
+database. If you change the schema in code, you can use this again with the `generate`
+option to generate a migration sript. Whenever you run an upgrade to your production
+instance, you should run this against your production DB with the `upgrade` option to
+bring your production DB up to sync with the code you are deploying. Run it like
+`./dbutils --help` to see all options. The config file that this works on is the same
+that is given to "api", "services" and "frontend".
+
+frontend
+========
+Development version of a frontend server allowing for account and server administration
+as well as score viewing and profile editing. Run it like `./frontend --help` to see
+help output and determine how to use this. Much like "services" and "api", this should
+be pointed at the development version of your services config file, which holds
+information about the MySQL database that this should connect to as well as what game
+series are supported. See `config/server.yaml` for an example file that you can modify.
+
+Do not use this utility to serve production traffic. Instead, see
+`bemani/wsgi/frontend.wsgi` for a ready-to-go WSGI file that can be used with uWSGI
+and nginx.
+
+ifsutils
+========
+A mediocre utility that can extract `.ifs` files. This has a lot of baked in
+assumptions and is not nearly as good as other open-source utilities for extracting
+files. It also cannot repack files. This is included for posterity, and because some
+bootstrapping code requires it in order to fully start a production server.
+Run it like `./ifsutils --help` to see help output and learn how to use it.
+
+iidxutils
+=========
+A utility for patching IIDX music database files. Note that this currently can only
+apply a "hide leggendarias from normal folders" patch, although its probable that it
+can be extended for other uses.
+
+proxy
+=====
+A utility to MITM an eAmuse session. Point a game at the port this listens on, and
+point it at another network to see the packets flowing between the two. Takes care
+of rewriting the facility message to MITM all messages. Has the ability to rewrite
+a request/response on the fly which is not currently used except for facility rewriting.
+Its possible that this could be used to on-the-fly patch packets coming back from a
+network which you don't control to do things such as enable paseli and adjust other
+settings that you cannot normally access. Logs in an identical format to bemanishark.
+Useful for black-box RE of other networks. Note that this does not have the ability
+to MITM SSL-encrypted traffic, so don't bother trying to use this on an official network.
+
+This also has the ability to route a packet to one of several known networks based on
+the PCBID, so this can also be used as a proxy for switching networks on the fly.
+With a config file, this can be used as a VIP of sorts, allowing you to point all of
+your games at a single server that runs this proxy, and forward games on a per-PCBID
+basis to various networks behind the scenes. For an example config file to use "proxy"
+as a VIP, see `config/proxy.yaml`. For a more reliable proxy, use the wsgi version
+of this utility located at `bemani/wsgi/proxy.wsgi` along with uWSGI and nginx.
+
+Run it like `./proxy --help` to see how to use this utility.
+
+psmap
+=====
+A utility to take an offset from a DLL file and produce python code that would generate
+a suitable response that said DLL will properly parse. Essentially, if you are
+reversing a new game and they use the `psmap` utility to decode all or part of a
+packet, you can grab either the physical offset into the DLL or the virtual address of
+the data and use this utility to generate the code necessary to service that request.
+Note that this doesn't currently work on 64bit games, but it should be trivial to
+figure out the differences in the 64-bit psmap implementation. Run it like
+`./psmap --help` to see how to use this utility.
+
+read
+====
+A utility to read music DB information out of game files and populate a database.
+This should be given the same config file as "api", "services" or "frontend" and
+assumes that "dbutils" has already been used to instantiate a valid MySQL DB. It
+also assumes you have the correct game files to read out of. Run it like
+`./read --help` to see how to use it. This utility's uses are extensively documented
+below in the "Installation" section.
+
+replay
+======
+A utility to take a packet as logged by proxy, services, trafficgen or bemanishark,
+and replay that packet against a particular server. Useful for quickly grabbing
+packets that caused a crash and debugging the crash (and verifying the fix). It also
+lets you replay that packet against your production instance once you fixed the issue
+in case that packet was a score or profile update that you care about.
+
+responsegen
+===========
+A utility to take a packet as logged by proxy, services, trafficgen or bemanishark,
+and generate python code that would have generated that exact packet. Useful for
+quickly grabbing packets sniffed from another network and prototyping new game support.
+Think of this as a combination of "replay" and "psmap". This is also extremely useful
+when building new integration test clients. Run it like `./responsegen --help` to
+see all information and usage.
+
+scheduler
+=========
+A command-line utility for kicking off scheduled work that must be performed against a
+DB. This includes picking new dailies/weeklies, new courses, etc... depending on the
+game and any requirements that the server perform some actual calculation based on
+time. Essentially, any game backend that includes a `run_scheduled_work` override will
+be acted on by this utility. Note that this takes care of scheduling cadence and
+should be seen as a utility-specific cron handler. You can safely run this repeatedly
+and as frequently as desired. Run like `./scheduler --help` to see how to ues this.
+This should be given the same config file as "api", "frontend" and "services".
+
+services
+========
+Development version of an eAmusement protocol server using flask and the protocol
+libraries also used in "bemanishark" and "trafficgen". Currently it lets most modern
+BEMANI games boot and supports full profile and events for Beatmania IIDX 20-24,
+Pop'n Music 19-24, Jubeat Saucer, Saucer Fulfill, Prop, Qubell and Clan, Sound Voltex
+1, 2, 3 Season 1/2 and 4, Dance Dance Revolution X2, X3, 2013, 2014 and Ace, MÚSECA 1,
+MÚSECA 1+1/2, Reflec Beat, Limelight, Colette, groovin'!! Upper, Volzza 1 and Volzza 2,
+and finally The\*BishiBashi.
+
+Do not use this utility to serve production traffic. Instead, see
+`bemani/wsgi/services.wsgi` for a ready-to-go WSGI file that can be used with uWSGI
+and nginx.
+
+shell
+=====
+A convenience wrapper to invoke a Python 3 shell that has paths set up to import the
+modules in this repository. If you want to tinker or write a quick one-off, this is
+probably the easiest way to do so.
+
+struct
+======
+A convenience utility for helping reverse-engineer structures out of game DLLs. You
+can give this a physical DLL offset or a virtual memory address for the start and
+end of the data as well as a python struct format (documentation at
+https://docs.python.org/3.6/library/struct.html) and this will print the decoded
+data to the screen as a series of tuples. Run it like `./struct --help` to see how
+to use this.
+
+trafficgen
+==========
+A utility for simulating traffic to an eAmusement service. Given a particular game,
+this will run through and attempt to verify simple operation of that service. No
+guarantees are made on the accuracy of the emulation though I've strived to be
+correct. In some cases, I will verify the response, and in other cases I will
+simply verify that certain things exist so as not to crash a real client. This
+currently generates traffic emulating Beatmania IIDX 20-24, Pop'n Music 19-24, Jubeat
+Saucer, Fulfill, Prop, Qubell and Clan, Sound Voltex 1, 2, 3 Season 1/2 and 4, Dance
+Dance Revolution X2, X3, 2013, 2014 and Ace, The\*BishiBashi, MÚSECA 1 and MÚSECA 1+1/2,
+Reflec Beat, Reflec Beat Limelight, Reflec Beat Colette, groovin'!! Upper, Volzza 1 and
+Volzza 2 and can verify card events and score events, as well as PASELI transactions.
+
+verifylibs
+==========
+Unit test frontend utility. This will invoke nosetests on the embarrasingly small
+collection of unit tests for this repository. If you are making modifications, it can
+be useful to write a test first (placed in the `bemani/tests/` directory) and code
+from there. It is also useful when optimizing or profiling, and also to verify that
+you haven't regressed anything.
+
+verifylint
+==========
+Lint invocation utility. This simply invokes flake8 with various options so that you
+can see you haven't introduced any lint errors.
+
+verifytraffic
+=============
+A utility which attempts to call "trafficgen" for each supported game on the network.
+Think of this as a full integration test suite, as it will sweep through each supported
+game and verify that network services are actually working. This assumes that you are
+running "services". Do not point this at a production instance since it **will**
+submit bogus cards, scores, names and the like and mess up your network. This takes
+a config file which sets up how the client should behave. See `config/trafficgen.yaml`
+for a sample file that can be used.
+
+verifytyping
+============
+Typing invocation utility. Since this repository is fully typed, this verifies that you
+haven't introduced any type errors and often catches bugs far faster than attemping to
+play a round only to see that you misused a class or misspelled a variable.
+
+Installation
+------------
+
+Dependency Setup
+================
+The code contained here assumes Python 3.6 as the base. If you don't have or don't
+want to install Python 3.6 as your system python, it is recommended to use
+virtualenv to create a virtual environment. The rest of the installation will assume
+you have Python 3.6 working properly (and are in an activated virtual environment if
+this is the route you've chosen to go). This code is designed to run on Linux.
+However, it has been tested successfully on Windows and OSX as it doesn't use any
+system libraries and sticks to pure python. YMMV in this regard, however, since the
+whole suite is built and tested using a Debian-based derivative.
+
+To install the required libraries, run the following command out of the root of the
+repository. This should allow all of the programs to at least start, but it still
+requires a MySQL database for many of them to be useful. This step has a dependency
+on an isntalled MySQL server and client as well as MySQL client development libraries.
+It also assumes that you've installed the 'wheel' package already. In order to
+compile the mysql client libraries, you will need to have libssl and libcrypto on your
+system as well. To satisfy these requirements on a Debian-based install, run the
+following command:
+
+  sudo apt install libssl-dev zlib1g-dev mysql-server mysql-client libmysqlclient-dev
+
+Once you have all of the above present, run the following command:
+
+  pip install -r requirements.txt
+
+Installing MySQL is outside the scope of this readme, so it is assumed that you have
+a MySQL database with access to create a new DB and tables within it. Note that this
+software requires MySQL version 5.7 or greater. This is due to the extensive use of
+the "json" column type added in 5.7. Create a database (the default database with
+this code is 'bemani') accessed by some user and password (the default user/pass for
+this code is 'bemani'/'bemani'). To create all of the required tables for the
+installation, run the following, substituting the config file for one that you've
+customized if you've done so. The config file that you use here should also be used
+with "api", "services", and "frontend" as well as various other utilities documented
+above.
+
+  ./dbutils --config config/server.yaml create
+
+In order to run the frontend, Python will need to find a javascript runtime. This
+is so it can precompile react components at render time so there doesn't need to be
+a compile step when developing. I found it absolutely bonkers that the backend could
+be on-the-fly reloaded but I had to go through an entire build process to produce
+interpreted JS code, so I went the route of self-contained services instead. Installing
+a JS runtime is also outside the scope of this document, but a quick way to get started
+is to install node.js.
+
+The default configuration points the frontend/backend cache at `/tmp`. It is recommended
+to change to a different directory, as using `/tmp` can cause some items not to be cached.
+This is due to the way `/tmp` on Linux restricts file access to the creator only, so
+if you share your cache with multiple utilities running under different users, it will
+fail to reuse the cache and drastically slow down the frontend.
+
+Database Initialization
+=======================
+At this point, games will boot when pointed at the network, but you won't be able
+to save scores. This is due to the missing song/chart -> score mapping. You will find
+default configuration files for the traffic generator and the services backend in
+the config/ directory. If you've customized your database setup, you will want to
+update the hostname/username/password/database here. You will also want to update
+the server address and frontend URL to customize your instance.
+
+To create the song/chart -> score mapping, you will want to run through the following
+section to import data from each game series. Be sure to substitute your own services
+config in place of the default if you've customized it. Note that if there have been updates
+to the files since you initially imported, you can run with the `--update` flag which
+forces the metadata to be overwritten in the DB instead of skipped. This won't normally
+happen, but if you make improvements to music DB parsing, you will want this to update
+your network.
+
+Note that you'll see a lot of re-used entries. That will happen when the import script
+finds an existing set of charts for the same song in a different game version and links
+the two game versions together. This is how scores can be shared across different versions
+of the same game.
+
+If you happen to already be an authorized client of a BEMAPI-compatible server, you can
+fast-track initializing your server by pointing it at the remote and using its existing
+database to seed your own. If this is the case, run the following command to perform
+a complete initialization. If you wish to update your initial setup with newer data,
+perhaps because a new supported game is available, you can run the following script and
+append the `--update` flag to it. Otherwise, run the following command like so:
+
+  ./bootstrap --config config/server.yaml \
+      --server http://some-server.here/ --token some-token-here
+
+If you do not have a BEMAPI-compatible server, you can initialize the server from the
+game files of the games you wish to run. See the following sections for how exactly to
+do that.
+
+Pop'n Music
+~~~~~~~~~~~
+For Pop'n Music, get the game DLL from the version of the game you want to import and
+run a command like so. This network supports versions 19-24 so you will want to run this
+command once for every version, giving the correct DLL file:
+
+  ./read --config config/server.yaml --series pnm --version 22 --bin popn22.dll
+
+Jubeat
+~~~~~~
+For Jubeat, get the music XML out of the data directory of the mix you are importing,
+and then use "read" with `--series jubeat` and `--version` corresponding to the following
+table:
+
+  Saucer:         saucer
+  Saucer Fulfill: saucer-fulfill
+  Prop:           prop
+  Qubell:         qubell
+  Clan:           clan
+
+An example is as follows:
+
+  ./read --config config/server.yaml --series jubeat --version saucer --xml \
+      music_info.xml
+
+You will also want to populate the Jubeat name database with the following command
+after importing all mixes:
+
+  ./read --config config/server.yaml --series jubeat --version all --tsv \
+      data/jubeat.tsv
+
+IIDX
+~~~~
+For IIDX, you will need the data directory of the mix you wish to support. The import
+script automatically scrapes the music DB as well as the song charts to determine
+difficulty, notecounts and BPM. For a normal mix, you will want to run the command like
+so. This network supports versions 20-24 so you will want to run this command once for
+every version, giving the correct bin file:
+
+  ./read --config config/server.yaml --series iidx --version 22 --bin \
+      gamedata/data/info/music_data.bin --assets gamedata/data/sound/
+
+Note that for omnimix mixes, you will need to point at the omnimix version of
+`music_data.bin`, normally named `music_omni.bin`. For the version, prepend "omni-" to the
+number, like so:
+
+  ./read --config config/server.yaml --series iidx --version omni-22 --bin \
+      gamedata/data/info/music_omni.bin --assets gamedata/data/sound/
+
+You will also want to update the IIDX name database with the following command
+after importing all mixes (this fixes some inconsistencies in names):
+
+  ./read --config config/server.yaml --series iidx --version all --tsv \
+      data/iidx.tsv
+
+DDR
+~~~
+For DDR, you will need the game DLL and `musicdb.xml` from the game you wish to import,
+and then run a command similar to the following. You will want to use the version
+corresponding to version in the following table:
+
+  X2:            12
+  X3 vs. 2ndMix: 13
+  2013:          14
+  2014:          15
+  Ace:           16
+
+  ./read --config config/server.yaml --series ddr --version 15 --bin ddr.dll \
+      --xml data/musicdb.xml
+
+For DDR Ace, there is no `musicdb.xml` or game DLL needed. Instead, you will need the
+`startup.arc` file, like the following example:
+
+  ./read --config config/server.yaml --series ddr --version 16 \
+      --bin data/arc/startup.arc
+
+SDVX
+~~~~
+For SDVX, you will need the game DLL and `music_db.xml` from the game you wish to import,
+and then run the following command, modifying the version parameter as required.
+Note that for SDVX 1, you want the `music_db.xml` file in `data/others/music_db/` directory,
+but for SDVX 2 and onward, you will want the file in `data/others/` instead.
+
+  ./read --config config/server.yaml --series sdvx --version 1 \
+      --xml data/others/music_db.xml
+
+For SDVX 1, you will also need to import the item DB, or appeal cards will not work
+properly. To do so, run the following command.
+
+  ./read --config config/server.yaml --series sdvx --version 1 \
+      --bin soundvoltex.dll
+
+For SDVX 2 and 3, you will also need to import the appeal message DB, or appeal cards
+will not work properly. To do so, run the following command, substituting the correct
+version number.
+
+  ./read --config config/server.yaml --series sdvx --version 2 \
+      --csv data/others/appealmessage.csv
+
+For SDVX 4, you will also need to import the appeal card DB, or appeal cards will not
+work properly. To do so, run the following command.
+
+  ./read --config config/server.yaml --series sdvx --version 4 \
+      --xml data/others/appeal_card.xml
+
+MÚSECA
+~~~~~~
+For MÚSECA, you will need the `music-info.xml` file from the game you wish to import.
+Then, run the following command, modifying the version parameter as required.
+
+  ./read --config config/server.yaml --series museca --version 1 \
+      --xml data/museca/xml/music-info.xml
+
+Reflec Beat
+~~~~~~~~~~~
+For Reflec Beat, get the game DLL from the version of the game you want to import and
+run a command like so. This network supports Reflec Beat up through Volzza 2, so you
+will want to run this with versions 1-6 to completely initialize:
+
+  ./read --config config/server.yaml --series reflec --version 1 --bin reflecbeat.dll
+
+Running Locally
+===============
+Once you've set all of this up, you can start the network in debug mode using a command
+similar to:
+
+  ./services --port 5730 --config config/server.yaml
+
+You can start the frontend in debug mode using another similar command as such:
+
+  ./frontend --port 8573 --config config/server.yaml
+
+You can start the BEMAPI REST server in debug mode using a command similar to:
+
+  ./api --port 18573 --config config/server.yaml
+
+The network config for any particular game should look similar to the following, with
+the correct hostname or IP filled in for the services URL. No path is necessary. Note
+that if you wish to switch between an existing network and one you serve using the
+"proxy" utility, you can set up the services URL to include subdirectories as required
+by that network. This code does not examine nor care about anything after the initial
+slash, so it can be whatever.
+
+  <network>
+    <timeout __type="u32">30000</timeout>
+    <sz_xrpc_buf __type="u32">102400</sz_xrpc_buf>
+    <ssl __type="bool">0</ssl>
+    <services __type="str">http://127.0.0.1:5730/</services>
+  </network>
+
+If you wish to verify the network's operation with some test traffic, feel free to
+point the traffic generator at your development network. You should run it similar to
+the command below, substituting the correct port to connect to your network and choosing
+one of the supported games. If you don't know a supported game, you can use the `--list`
+option to print them. If "Success!" is printed after all checks, you're good to go!
+
+  ./trafficgen --config config/trafficgen.yaml --port 5730 --game pnm-22 && echo Success!
+
+You will want to set up a cron job or similar scheduling agent to call "scheduler"
+on a regular basis. It is recommended to call it every five minutes since there are cache
+warming portions for the front-end that expire every 10 minutes. Game code will register
+with internal handlers to perform daily/weekly actions which are kicked off by this script.
+An example invocation of the tool is as follows:
+
+  ./scheduler --config config/server.yaml
+
+Once your network is up and running, if you pull new code down, the DB schema may have
+changed. For that, use the same DB util script detailed above in the following manner.
+This will walk through all migration scripts that you haven't applied and bring your DB
+up to spec. It is recommended to create a deploy script that knows how to restart uWSGI,
+install a new version of these utilities to your production virtualenv and then runs this
+script to ensure that your production DB is kept in sync:
+
+  ./dbutils --config config/server.yaml upgrade
+
+Since the network provided is player-first, in order to promote an account to administrator
+you will have to create an account on a game first. Once you have done that, you can sign
+up for the front-end using those credentials (your card and PIN), and then use the dbutils
+script to promote yourself to admin, similar to this command:
+
+  ./dbutils --config config/server.yaml add-admin --username <your-name-here>
+
+Production Setup
+================
+As alluded to several times in this README, the recommended way to run a production
+instance of this code is to set up uWSGI fronted by nginx. You should SSL-encrypt
+the frontend and the API services, and its recommended to use LetsEncrypt for a
+free certificate that you can manage easily. There are other ways to run this software
+but I have no experience with or advice on them.
+
+The easiest way to get up and running is to install MySQL 5.7, nginx and uWSGI along
+with Python 3.6 or higher. Create a directory where the services will live and place
+a virtualenv inside it (outside the scope of this document). Then, the wsgi files found
+in `bemani/wsgi/` can be placed in here, uWSGI pointed at them and nginx set up. The
+setup for the top-level package will include all of the frontend templates, so you can
+set up a nginx directory to serve the static resources directly.
+
+For example configurations, an example install script, and an example script to back
+up your MySQL instance, see the `examples/` directory.
+
+Contributing
+------------
+Contributions are welcome! Before submitting a pull request, ensure that your code
+is type-hint clean by running `./verifytyping` and ensure that it hasn't broken basic
+libraries with `./verifylibs`. Make sure that it is also lint-clean with `./verifylint`.
+If you are changing code related to a particular game, it is nice to include a
+verification in the form of a game traffic emulator, so that basic functionality can
+be verified. To ensure you haven't broken another game with your changes, its recommended
+to run the traffic generator against your code with various games. For convenience, you
+can run `./verifytraffic --config config/trafficgen.yaml` to run all supported games
+against your change. Remember that some games require you to run the scheduler to
+generate dailies/weeklies, and if you neglect to run this some of the integration
+tests will fail as they require full packet support! If possible, please also write
+a unit test for your changes. However, if the unit test is just a tautology and an
+integration/traffic test will suit better, then do that instead.
+
+For documentation on how the protocol layer works, see "PROTOCOL". For documentation
+on how the eAmusement server is intended to work, see "BACKEND". Inside `bemani/data/`
+the various DB model files have comments detailing the intended usage of each of the
+tables. For documentation on how the BEMAPI REST API should respond, please see the
+BEMAPI specification repository at https://github.com/DragonMinded/bemapi.
+
+When updating DB schema in the various `bemani/data/` python files, you will most-likely
+want to generate a migration for others to use. For that, we've integrated with alembic
+in order to provide robust migrations. The same DB utility script detailed above will
+create a migration script for you, given a message specifying the operation taking place.
+You should run this **after** making the code change to the schema in the relevant
+file under `bemani/data/mysql`. Alembic will automatically diff your development MySQL
+DB against the schema change you've made and generate an appropriate migration. Sometimes
+you will want to augment that migration with addtional data transformations. Various
+existing migrations do just that, so have a look at them under
+`bemani/data/migrations/versions/`. An example is as follows:
+
+  ./dbutils --config config/server.yaml generate --message "Adding timestamp column to user."
+
+Once the script finishes, check out the created migration script to be sure its correct
+and then check it in.
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..618c7bb
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,10 @@
+Things that I have not gotten around to doing.
+
+ - IIDX favorites viewer and editor for frontend. The data is all available in profile, but the interface was never built.
+ - DDR calorie tracker and workout stats. Again, the data is all available but the interface was never built.
+ - Rivals for several games. Pop'n and Jubeat come to mind as games that I never supported rivals for, but have support in-game.
+ - Lobby for all games except Reflec Beat. Reflec is the only game with lobby support right now, but this should be fairly easy to add to other games since the backend infra is all there. Correct global IP detection is even built-in to the server and passed forward if you are using a proxy.
+ - Prettify the frontend. Its a bit utilitarian right now, aside from some minor color flare.
+ - Make the frontend work better on mobile. It works well enough, but it could be a much better experience.
+ - Support for DanEvo. I meant to do this but my DanEvo ended up in storage before I could tackle it, so the only thing that exists at the moment is a rudimentary music DB parser.
+ - Figure out phase/unlock/etc bits for some older IIDX and Pop'n Music versions and hook them up to the Arcade panel to allow switching events.
diff --git a/api b/api
new file mode 100755
index 0000000..a0787e9
--- /dev/null
+++ b/api
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.api "$@"
diff --git a/arcutils b/arcutils
new file mode 100755
index 0000000..2261364
--- /dev/null
+++ b/arcutils
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.arcutils "$@"
diff --git a/bemani/__init__.py b/bemani/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/bemani/api/__init__.py b/bemani/api/__init__.py
new file mode 100644
index 0000000..0a413cf
--- /dev/null
+++ b/bemani/api/__init__.py
@@ -0,0 +1 @@
+from bemani.api.app import app, config
diff --git a/bemani/api/app.py b/bemani/api/app.py
new file mode 100644
index 0000000..546319d
--- /dev/null
+++ b/bemani/api/app.py
@@ -0,0 +1,311 @@
+import copy
+import json
+import traceback
+from typing import Any, Callable, Dict
+from flask import Flask, abort, request, Response, g  # type: ignore
+from functools import wraps
+
+from bemani.api.exceptions import APIException
+from bemani.api.objects import RecordsObject, ProfileObject, StatisticsObject, CatalogObject
+from bemani.common import GameConstants, APIConstants, VersionConstants
+from bemani.data import Data
+
+app = Flask(
+    __name__
+)
+config: Dict[str, Any] = {}
+
+SUPPORTED_VERSIONS = ['v1']
+
+
+def jsonify_response(data: Dict[str, Any], code: int=200) -> Response:
+    return Response(
+        json.dumps(data).encode('utf8'),
+        content_type="application/json; charset=utf-8",
+        status=code,
+    )
+
+
+@app.before_request
+def before_request() -> None:
+    global config
+
+    g.config = config
+    g.data = Data(config)
+    g.authorized = False
+
+    authkey = request.headers.get('Authorization')
+    if authkey is not None:
+        try:
+            authtype, authtoken = authkey.split(' ', 1)
+        except ValueError:
+            authtype = None
+            authtoken = None
+
+        if authtype.lower() == 'token':
+            g.authorized = g.data.local.api.validate_client(authtoken)
+
+
+@app.teardown_request
+def teardown_request(exception: Any) -> None:
+    data = getattr(g, 'data', None)
+    if data is not None:
+        data.close()
+
+
+def authrequired(func: Callable) -> Callable:
+    @wraps(func)
+    def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+        if not g.authorized:
+            return jsonify_response(
+                {'error': 'Unauthorized client!'},
+                401,
+            )
+        else:
+            return func(*args, **kwargs)
+    return decoratedfunction
+
+
+def jsonify(func: Callable) -> Callable:
+    @wraps(func)
+    def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+        return jsonify_response(func(*args, **kwargs))
+    return decoratedfunction
+
+
+@app.errorhandler(Exception)
+def server_exception(exception: Any) -> Response:
+    stack = ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+    print(stack)
+    try:
+        g.data.local.network.put_event(
+            'exception',
+            {
+                'service': 'api',
+                'request': request.url,
+                'traceback': stack,
+            },
+        )
+    except Exception:
+        pass
+
+    return jsonify_response(
+        {'error': 'Exception occured while processing request.'},
+        500,
+    )
+
+
+@app.errorhandler(APIException)
+def api_exception(exception: Any) -> Response:
+    return jsonify_response(
+        {'error': exception.message},
+        exception.code,
+    )
+
+
+@app.errorhandler(500)
+def server_error(error: Any) -> Response:
+    return jsonify_response(
+        {'error': 'Exception occured while processing request.'},
+        500,
+    )
+
+
+@app.errorhandler(501)
+def protocol_error(error: Any) -> Response:
+    return jsonify_response(
+        {'error': 'Unsupported protocol version in request.'},
+        501,
+    )
+
+
+@app.errorhandler(400)
+def bad_json(error: Any) -> Response:
+    return jsonify_response(
+        {'error': 'Request JSON could not be decoded.'},
+        500,
+    )
+
+
+@app.errorhandler(404)
+def unrecognized_object(error: Any) -> Response:
+    return jsonify_response(
+        {'error': 'Unrecognized request game/version or object.'},
+        404,
+    )
+
+
+@app.errorhandler(405)
+def invalid_request(error: Any) -> Response:
+    return jsonify_response(
+        {'error': 'Invalid request URI or method.'},
+        405,
+    )
+
+
+@app.route('/<path:path>', methods=['GET', 'POST'])
+@authrequired
+def catch_all(path: str) -> Response:
+    abort(405)
+
+
+@app.route('/', methods=['GET', 'POST'])
+@authrequired
+@jsonify
+def info() -> Dict[str, Any]:
+    requestdata = request.get_json()
+    if requestdata is None:
+        raise APIException('Request JSON could not be decoded.')
+    if requestdata:
+        raise APIException('Unrecognized parameters for request.')
+
+    return {
+        'versions': SUPPORTED_VERSIONS,
+        'name': g.config.get('name', 'e-AMUSEMENT Network'),
+        'email': g.config.get('email', 'nobody@nowhere.com'),
+    }
+
+
+@app.route('/<protoversion>/<requestgame>/<requestversion>', methods=['GET', 'POST'])
+@authrequired
+@jsonify
+def lookup(protoversion: str, requestgame: str, requestversion: str) -> Dict[str, Any]:
+    requestdata = request.get_json()
+    for expected in ['type', 'ids', 'objects']:
+        if expected not in requestdata:
+            raise APIException('Missing parameters for request.')
+    for param in requestdata:
+        if param not in ['type', 'ids', 'objects', 'since', 'until']:
+            raise APIException('Unrecognized parameters for request.')
+
+    args = copy.deepcopy(requestdata)
+    del args['type']
+    del args['ids']
+    del args['objects']
+
+    if protoversion not in SUPPORTED_VERSIONS:
+        # Don't know about this protocol version
+        abort(501)
+
+    # Figure out what games we support based on config, and map those.
+    gamemapping = {}
+    for (gameid, constant) in [
+        ('ddr', GameConstants.DDR),
+        ('iidx', GameConstants.IIDX),
+        ('jubeat', GameConstants.JUBEAT),
+        ('museca', GameConstants.MUSECA),
+        ('popnmusic', GameConstants.POPN_MUSIC),
+        ('reflecbeat', GameConstants.REFLEC_BEAT),
+        ('soundvoltex', GameConstants.SDVX),
+    ]:
+        if g.config.get('support', {}).get(constant, False):
+            gamemapping[gameid] = constant
+    game = gamemapping.get(requestgame)
+    if game is None:
+        # Don't support this game!
+        abort(404)
+
+    if requestversion[0] == 'o':
+        omnimix = True
+        requestversion = requestversion[1:]
+    else:
+        omnimix = False
+
+    version = {
+        GameConstants.DDR: {
+            '12': VersionConstants.DDR_X2,
+            '13': VersionConstants.DDR_X3_VS_2NDMIX,
+            '14': VersionConstants.DDR_2013,
+            '15': VersionConstants.DDR_2014,
+            '16': VersionConstants.DDR_ACE,
+        },
+        GameConstants.IIDX: {
+            '20': VersionConstants.IIDX_TRICORO,
+            '21': VersionConstants.IIDX_SPADA,
+            '22': VersionConstants.IIDX_PENDUAL,
+            '23': VersionConstants.IIDX_COPULA,
+            '24': VersionConstants.IIDX_SINOBUZ,
+            '25': VersionConstants.IIDX_CANNON_BALLERS,
+        },
+        GameConstants.JUBEAT: {
+            '5': VersionConstants.JUBEAT_SAUCER,
+            '5a': VersionConstants.JUBEAT_SAUCER_FULFILL,
+            '6': VersionConstants.JUBEAT_PROP,
+            '7': VersionConstants.JUBEAT_QUBELL,
+            '8': VersionConstants.JUBEAT_CLAN,
+        },
+        GameConstants.MUSECA: {
+            '1': VersionConstants.MUSECA,
+            '1p': VersionConstants.MUSECA_1_PLUS,
+        },
+        GameConstants.POPN_MUSIC: {
+            '19': VersionConstants.POPN_MUSIC_TUNE_STREET,
+            '20': VersionConstants.POPN_MUSIC_FANTASIA,
+            '21': VersionConstants.POPN_MUSIC_SUNNY_PARK,
+            '22': VersionConstants.POPN_MUSIC_LAPISTORIA,
+            '23': VersionConstants.POPN_MUSIC_ECLALE,
+            '24': VersionConstants.POPN_MUSIC_USANEKO,
+        },
+        GameConstants.REFLEC_BEAT: {
+            '1': VersionConstants.REFLEC_BEAT,
+            '2': VersionConstants.REFLEC_BEAT_LIMELIGHT,
+            # We don't support non-final COLETTE, so just return scores for
+            # final colette to any network that asks.
+            '3w': VersionConstants.REFLEC_BEAT_COLETTE,
+            '3sp': VersionConstants.REFLEC_BEAT_COLETTE,
+            '3su': VersionConstants.REFLEC_BEAT_COLETTE,
+            '3a': VersionConstants.REFLEC_BEAT_COLETTE,
+            '3as': VersionConstants.REFLEC_BEAT_COLETTE,
+            # We don't support groovin'!!, so just return upper scores.
+            '4': VersionConstants.REFLEC_BEAT_GROOVIN,
+            '4u': VersionConstants.REFLEC_BEAT_GROOVIN,
+            '5': VersionConstants.REFLEC_BEAT_VOLZZA,
+            '5a': VersionConstants.REFLEC_BEAT_VOLZZA_2,
+            '6': VersionConstants.REFLEC_BEAT_REFLESIA,
+        },
+        GameConstants.SDVX: {
+            '1': VersionConstants.SDVX_BOOTH,
+            '2': VersionConstants.SDVX_INFINITE_INFECTION,
+            '3': VersionConstants.SDVX_GRAVITY_WARS,
+            '4': VersionConstants.SDVX_HEAVENLY_HAVEN,
+        },
+    }.get(game, {}).get(requestversion)
+    if version is None:
+        # Don't support this version!
+        abort(404)
+
+    idtype = requestdata['type']
+    ids = requestdata['ids']
+    if idtype not in [APIConstants.ID_TYPE_CARD, APIConstants.ID_TYPE_SONG, APIConstants.ID_TYPE_INSTANCE, APIConstants.ID_TYPE_SERVER]:
+        raise APIException('Invalid ID type provided!')
+    if idtype == APIConstants.ID_TYPE_CARD and len(ids) == 0:
+        raise APIException('Invalid number of IDs given!')
+    if idtype == APIConstants.ID_TYPE_SONG and len(ids) not in [1, 2]:
+        raise APIException('Invalid number of IDs given!')
+    if idtype == APIConstants.ID_TYPE_INSTANCE and len(ids) != 3:
+        raise APIException('Invalid number of IDs given!')
+    if idtype == APIConstants.ID_TYPE_SERVER and len(ids) != 0:
+        raise APIException('Invalid number of IDs given!')
+
+    responsedata = {}
+    for obj in requestdata['objects']:
+        handler = {
+            'records': RecordsObject,
+            'profile': ProfileObject,
+            'statistics': StatisticsObject,
+            'catalog': CatalogObject,
+        }.get(obj)
+        if handler is None:
+            # Don't support this object type
+            abort(404)
+
+        inst = handler(g.data, game, version, omnimix)
+        try:
+            fetchmethod = getattr(inst, 'fetch_{}'.format(protoversion))
+        except AttributeError:
+            # Don't know how to handle this object for this version
+            abort(501)
+
+        responsedata[obj] = fetchmethod(idtype, ids, args)
+
+    return responsedata
diff --git a/bemani/api/exceptions.py b/bemani/api/exceptions.py
new file mode 100644
index 0000000..991e77b
--- /dev/null
+++ b/bemani/api/exceptions.py
@@ -0,0 +1,5 @@
+class APIException(Exception):
+
+    def __init__(self, msg: str, code: int=500) -> None:
+        self.message = msg
+        self.code = code
diff --git a/bemani/api/objects/__init__.py b/bemani/api/objects/__init__.py
new file mode 100644
index 0000000..3cae93a
--- /dev/null
+++ b/bemani/api/objects/__init__.py
@@ -0,0 +1,5 @@
+from bemani.api.objects.base import BaseObject
+from bemani.api.objects.catalog import CatalogObject
+from bemani.api.objects.records import RecordsObject
+from bemani.api.objects.profile import ProfileObject
+from bemani.api.objects.statistics import StatisticsObject
diff --git a/bemani/api/objects/base.py b/bemani/api/objects/base.py
new file mode 100644
index 0000000..09c71e2
--- /dev/null
+++ b/bemani/api/objects/base.py
@@ -0,0 +1,23 @@
+from typing import List, Any, Dict
+
+from bemani.api.exceptions import APIException
+from bemani.data import Data
+
+
+class BaseObject:
+    """
+    A base class which represents a fetchable API object. Every fetchable object
+    will subclass from this and implement one or more version fetches. These
+    are dynamically looked up by the version number provided by the client, so
+    objects can control which versions they reply to by subclassing or ignoring
+    various fetch versions.
+    """
+
+    def __init__(self, data: Data, game: str, version: int, omnimix: bool) -> None:
+        self.data = data
+        self.game = game
+        self.version = version
+        self.omnimix = omnimix
+
+    def fetch_v1(self, idtype: str, ids: List[str], params: Dict[str, Any]) -> Any:
+        raise APIException('Object fetch not supported for this version!')
diff --git a/bemani/api/objects/catalog.py b/bemani/api/objects/catalog.py
new file mode 100644
index 0000000..3f1dbef
--- /dev/null
+++ b/bemani/api/objects/catalog.py
@@ -0,0 +1,185 @@
+from typing import Any, Dict, List
+
+from bemani.api.exceptions import APIException
+from bemani.api.objects.base import BaseObject
+from bemani.common import GameConstants, APIConstants, DBConstants, VersionConstants
+from bemani.data import Song
+
+
+class CatalogObject(BaseObject):
+
+    def __format_ddr_song(self, song: Song) -> Dict[str, Any]:
+        groove = song.data.get_dict('groove')
+        return {
+            'editid': str(song.data.get_int('edit_id')),
+            'difficulty': song.data.get_int('difficulty'),
+            'bpm_min': song.data.get_int('bpm_min'),
+            'bpm_max': song.data.get_int('bpm_max'),
+            'category': str(song.data.get_int('category')),
+            'groove': {
+                'air': groove.get_int('air'),
+                'chaos': groove.get_int('chaos'),
+                'freeze': groove.get_int('freeze'),
+                'stream': groove.get_int('stream'),
+                'voltage': groove.get_int('voltage'),
+            },
+        }
+
+    def __format_iidx_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'difficulty': song.data.get_int('difficulty'),
+            'bpm_min': song.data.get_int('bpm_min'),
+            'bpm_max': song.data.get_int('bpm_max'),
+            'notecount': song.data.get_int('notecount'),
+            'category': str(int(song.id / 1000)),
+        }
+
+    def __format_jubeat_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'difficulty': song.data.get_int('difficulty'),
+            'bpm_min': song.data.get_int('bpm_min'),
+            'bpm_max': song.data.get_int('bpm_max'),
+        }
+
+    def __format_museca_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'difficulty': song.data.get_int('difficulty'),
+            'bpm_min': song.data.get_int('bpm_min'),
+            'bpm_max': song.data.get_int('bpm_max'),
+            'limited': song.data.get_int('limited'),
+        }
+
+    def __format_popn_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'difficulty': song.data.get_int('difficulty'),
+            'category': song.data.get_str('category'),
+        }
+
+    def __format_reflec_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'difficulty': song.data.get_int('difficulty'),
+            'category': str(song.data.get_int('folder')),
+            'musicid': song.data.get_str('chart_id'),
+        }
+
+    def __format_sdvx_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'difficulty': song.data.get_int('difficulty'),
+            'bpm_min': song.data.get_int('bpm_min'),
+            'bpm_max': song.data.get_int('bpm_max'),
+            'limited': song.data.get_int('limited'),
+        }
+
+    def __format_song(self, song: Song) -> Dict[str, Any]:
+        base = {
+            'song': str(song.id),
+            'chart': str(song.chart),
+            'title': song.name or "",
+            'artist': song.artist or "",
+            'genre': song.genre or "",
+        }
+
+        if self.game == GameConstants.DDR:
+            base.update(self.__format_ddr_song(song))
+        if self.game == GameConstants.IIDX:
+            base.update(self.__format_iidx_song(song))
+        if self.game == GameConstants.JUBEAT:
+            base.update(self.__format_jubeat_song(song))
+        if self.game == GameConstants.MUSECA:
+            base.update(self.__format_museca_song(song))
+        if self.game == GameConstants.POPN_MUSIC:
+            base.update(self.__format_popn_song(song))
+        if self.game == GameConstants.REFLEC_BEAT:
+            base.update(self.__format_reflec_song(song))
+        if self.game == GameConstants.SDVX:
+            base.update(self.__format_sdvx_song(song))
+
+        return base
+
+    def __format_sdvx_extras(self) -> Dict[str, List[Dict[str, Any]]]:
+        # Gotta look up the unlock catalog
+        items = self.data.local.game.get_items(self.game, self.version)
+
+        # Format it depending on the version
+        if self.version == 1:
+            return {
+                "purchases": [
+                    {
+                        "catalogid": str(item.id),
+                        "song": str(item.data.get_int("musicid")),
+                        "chart": str(item.data.get_int("chart")),
+                        "price": item.data.get_int("blocks"),
+                    }
+                    for item in items
+                    if item.type == "song_unlock"
+                ],
+                "appealcards": [],
+            }
+        else:
+            return {
+                "purchases": [],
+                "appealcards": [
+                    {
+                        "appealid": str(item.id),
+                        "description": item.data.get_str("description"),
+                    }
+                    for item in items
+                    if item.type == "appealcard"
+                ],
+            }
+
+    def __format_extras(self) -> Dict[str, List[Dict[str, Any]]]:
+        if self.game == GameConstants.SDVX:
+            return self.__format_sdvx_extras()
+        else:
+            return {}
+
+    @property
+    def music_version(self) -> int:
+        if self.game == GameConstants.IIDX:
+            if self.omnimix:
+                return self.version + DBConstants.OMNIMIX_VERSION_BUMP
+            else:
+                return self.version
+        else:
+            return self.version
+
+    def fetch_v1(self, idtype: str, ids: List[str], params: Dict[str, Any]) -> Dict[str, List[Dict[str, Any]]]:
+        # Verify IDs
+        if idtype != APIConstants.ID_TYPE_SERVER:
+            raise APIException(
+                'Unsupported ID for lookup!',
+                405,
+            )
+
+        # Fetch the songs
+        songs = self.data.local.music.get_all_songs(self.game, self.music_version)
+        if self.game == GameConstants.JUBEAT and self.version == VersionConstants.JUBEAT_CLAN:
+            # There's always a special case. We don't store all music IDs since those in
+            # the range of 80000301-80000347 are actually the same song, but copy-pasted
+            # for different prefectures and slightly different charts. So, we need to copy
+            # that song data so that remote clients can resolve scores for those ID ranges.
+            additions: List[Song] = []
+            for song in songs:
+                if song.id == 80000301:
+                    for idrange in range(80000302, 80000348):
+                        additions.append(
+                            Song(
+                                song.game,
+                                song.version,
+                                idrange,
+                                song.chart,
+                                song.name,
+                                song.artist,
+                                song.genre,
+                                song.data,
+                            )
+                        )
+            songs.extend(additions)
+        retval = {
+            'songs': [self.__format_song(song) for song in songs],
+        }
+
+        # Fetch any optional extras per-game, return
+        retval.update(self.__format_extras())
+        return retval
diff --git a/bemani/api/objects/profile.py b/bemani/api/objects/profile.py
new file mode 100644
index 0000000..b1467a7
--- /dev/null
+++ b/bemani/api/objects/profile.py
@@ -0,0 +1,131 @@
+from typing import Any, Dict, List, Set, Tuple
+
+from bemani.api.exceptions import APIException
+from bemani.api.objects.base import BaseObject
+from bemani.common import ValidatedDict, GameConstants, APIConstants
+from bemani.data import UserID
+
+
+class ProfileObject(BaseObject):
+
+    def __format_ddr_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        return {
+            'area': profile.get_int('area', -1) if exact else -1,
+        }
+
+    def __format_iidx_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        qpro = profile.get_dict('qpro')
+
+        return {
+            'area': profile.get_int('pid', -1),
+            'qpro': {
+                'head': qpro.get_int('head', -1) if exact else -1,
+                'hair': qpro.get_int('hair', -1) if exact else -1,
+                'face': qpro.get_int('face', -1) if exact else -1,
+                'body': qpro.get_int('body', -1) if exact else -1,
+                'hand': qpro.get_int('hand', -1) if exact else -1,
+            }
+        }
+
+    def __format_jubeat_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        return {}
+
+    def __format_museca_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        return {}
+
+    def __format_popn_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        return {
+            'character': profile.get_int('chara', -1) if exact else -1,
+        }
+
+    def __format_reflec_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        return {
+            'icon': profile.get_dict('config').get_int('icon_id', -1) if exact else -1,
+        }
+
+    def __format_sdvx_profile(self, profile: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        return {}
+
+    def __format_profile(self, cardids: List[str], profile: ValidatedDict, settings: ValidatedDict, exact: bool) -> Dict[str, Any]:
+        base = {
+            'name': profile.get_str('name'),
+            'cards': cardids,
+            'registered': settings.get_int('first_play_timestamp', -1),
+            'updated': settings.get_int('last_play_timestamp', -1),
+            'plays': settings.get_int('total_plays', -1),
+            'match': 'exact' if exact else 'partial',
+        }
+
+        if self.game == GameConstants.DDR:
+            base.update(self.__format_ddr_profile(profile, exact))
+        if self.game == GameConstants.IIDX:
+            base.update(self.__format_iidx_profile(profile, exact))
+        if self.game == GameConstants.JUBEAT:
+            base.update(self.__format_jubeat_profile(profile, exact))
+        if self.game == GameConstants.MUSECA:
+            base.update(self.__format_museca_profile(profile, exact))
+        if self.game == GameConstants.POPN_MUSIC:
+            base.update(self.__format_popn_profile(profile, exact))
+        if self.game == GameConstants.REFLEC_BEAT:
+            base.update(self.__format_reflec_profile(profile, exact))
+        if self.game == GameConstants.SDVX:
+            base.update(self.__format_sdvx_profile(profile, exact))
+
+        return base
+
+    def fetch_v1(self, idtype: str, ids: List[str], params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        # Fetch the profiles
+        profiles: List[Tuple[UserID, ValidatedDict]] = []
+        if idtype == APIConstants.ID_TYPE_SERVER:
+            profiles.extend(self.data.local.user.get_all_profiles(self.game, self.version))
+        elif idtype == APIConstants.ID_TYPE_SONG:
+            raise APIException(
+                'Unsupported ID for lookup!',
+                405,
+            )
+        elif idtype == APIConstants.ID_TYPE_INSTANCE:
+            raise APIException(
+                'Unsupported ID for lookup!',
+                405,
+            )
+        elif idtype == APIConstants.ID_TYPE_CARD:
+            users: Set[UserID] = set()
+            for cardid in ids:
+                userid = self.data.local.user.from_cardid(cardid)
+                if userid is not None:
+                    # Don't duplicate loads for users with multiple card IDs if multiples
+                    # of those IDs are requested.
+                    if userid in users:
+                        continue
+                    users.add(userid)
+
+                    # We can possibly find another profile for this user. This is important
+                    # in the case that we returned scores for a user that doesn't have a
+                    # profile on a particular version. We allow that on this network, so in
+                    # order to not break remote networks, try our best to return any profile.
+                    profile = self.data.local.user.get_any_profile(self.game, self.version, userid)
+                    if profile is not None:
+                        profiles.append((userid, profile))
+        else:
+            raise APIException('Invalid ID type!')
+
+        # Now, fetch the users, and filter out profiles belonging to orphaned users
+        retval: List[Dict[str, Any]] = []
+        id_to_cards: Dict[UserID, List[str]] = {}
+        for (userid, profile) in profiles:
+            if userid not in id_to_cards:
+                cards = self.data.local.user.get_cards(userid)
+                if len(cards) == 0:
+                    # Can't add this user, skip the profile
+                    continue
+
+                id_to_cards[userid] = cards
+
+            # Format the profile and add it
+            settings = self.data.local.game.get_settings(self.game, userid)
+            if settings is None:
+                settings = ValidatedDict({})
+
+            retval.append(self.__format_profile(id_to_cards[userid], profile, settings, profile['version'] == self.version))
+
+        return retval
diff --git a/bemani/api/objects/records.py b/bemani/api/objects/records.py
new file mode 100644
index 0000000..8c36d10
--- /dev/null
+++ b/bemani/api/objects/records.py
@@ -0,0 +1,299 @@
+from typing import Any, Dict, List, Set, Tuple
+
+from bemani.api.exceptions import APIException
+from bemani.api.objects.base import BaseObject
+from bemani.common import GameConstants, VersionConstants, APIConstants, DBConstants
+from bemani.data import Score, UserID
+
+
+class RecordsObject(BaseObject):
+
+    def __format_ddr_record(self, record: Score) -> Dict[str, Any]:
+        halo = {
+            DBConstants.DDR_HALO_NONE: 'none',
+            DBConstants.DDR_HALO_GOOD_FULL_COMBO: 'gfc',
+            DBConstants.DDR_HALO_GREAT_FULL_COMBO: 'fc',
+            DBConstants.DDR_HALO_PERFECT_FULL_COMBO: 'pfc',
+            DBConstants.DDR_HALO_MARVELOUS_FULL_COMBO: 'mfc',
+        }.get(record.data.get_int('halo'), 'none')
+        rank = {
+            DBConstants.DDR_RANK_AAA: "AAA",
+            DBConstants.DDR_RANK_AA_PLUS: "AA+",
+            DBConstants.DDR_RANK_AA: "AA",
+            DBConstants.DDR_RANK_AA_MINUS: "AA-",
+            DBConstants.DDR_RANK_A_PLUS: "A+",
+            DBConstants.DDR_RANK_A: "A",
+            DBConstants.DDR_RANK_A_MINUS: "A-",
+            DBConstants.DDR_RANK_B_PLUS: "B+",
+            DBConstants.DDR_RANK_B: "B",
+            DBConstants.DDR_RANK_B_MINUS: "B-",
+            DBConstants.DDR_RANK_C_PLUS: "C+",
+            DBConstants.DDR_RANK_C: "C",
+            DBConstants.DDR_RANK_C_MINUS: "C-",
+            DBConstants.DDR_RANK_D_PLUS: "D+",
+            DBConstants.DDR_RANK_D: "D",
+            DBConstants.DDR_RANK_E: "E",
+        }.get(record.data.get_int('rank'), 'E')
+
+        if self.version == VersionConstants.DDR_ACE:
+            # DDR Ace is specia
+            ghost = [int(x) for x in record.data.get_str('ghost')]
+        else:
+            if 'trace' not in record.data:
+                ghost = []
+            else:
+                ghost = record.data.get_int_array('trace', len(record.data['trace']))
+
+        return {
+            'rank': rank,
+            'halo': halo,
+            'combo': record.data.get_int('combo'),
+            'ghost': ghost,
+        }
+
+    def __format_iidx_record(self, record: Score) -> Dict[str, Any]:
+        status = {
+            DBConstants.IIDX_CLEAR_STATUS_NO_PLAY: 'np',
+            DBConstants.IIDX_CLEAR_STATUS_FAILED: 'failed',
+            DBConstants.IIDX_CLEAR_STATUS_ASSIST_CLEAR: 'ac',
+            DBConstants.IIDX_CLEAR_STATUS_EASY_CLEAR: 'ec',
+            DBConstants.IIDX_CLEAR_STATUS_CLEAR: 'nc',
+            DBConstants.IIDX_CLEAR_STATUS_HARD_CLEAR: 'hc',
+            DBConstants.IIDX_CLEAR_STATUS_EX_HARD_CLEAR: 'exhc',
+            DBConstants.IIDX_CLEAR_STATUS_FULL_COMBO: 'fc',
+        }.get(record.data.get_int('clear_status'), 'np')
+
+        return {
+            'status': status,
+            'miss': record.data.get_int('miss_count', -1),
+            'ghost': [b for b in record.data.get_bytes('ghost')],
+            'pgreat': record.data.get_int('pgreats', -1),
+            'great': record.data.get_int('greats', -1),
+        }
+
+    def __format_jubeat_record(self, record: Score) -> Dict[str, Any]:
+        status = {
+            DBConstants.JUBEAT_PLAY_MEDAL_FAILED: 'failed',
+            DBConstants.JUBEAT_PLAY_MEDAL_CLEARED: 'cleared',
+            DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_FULL_COMBO: 'nfc',
+            DBConstants.JUBEAT_PLAY_MEDAL_FULL_COMBO: 'fc',
+            DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT: 'nec',
+            DBConstants.JUBEAT_PLAY_MEDAL_EXCELLENT: 'exc',
+        }.get(record.data.get_int('medal'), 'failed')
+        if 'ghost' not in record.data:
+            ghost: List[int] = []
+        else:
+            ghost = record.data.get_int_array('ghost', len(record.data['ghost']))
+
+        return {
+            'status': status,
+            'combo': record.data.get_int('combo', -1),
+            'ghost': ghost,
+        }
+
+    def __format_museca_record(self, record: Score) -> Dict[str, Any]:
+        rank = {
+            DBConstants.MUSECA_GRADE_DEATH: 'death',
+            DBConstants.MUSECA_GRADE_POOR: 'poor',
+            DBConstants.MUSECA_GRADE_MEDIOCRE: 'mediocre',
+            DBConstants.MUSECA_GRADE_GOOD: 'good',
+            DBConstants.MUSECA_GRADE_GREAT: 'great',
+            DBConstants.MUSECA_GRADE_EXCELLENT: 'excellent',
+            DBConstants.MUSECA_GRADE_SUPERB: 'superb',
+            DBConstants.MUSECA_GRADE_MASTERPIECE: 'masterpiece',
+            DBConstants.MUSECA_GRADE_PERFECT: 'perfect'
+        }.get(record.data.get_int('grade'), 'death')
+        status = {
+            DBConstants.MUSECA_CLEAR_TYPE_FAILED: 'failed',
+            DBConstants.MUSECA_CLEAR_TYPE_CLEARED: 'cleared',
+            DBConstants.MUSECA_CLEAR_TYPE_FULL_COMBO: 'fc',
+        }.get(record.data.get_int('clear_type'), 'failed')
+
+        return {
+            'rank': rank,
+            'status': status,
+            'combo': record.data.get_int('combo', -1),
+            'buttonrate': record.data.get_dict('stats').get_int('btn_rate'),
+            'longrate': record.data.get_dict('stats').get_int('long_rate'),
+            'volrate': record.data.get_dict('stats').get_int('vol_rate'),
+        }
+
+    def __format_popn_record(self, record: Score) -> Dict[str, Any]:
+        status = {
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED: 'cf',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FAILED: 'df',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FAILED: 'sf',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_EASY_CLEAR: 'ec',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_CLEARED: 'cc',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_CLEARED: 'dc',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_CLEARED: 'sc',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FULL_COMBO: 'cfc',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FULL_COMBO: 'dfc',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FULL_COMBO: 'sfc',
+            DBConstants.POPN_MUSIC_PLAY_MEDAL_PERFECT: 'p',
+        }.get(record.data.get_int('medal'), 'cf')
+
+        return {
+            'status': status,
+            'combo': record.data.get_int('combo', -1),
+        }
+
+    def __format_reflec_record(self, record: Score) -> Dict[str, Any]:
+        status = {
+            DBConstants.REFLEC_BEAT_CLEAR_TYPE_NO_PLAY: 'np',
+            DBConstants.REFLEC_BEAT_CLEAR_TYPE_FAILED: 'failed',
+            DBConstants.REFLEC_BEAT_CLEAR_TYPE_CLEARED: 'cleared',
+            DBConstants.REFLEC_BEAT_CLEAR_TYPE_HARD_CLEARED: 'hc',
+            DBConstants.REFLEC_BEAT_CLEAR_TYPE_S_HARD_CLEARED: 'shc',
+        }.get(record.data.get_int('clear_type'), 'np')
+        halo = {
+            DBConstants.REFLEC_BEAT_COMBO_TYPE_NONE: 'none',
+            DBConstants.REFLEC_BEAT_COMBO_TYPE_ALMOST_COMBO: 'ac',
+            DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO: 'fc',
+            DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO_ALL_JUST: 'fcaj',
+        }.get(record.data.get_int('combo_type'), 'none')
+
+        return {
+            'rate': record.data.get_int('achievement_rate'),
+            'status': status,
+            'halo': halo,
+            'combo': record.data.get_int('combo', -1),
+            'miss': record.data.get_int('miss_count', -1),
+        }
+
+    def __format_sdvx_record(self, record: Score) -> Dict[str, Any]:
+        status = {
+            DBConstants.SDVX_CLEAR_TYPE_NO_PLAY: 'np',
+            DBConstants.SDVX_CLEAR_TYPE_FAILED: 'failed',
+            DBConstants.SDVX_CLEAR_TYPE_CLEAR: 'cleared',
+            DBConstants.SDVX_CLEAR_TYPE_HARD_CLEAR: 'hc',
+            DBConstants.SDVX_CLEAR_TYPE_ULTIMATE_CHAIN: 'uc',
+            DBConstants.SDVX_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: 'puc',
+        }.get(record.data.get_int('clear_type'), 'np')
+        rank = {
+            DBConstants.SDVX_GRADE_NO_PLAY: 'E',
+            DBConstants.SDVX_GRADE_D: 'D',
+            DBConstants.SDVX_GRADE_C: 'C',
+            DBConstants.SDVX_GRADE_B: 'B',
+            DBConstants.SDVX_GRADE_A: 'A',
+            DBConstants.SDVX_GRADE_A_PLUS: 'A+',
+            DBConstants.SDVX_GRADE_AA: 'AA',
+            DBConstants.SDVX_GRADE_AA_PLUS: 'AA+',
+            DBConstants.SDVX_GRADE_AAA: 'AAA',
+            DBConstants.SDVX_GRADE_AAA_PLUS: 'AAA+',
+            DBConstants.SDVX_GRADE_S: 'S',
+        }.get(record.data.get_int('grade'), 'E')
+
+        return {
+            'status': status,
+            'rank': rank,
+            'combo': record.data.get_int('combo', -1),
+            'buttonrate': record.data.get_dict('stats').get_int('btn_rate'),
+            'longrate': record.data.get_dict('stats').get_int('long_rate'),
+            'volrate': record.data.get_dict('stats').get_int('vol_rate'),
+        }
+
+    def __format_record(self, cardids: List[str], record: Score) -> Dict[str, Any]:
+        base = {
+            'cards': cardids,
+            'song': str(record.id),
+            'chart': str(record.chart),
+            'points': record.points,
+            'timestamp': record.timestamp,
+            'updated': record.update,
+        }
+
+        if self.game == GameConstants.DDR:
+            base.update(self.__format_ddr_record(record))
+        if self.game == GameConstants.IIDX:
+            base.update(self.__format_iidx_record(record))
+        if self.game == GameConstants.JUBEAT:
+            base.update(self.__format_jubeat_record(record))
+        if self.game == GameConstants.MUSECA:
+            base.update(self.__format_museca_record(record))
+        if self.game == GameConstants.POPN_MUSIC:
+            base.update(self.__format_popn_record(record))
+        if self.game == GameConstants.REFLEC_BEAT:
+            base.update(self.__format_reflec_record(record))
+        if self.game == GameConstants.SDVX:
+            base.update(self.__format_sdvx_record(record))
+
+        return base
+
+    @property
+    def music_version(self) -> int:
+        if self.game == GameConstants.IIDX:
+            if self.omnimix:
+                return self.version + DBConstants.OMNIMIX_VERSION_BUMP
+            else:
+                return self.version
+        else:
+            return self.version
+
+    def fetch_v1(self, idtype: str, ids: List[str], params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        since = params.get('since')
+        until = params.get('until')
+
+        # Fetch the scores
+        records: List[Tuple[UserID, Score]] = []
+        if idtype == APIConstants.ID_TYPE_SERVER:
+            # Because of the way this query works, we can't apply since/until to it directly.
+            # If we did, it would miss higher scores earned before since or after until, and
+            # incorrectly report records.
+            records.extend(self.data.local.music.get_all_records(self.game, self.music_version))
+        elif idtype == APIConstants.ID_TYPE_SONG:
+            if len(ids) == 1:
+                songid = int(ids[0])
+                chart = None
+            else:
+                songid = int(ids[0])
+                chart = int(ids[1])
+            records.extend(self.data.local.music.get_all_scores(self.game, self.music_version, songid=songid, songchart=chart, since=since, until=until))
+        elif idtype == APIConstants.ID_TYPE_INSTANCE:
+            songid = int(ids[0])
+            chart = int(ids[1])
+            cardid = ids[2]
+            userid = self.data.local.user.from_cardid(cardid)
+            if userid is not None:
+                score = self.data.local.music.get_score(self.game, self.music_version, userid, songid, chart)
+                if score is not None:
+                    records.append((userid, score))
+        elif idtype == APIConstants.ID_TYPE_CARD:
+            users: Set[UserID] = set()
+            for cardid in ids:
+                userid = self.data.local.user.from_cardid(cardid)
+                if userid is not None:
+                    # Don't duplicate loads for users with multiple card IDs if multiples
+                    # of those IDs are requested.
+                    if userid in users:
+                        continue
+                    users.add(userid)
+
+                    records.extend([(userid, score) for score in self.data.local.music.get_scores(self.game, self.music_version, userid, since=since, until=until)])
+        else:
+            raise APIException('Invalid ID type!')
+
+        # Now, fetch the users, and filter out scores belonging to orphaned users
+        id_to_cards: Dict[UserID, List[str]] = {}
+        retval: List[Dict[str, Any]] = []
+        for (userid, record) in records:
+            # Postfilter for queries that can't filter. This will save on data transferred.
+            if since is not None:
+                if record.update < since:
+                    continue
+            if until is not None:
+                if record.update >= until:
+                    continue
+
+            if userid not in id_to_cards:
+                cards = self.data.local.user.get_cards(userid)
+                if len(cards) == 0:
+                    # Can't add this user, skip the score
+                    continue
+
+                id_to_cards[userid] = cards
+
+            # Format the score and add it
+            retval.append(self.__format_record(id_to_cards[userid], record))
+
+        return retval
diff --git a/bemani/api/objects/statistics.py b/bemani/api/objects/statistics.py
new file mode 100644
index 0000000..64ad19f
--- /dev/null
+++ b/bemani/api/objects/statistics.py
@@ -0,0 +1,230 @@
+from typing import List, Dict, Tuple, Any
+
+from bemani.api.exceptions import APIException
+from bemani.api.objects.base import BaseObject
+from bemani.common import APIConstants, DBConstants, GameConstants
+from bemani.data import Attempt, UserID
+
+
+class StatisticsObject(BaseObject):
+
+    def __format_statistics(self, stats: Dict[str, Any]) -> Dict[str, Any]:
+        return {
+            'cards': [],
+            'song': str(stats['id']),
+            'chart': str(stats['chart']),
+            'plays': stats.get('plays', -1),
+            'clears': stats.get('clears', -1),
+            'combos': stats.get('combos', -1),
+        }
+
+    def __format_user_statistics(self, cardids: List[str], stats: Dict[str, Any]) -> Dict[str, Any]:
+        base = self.__format_statistics(stats)
+        base['cards'] = cardids
+        return base
+
+    @property
+    def music_version(self) -> int:
+        if self.game == GameConstants.IIDX:
+            if self.omnimix:
+                return self.version + DBConstants.OMNIMIX_VERSION_BUMP
+            else:
+                return self.version
+        else:
+            return self.version
+
+    def __is_play(self, attempt: Attempt) -> bool:
+        if self.game in [
+            GameConstants.DDR,
+            GameConstants.JUBEAT,
+            GameConstants.MUSECA,
+            GameConstants.POPN_MUSIC,
+        ]:
+            return True
+        if self.game == GameConstants.IIDX:
+            return attempt.data.get_int('clear_status') != DBConstants.IIDX_CLEAR_STATUS_NO_PLAY
+        if self.game == GameConstants.REFLEC_BEAT:
+            return attempt.data.get_int('clear_type') != DBConstants.REFLEC_BEAT_CLEAR_TYPE_NO_PLAY
+        if self.game == GameConstants.SDVX:
+            return attempt.data.get_int('clear_type') != DBConstants.SDVX_CLEAR_TYPE_NO_PLAY
+
+        return False
+
+    def __is_clear(self, attempt: Attempt) -> bool:
+        if not self.__is_play(attempt):
+            return False
+
+        if self.game == GameConstants.DDR:
+            return attempt.data.get_int('rank') != DBConstants.DDR_RANK_E
+        if self.game == GameConstants.IIDX:
+            return attempt.data.get_int('clear_status') != DBConstants.IIDX_CLEAR_STATUS_FAILED
+        if self.game == GameConstants.JUBEAT:
+            return attempt.data.get_int('medal') != DBConstants.JUBEAT_PLAY_MEDAL_FAILED
+        if self.game == GameConstants.MUSECA:
+            return attempt.data.get_int('clear_type') != DBConstants.MUSECA_CLEAR_TYPE_FAILED
+        if self.game == GameConstants.POPN_MUSIC:
+            return attempt.data.get_int('medal') not in [
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED,
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FAILED,
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FAILED,
+            ]
+        if self.game == GameConstants.REFLEC_BEAT:
+            return attempt.data.get_int('clear_type') != DBConstants.REFLEC_BEAT_CLEAR_TYPE_FAILED
+        if self.game == GameConstants.SDVX:
+            return (
+                attempt.data.get_int('grade') != DBConstants.SDVX_GRADE_NO_PLAY and
+                attempt.data.get_int('clear_type') not in [
+                    DBConstants.SDVX_CLEAR_TYPE_NO_PLAY,
+                    DBConstants.SDVX_CLEAR_TYPE_FAILED,
+                ]
+            )
+
+        return False
+
+    def __is_combo(self, attempt: Attempt) -> bool:
+        if not self.__is_play(attempt):
+            return False
+
+        if self.game == GameConstants.DDR:
+            return attempt.data.get_int('halo') != DBConstants.DDR_HALO_NONE
+        if self.game == GameConstants.IIDX:
+            return attempt.data.get_int('clear_status') == DBConstants.IIDX_CLEAR_STATUS_FULL_COMBO
+        if self.game == GameConstants.JUBEAT:
+            return attempt.data.get_int('medal') in [
+                DBConstants.JUBEAT_PLAY_MEDAL_FULL_COMBO,
+                DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT,
+                DBConstants.JUBEAT_PLAY_MEDAL_EXCELLENT,
+            ]
+        if self.game == GameConstants.MUSECA:
+            return attempt.data.get_int('clear_type') == DBConstants.MUSECA_CLEAR_TYPE_FULL_COMBO
+        if self.game == GameConstants.POPN_MUSIC:
+            return attempt.data.get_int('medal') in [
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FULL_COMBO,
+                DBConstants.POPN_MUSIC_PLAY_MEDAL_PERFECT,
+            ]
+        if self.game == GameConstants.REFLEC_BEAT:
+            return attempt.data.get_int('combo_type') in [
+                DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO,
+                DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO_ALL_JUST,
+            ]
+        if self.game == GameConstants.SDVX:
+            return attempt.data.get_int('clear_type') in [
+                DBConstants.SDVX_CLEAR_TYPE_ULTIMATE_CHAIN,
+                DBConstants.SDVX_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+            ]
+
+        return False
+
+    def __aggregate_global(self, attempts: List[Attempt]) -> List[Dict[str, Any]]:
+        stats: Dict[int, Dict[int, Dict[str, int]]] = {}
+
+        for attempt in attempts:
+            if attempt.id not in stats:
+                stats[attempt.id] = {}
+            if attempt.chart not in stats[attempt.id]:
+                stats[attempt.id][attempt.chart] = {
+                    'plays': 0,
+                    'clears': 0,
+                    'combos': 0,
+                }
+
+            if self.__is_play(attempt):
+                stats[attempt.id][attempt.chart]['plays'] += 1
+            if self.__is_clear(attempt):
+                stats[attempt.id][attempt.chart]['clears'] += 1
+            if self.__is_combo(attempt):
+                stats[attempt.id][attempt.chart]['combos'] += 1
+
+        retval = []
+        for songid in stats:
+            for songchart in stats[songid]:
+                stat = stats[songid][songchart]
+                stat['id'] = songid
+                stat['chart'] = songchart
+                retval.append(self.__format_statistics(stat))
+
+        return retval
+
+    def __aggregate_local(self, cards: Dict[int, List[str]], attempts: List[Tuple[UserID, Attempt]]) -> List[Dict[str, Any]]:
+        stats: Dict[UserID, Dict[int, Dict[int, Dict[str, int]]]] = {}
+
+        for (userid, attempt) in attempts:
+            if userid not in stats:
+                stats[userid] = {}
+            if attempt.id not in stats[userid]:
+                stats[userid][attempt.id] = {}
+            if attempt.chart not in stats[userid][attempt.id]:
+                stats[userid][attempt.id][attempt.chart] = {
+                    'plays': 0,
+                    'clears': 0,
+                    'combos': 0,
+                }
+
+            if self.__is_play(attempt):
+                stats[userid][attempt.id][attempt.chart]['plays'] += 1
+            if self.__is_clear(attempt):
+                stats[userid][attempt.id][attempt.chart]['clears'] += 1
+            if self.__is_combo(attempt):
+                stats[userid][attempt.id][attempt.chart]['combos'] += 1
+
+        retval = []
+        for userid in stats:
+            for songid in stats[userid]:
+                for songchart in stats[userid][songid]:
+                    stat = stats[userid][songid][songchart]
+                    stat['id'] = songid
+                    stat['chart'] = songchart
+                    retval.append(self.__format_user_statistics(cards[userid], stat))
+
+        return retval
+
+    def fetch_v1(self, idtype: str, ids: List[str], params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        retval: List[Dict[str, Any]] = []
+
+        # Fetch the attempts
+        if idtype == APIConstants.ID_TYPE_SERVER:
+            retval = self.__aggregate_global(
+                [attempt[1] for attempt in self.data.local.music.get_all_attempts(self.game, self.music_version)]
+            )
+        elif idtype == APIConstants.ID_TYPE_SONG:
+            if len(ids) == 1:
+                songid = int(ids[0])
+                chart = None
+            else:
+                songid = int(ids[0])
+                chart = int(ids[1])
+            retval = self.__aggregate_global(
+                [attempt[1] for attempt in self.data.local.music.get_all_attempts(self.game, self.music_version, songid=songid, songchart=chart)]
+            )
+        elif idtype == APIConstants.ID_TYPE_INSTANCE:
+            songid = int(ids[0])
+            chart = int(ids[1])
+            cardid = ids[2]
+            userid = self.data.local.user.from_cardid(cardid)
+            if userid is not None:
+                retval = self.__aggregate_local(
+                    {userid: self.data.local.user.get_cards(userid)},
+                    self.data.local.music.get_all_attempts(self.game, self.music_version, songid=songid, songchart=chart, userid=userid)
+                )
+        elif idtype == APIConstants.ID_TYPE_CARD:
+            id_to_cards: Dict[int, List[str]] = {}
+            attempts: List[Tuple[UserID, Attempt]] = []
+            for cardid in ids:
+                userid = self.data.local.user.from_cardid(cardid)
+                if userid is not None:
+                    # Don't duplicate loads for users with multiple card IDs if multiples
+                    # of those IDs are requested.
+                    if userid in id_to_cards:
+                        continue
+
+                    id_to_cards[userid] = self.data.local.user.get_cards(userid)
+                    attempts.extend(
+                        self.data.local.music.get_all_attempts(self.game, self.music_version, userid=userid)
+                    )
+            retval = self.__aggregate_local(id_to_cards, attempts)
+        else:
+            raise APIException('Invalid ID type!')
+
+        return retval
diff --git a/bemani/backend/__init__.py b/bemani/backend/__init__.py
new file mode 100644
index 0000000..1da790c
--- /dev/null
+++ b/bemani/backend/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.dispatch import Dispatch, UnrecognizedPCBIDException
+from bemani.backend.base import Base
diff --git a/bemani/backend/base.py b/bemani/backend/base.py
new file mode 100644
index 0000000..edb90e1
--- /dev/null
+++ b/bemani/backend/base.py
@@ -0,0 +1,434 @@
+import traceback
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type
+
+from bemani.common import Model, ValidatedDict, Time
+from bemani.data import Data, UserID, RemoteUser
+
+
+class ProfileCreationException(Exception):
+    pass
+
+
+class Status:
+    """
+    List of statuses we return to the game for various reasons.
+    """
+    SUCCESS = 0
+    NO_PROFILE = 109
+    NOT_ALLOWED = 110
+    NOT_REGISTERED = 112
+    INVALID_PIN = 116
+
+
+class Factory:
+    """
+    The base class every game factory inherits from. Defines a create method
+    which should return some game class which can handle packets. Game classes
+    inherit from Base, and have handle_<call>_request methods on them that
+    Dispatch will look up in order to handle calls.
+    """
+
+    MANAGED_CLASSES: List[Type["Base"]] = []
+
+    @classmethod
+    def register_all(cls) -> None:
+        """
+        Subclasses of this class should use this function to register themselves
+        with Base, using Base.register(). Factories specify the game code that
+        they support, which Base will use when routing requests.
+        """
+        raise Exception('Override this in subclass!')
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> None:
+        """
+        Subclasses of this class should use this function to run any scheduled
+        work on classes which it is a factory for. This is usually used for
+        out-of-band DB operations such as generating new weekly/daily charts,
+        calculating league scores, etc.
+        """
+        for game in cls.MANAGED_CLASSES:
+            try:
+                events = game.run_scheduled_work(data, config)
+            except Exception:
+                events = []
+                stack = traceback.format_exc()
+                print(stack)
+                data.local.network.put_event(
+                    'exception',
+                    {
+                        'service': 'scheduler',
+                        'traceback': stack,
+                    },
+                )
+            for event in events:
+                data.local.network.put_event(event[0], event[1])
+
+    @classmethod
+    def all_games(cls) -> Iterator[Tuple[str, int, str]]:
+        """
+        Given a particular factory, iterate over all game, version combinations.
+        Useful for loading things from the DB without wanting to hardcode values.
+        """
+        for game in cls.MANAGED_CLASSES:
+            yield (game.game, game.version, game.name)
+
+    @classmethod
+    def all_settings(cls) -> Iterator[Tuple[str, int, Dict[str, Any]]]:
+        """
+        Given a particular factory, iterate over all game, version combinations that
+        have settings and return those settings.
+        """
+        for game in cls.MANAGED_CLASSES:
+            yield (game.game, game.version, game.get_settings())
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional['Base']:
+        """
+        Given a modelstring and an optional parent model, return an instantiated game class that can handle a packet.
+
+        Parameters:
+            data - A Data singleton for DB access
+            config - Configuration dictionary
+            model - A parsed Model, used by game factories to determine which game class to return
+            parentmodel - The parent model doing the requesting. In some cases, games request an older
+                          version game class to migrate profiles. This presents a problem when they don't
+                          specify version strings, because some game lookups are ambiguous without them.
+                          This allows a factory to determine which game to return based on the parent
+                          requesting model, assuming that we want one version back.
+
+        Returns:
+            A subclass of Base that hopefully has a handle_<call>_request method on it, for the particular
+            call that Dispatch wants to resolve, or None if we can't look up a game.
+        """
+        raise Exception('Override this in subclass!')
+
+
+class Base:
+    """
+    The base class every game class inherits from. Incudes handlers for card management, PASELI, most
+    non-game startup packets, and simple code for loading/storing profiles.
+    """
+
+    __registered_games: Dict[str, Type[Factory]] = {}
+    __registered_handlers: Set[Type[Factory]] = set()
+
+    """
+    Override this in your subclass.
+    """
+    game = 'dummy'
+
+    """
+    Override this in your subclass.
+    """
+    version = 0
+
+    """
+    Override this in your subclass.
+    """
+    name = 'dummy'
+
+    def __init__(self, data: Data, config: Dict[str, Any], model: Model) -> None:
+        self.data = data
+        self.config = config
+        self.model = model
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional['Base']:
+        """
+        Given a modelstring and an optional parent model, return an instantiated game class that can handle a packet.
+
+        Note that this is provided here as game factories register with Base to advertise that the will
+        handle some model string. This allows game code to ask for other game classes by model only.
+
+        Parameters:
+            data - A Data singleton for DB access
+            config - Configuration dictionary
+            model - A parsed Model, used by game factories to determine which game class to return
+            parentmodel - The parent model doing the requesting. In some cases, games request an older
+                          version game class to migrate profiles. This presents a problem when they don't
+                          specify version strings, because some game lookups are ambiguous without them.
+                          This allows a factory to determine which game to return based on the parent
+                          requesting model, assuming that we want one version back.
+
+        Returns:
+            A subclass of Base that hopefully has a handle_<call>_request method on it, for the particular
+            call that Dispatch wants to resolve, or an instance of Base itself if no game is registered for
+            this model. Its possible to return None from this function if a registered game has no way of
+            handling this particular modelstring.
+        """
+        if model.game not in cls.__registered_games:
+            # Return just this base model, which will provide nothing
+            return Base(data, config, model)
+        else:
+            # Return the registered module providing this game
+            return cls.__registered_games[model.game].create(data, config, model, parentmodel=parentmodel)
+
+    @classmethod
+    def register(cls, game: str, handler: Type[Factory]) -> None:
+        """
+        Register a factory to handle a game. Note that the game should be the game
+        code as returned by a game, such as "LDJ" or "MDX".
+
+        Parameters:
+            game - 3-character string identifying a game
+            handler - A factory which has a create() method that can spawn game classes.
+        """
+        cls.__registered_games[game] = handler
+        cls.__registered_handlers.add(handler)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Run any out-of-band scheduled work that is applicable to this game.
+        """
+        return []
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return any game settings this game wishes a front-end to modify.
+        """
+        return {}
+
+    @classmethod
+    def all_games(cls) -> Iterator[Tuple[str, int, str]]:
+        """
+        Given all registered factories, iterate over all game, version combinations.
+        Useful for loading things from the DB without wanting to hardcode values.
+        """
+        for factory in cls.__registered_handlers:
+            for game in factory.MANAGED_CLASSES:
+                yield (game.game, game.version, game.name)
+
+    @classmethod
+    def all_settings(cls) -> Iterator[Tuple[str, int, Dict[str, Any]]]:
+        """
+        Given all registered factories, iterate over all game, version combinations that
+        have settings and return those settings.
+        """
+        for factory in cls.__registered_handlers:
+            for game in factory.MANAGED_CLASSES:
+                yield (game.game, game.version, game.get_settings())
+
+    def extra_services(self) -> List[str]:
+        """
+        A list of extra services that this game needs to advertise.
+        Override in your subclass if you need to advertise extra
+        services for a particular game or series.
+        """
+        return []
+
+    def supports_paseli(self) -> bool:
+        """
+        An override so that particular games can disable PASELI support
+        regardless of the server settings. Some games and some regions
+        are buggy with respect to PASELI.
+        """
+        return True
+
+    def bind_profile(self, userid: UserID) -> None:
+        """
+        Handling binding the user's profile to this version on this server.
+
+        Parameters:
+            userid - The user ID we are binding the profile for.
+        """
+
+    def has_profile(self, userid: UserID) -> bool:
+        """
+        Return whether a user has a profile for this game/version on this server.
+
+        Parameters:
+            userid - The user ID we are binding the profile for.
+
+        Returns:
+            True if the profile exists, False if not.
+        """
+        return self.data.local.user.get_profile(self.game, self.version, userid) is not None
+
+    def get_profile(self, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Return the profile for a user given this game/version on any connected server.
+
+        Parameters:
+            userid - The user ID we are getting the profile for.
+
+        Returns:
+            A dictionary representing the user's profile, or None if it doesn't exist.
+        """
+        return self.data.remote.user.get_profile(self.game, self.version, userid)
+
+    def get_any_profile(self, userid: UserID) -> ValidatedDict:
+        """
+        Return ANY profile for a user in a game series.
+
+        Tries to look up the profile for a userid/game/version on any connected server.
+        If that fails, looks for the latest profile that the user has for the current
+        game series. This is usually used for fetching profiles to display names for
+        scores, as users can earn scores on different mixes of games and on remote
+        networks.
+
+        Parameters:
+            userid - The user ID we are getting the profile for.
+
+        Returns:
+            A dictionary representing the user's profile, or an empty dictionary if
+            none was found.
+        """
+        profile = self.data.remote.user.get_any_profile(self.game, self.version, userid)
+        if profile is None:
+            profile = ValidatedDict()
+        return profile
+
+    def get_any_profiles(self, userids: List[UserID]) -> List[Tuple[UserID, ValidatedDict]]:
+        """
+        Does the identical thing to the above function, but takes a list of user IDs to
+        fetch in bulk.
+
+        Parameters:
+            userids - List of user IDs we are getting the profile for.
+
+        Returns:
+            A list of tuples with the User ID and dictionary representing the user's profile,
+            or an empty dictionary if nothing was found.
+        """
+        userids = list(set(userids))
+        profiles = self.data.remote.user.get_any_profiles(self.game, self.version, userids)
+        return [
+            (userid, profile if profile is not None else ValidatedDict())
+            for (userid, profile) in profiles
+        ]
+
+    def put_profile(self, userid: UserID, profile: ValidatedDict) -> None:
+        """
+        Save a new profile for this user given a game/version.
+
+        Parameters:
+            userid - The user ID we are saving the profile for.
+            profile - A dictionary that should be looked up later using get_profile.
+        """
+        if RemoteUser.is_remote(userid):
+            raise Exception('Trying to save a remote profile locally!')
+        self.data.local.user.put_profile(self.game, self.version, userid, profile)
+
+    def update_play_statistics(self, userid: UserID, extra_stats: Optional[Dict[str, Any]]=None) -> None:
+        """
+        Given a user ID, calculate new play statistics.
+
+        Handles keeping track of statistics such as consecutive days played, last
+        play date, times played today, times played total, etc.
+
+        Parameters:
+            userid - The user ID we are binding the profile for.
+        """
+        if RemoteUser.is_remote(userid):
+            raise Exception('Trying to save remote statistics locally!')
+
+        # We store the play statistics in a series-wide settings blob so its available
+        # across all game versions, since it isn't game-specific.
+        settings = self.get_play_statistics(userid)
+
+        if extra_stats is not None:
+            for key in extra_stats:
+                # Make sure we don't override anything we manage here
+                if key in [
+                    'total_plays',
+                    'today_plays',
+                    'total_days',
+                    'first_play_timestamp',
+                    'last_play_timestamp',
+                    'last_play_date',
+                    'consecutive_days',
+                ]:
+                    continue
+                # Safe to copy over
+                settings[key] = extra_stats[key]
+
+        settings.replace_int('total_plays', settings.get_int('total_plays') + 1)
+        settings.replace_int('first_play_timestamp', settings.get_int('first_play_timestamp', int(Time.now())))
+        settings.replace_int('last_play_timestamp', int(Time.now()))
+
+        last_play_date = settings.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        yesterday_play_date = Time.yesterdays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            # We already played today, add one
+            settings.replace_int('today_plays', settings.get_int('today_plays') + 1)
+        else:
+            # We played on a new day, so count total days up
+            settings.replace_int('total_days', settings.get_int('total_days') + 1)
+
+            # We haven't played yet today, reset to one
+            settings.replace_int('today_plays', 1)
+            if (
+                last_play_date[0] == yesterday_play_date[0] and
+                last_play_date[1] == yesterday_play_date[1] and
+                last_play_date[2] == yesterday_play_date[2]
+            ):
+                # We played yesterday, add one to consecutive days
+                settings.replace_int('consecutive_days', settings.get_int('consecutive_days') + 1)
+            else:
+                # We haven't played yet today or yesterday, reset consecutive days
+                settings.replace_int('consecutive_days', 1)
+        settings.replace_int_array('last_play_date', 3, today_play_date)
+
+        # Save back
+        self.data.local.game.put_settings(self.game, userid, settings)
+
+    def get_machine_id(self) -> int:
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        return machine.id
+
+    def update_machine_name(self, newname: Optional[str]) -> None:
+        if newname is None:
+            return
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        machine.name = newname
+        self.data.local.machine.put_machine(machine)
+
+    def update_machine_data(self, newdata: Dict[str, Any]) -> None:
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        machine.data.update(newdata)
+        self.data.local.machine.put_machine(machine)
+
+    def get_game_config(self) -> ValidatedDict:
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine.arcade is not None:
+            settings = self.data.local.machine.get_settings(machine.arcade, self.game, self.version, 'game_config')
+        else:
+            settings = None
+
+        if settings is None:
+            settings = ValidatedDict()
+        return settings
+
+    def get_play_statistics(self, userid: UserID) -> ValidatedDict:
+        """
+        Given a user ID, get the play statistics.
+
+        Note that games wishing to use this when generating profiles to send to
+        a game should call update_play_statistics when parsing a profile save.
+
+        Parameters:
+            userid - The user ID we are binding the profile for.
+
+        Returns a dictionary optionally containing the following attributes:
+            total_plays - Integer count of total plays for this game series
+            first_play_timestamp - Unix timestamp of first play time
+            last_play_timestamp - Unix timestamp of last play time
+            last_play_date - List of ints in the form of [YYYY, MM, DD] of last play date
+            today_plays - Number of times played today
+            total_days - Total individual days played
+            consecutive_days - Number of consecutive days played at this time.
+        """
+        if RemoteUser.is_remote(userid):
+            return ValidatedDict({})
+        settings = self.data.local.game.get_settings(self.game, userid)
+        if settings is None:
+            return ValidatedDict({})
+        return settings
diff --git a/bemani/backend/bishi/__init__.py b/bemani/backend/bishi/__init__.py
new file mode 100644
index 0000000..b61eb13
--- /dev/null
+++ b/bemani/backend/bishi/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.bishi.factory import BishiBashiFactory
+from bemani.backend.bishi.base import BishiBashiBase
diff --git a/bemani/backend/bishi/base.py b/bemani/backend/bishi/base.py
new file mode 100644
index 0000000..d7ace86
--- /dev/null
+++ b/bemani/backend/bishi/base.py
@@ -0,0 +1,23 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import GameConstants
+
+
+class BishiBashiBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all one Bishi Bashi version that we support (lol).
+    In theory we could add support for Bishi Bashi Channel, but that never
+    happened.
+    """
+
+    game = GameConstants.BISHI_BASHI
+
+    def previous_version(self) -> Optional['BishiBashiBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
diff --git a/bemani/backend/bishi/bishi.py b/bemani/backend/bishi/bishi.py
new file mode 100644
index 0000000..04e3457
--- /dev/null
+++ b/bemani/backend/bishi/bishi.py
@@ -0,0 +1,208 @@
+# vim: set fileencoding=utf-8
+import binascii
+import copy
+import base64
+from typing import Any, Dict, List
+
+from bemani.backend.bishi.base import BishiBashiBase
+from bemani.backend.ess import EventLogHandler
+from bemani.common import ValidatedDict, GameConstants, VersionConstants
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class TheStarBishiBashi(
+    EventLogHandler,
+    BishiBashiBase,
+):
+
+    name = "The★BishiBashi"
+    version = VersionConstants.BISHI_BASHI_TSBB
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Unlock Characters',
+                    'tip': 'Force unlock all characters on select screen.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_characters',
+                },
+            ],
+        }
+
+    def __update_shop_name(self, profiledata: bytes) -> None:
+        # Figure out the profile type
+        csvs = profiledata.split(b',')
+        if len(csvs) < 2:
+            # Not long enough to care about
+            return
+        datatype = csvs[1].decode('ascii')
+        if datatype != 'IBBDAT00':
+            # Not the right profile type requested
+            return
+
+        # Grab the shop name
+        try:
+            shopname = csvs[30].decode('shift-jis')
+        except Exception:
+            return
+        self.update_machine_name(shopname)
+
+    def handle_system_getmaster_request(self, request: Node) -> Node:
+        # System message
+        root = Node.void('system')
+        root.add_child(Node.s32('result', 0))
+        return root
+
+    def handle_playerdata_usergamedata_send_request(self, request: Node) -> Node:
+        # Look up user by refid
+        refid = request.child_value('data/eaid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            root = Node.void('playerdata')
+            root.add_child(Node.s32('result', 1))  # Unclear if this is the right thing to do here.
+            return root
+
+        # Extract new profile info from old profile
+        oldprofile = self.get_profile(userid)
+        is_new = False
+        if oldprofile is None:
+            oldprofile = ValidatedDict()
+            is_new = True
+        newprofile = self.unformat_profile(userid, request, oldprofile, is_new)
+
+        # Write new profile
+        self.put_profile(userid, newprofile)
+
+        # Return success!
+        root = Node.void('playerdata')
+        root.add_child(Node.s32('result', 0))
+        return root
+
+    def handle_playerdata_usergamedata_recv_request(self, request: Node) -> Node:
+        # Look up user by refid
+        refid = request.child_value('data/eaid')
+        profiletype = request.child_value('data/recv_csv').split(',')[0]
+        profile = None
+        userid = None
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+        if profile is not None:
+            return self.format_profile(userid, profiletype, profile)
+        else:
+            root = Node.void('playerdata')
+            root.add_child(Node.s32('result', 1))  # Unclear if this is the right thing to do here.
+            return root
+
+    def format_profile(self, userid: UserID, profiletype: str, profile: ValidatedDict) -> Node:
+        root = Node.void('playerdata')
+        root.add_child(Node.s32('result', 0))
+        player = Node.void('player')
+        root.add_child(player)
+        records = 0
+
+        for i in range(len(profile['strdatas'])):
+            strdata = profile['strdatas'][i]
+            bindata = profile['bindatas'][i]
+
+            # Figure out the profile type
+            csvs = strdata.split(b',')
+            if len(csvs) < 2:
+                # Not long enough to care about
+                continue
+            datatype = csvs[1].decode('ascii')
+            if datatype != profiletype:
+                # Not the right profile type requested
+                continue
+
+            game_config = self.get_game_config()
+            force_unlock_characters = game_config.get_bool('force_unlock_characters')
+            if force_unlock_characters:
+                csvs[11] = b'3ffffffffffff'
+            else:
+                # Reward characters based on playing other games on the network
+                hexdata = csvs[11].decode('ascii')
+                while (len(hexdata) & 1) != 0:
+                    hexdata = '0' + hexdata
+                unlock_bits = [b for b in binascii.unhexlify(hexdata)]
+                while len(unlock_bits) < 7:
+                    unlock_bits.insert(0, 0)
+
+                # Reverse the array, so indexing makes more sense
+                unlock_bits = unlock_bits[::-1]
+
+                # Figure out what other games were played by this user
+                profiles = self.data.local.user.get_games_played(userid)
+
+                # IIDX
+                if len([p for p in profiles if p[0] == GameConstants.IIDX]) > 0:
+                    unlock_bits[1] = unlock_bits[1] | 0x10
+
+                # Pop'n
+                if len([p for p in profiles if p[0] == GameConstants.POPN_MUSIC]) > 0:
+                    unlock_bits[1] = unlock_bits[1] | 0x60
+
+                # Jubeat
+                if len([p for p in profiles if p[0] == GameConstants.JUBEAT]) > 0:
+                    unlock_bits[2] = unlock_bits[2] | 0x02
+
+                # DDR
+                if len([p for p in profiles if p[0] == GameConstants.DDR]) > 0:
+                    unlock_bits[6] = unlock_bits[6] | 0x03
+
+                # GFDM characters exist, but this network has no support for
+                # GFDM or Gitadora, so the bits were never added.
+
+                # Reconstruct table
+                unlock_bits = unlock_bits[::-1]
+                csvs[11] = ''.join(['{:02x}'.format(x) for x in unlock_bits]).encode('ascii')
+
+            # This is a valid profile node for this type, lets return only the profile values
+            strdata = b','.join(csvs[2:])
+            record = Node.void('record')
+            player.add_child(record)
+            d = Node.string('d', base64.b64encode(strdata).decode('ascii'))
+            record.add_child(d)
+            d.add_child(Node.string('bin1', base64.b64encode(bindata).decode('ascii')))
+
+            # Remember that we had this record
+            records = records + 1
+
+        player.add_child(Node.u32('record_num', records))
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict, is_new: bool) -> ValidatedDict:
+        # Profile save request, data values are base64 encoded.
+        # d is a CSV, and bin1 is binary data.
+        newprofile = copy.deepcopy(oldprofile)
+        strdatas: List[bytes] = []
+        bindatas: List[bytes] = []
+
+        record = request.child('data/record')
+        for node in record.children:
+            if node.name != 'd':
+                continue
+
+            profile = base64.b64decode(node.value)
+            # Update the shop name if this is a new profile, since we know it came
+            # from this cabinet. This is the only source of truth for what the
+            # cabinet shop name is set to.
+            if is_new:
+                self.__update_shop_name(profile)
+            strdatas.append(profile)
+            bindatas.append(base64.b64decode(node.child_value('bin1')))
+
+        newprofile['strdatas'] = strdatas
+        newprofile['bindatas'] = bindatas
+
+        # Keep track of play statistics across all versions
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/bishi/factory.py b/bemani/backend/bishi/factory.py
new file mode 100644
index 0000000..f32620e
--- /dev/null
+++ b/bemani/backend/bishi/factory.py
@@ -0,0 +1,27 @@
+from typing import Dict, Optional, Any
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.bishi.bishi import TheStarBishiBashi
+from bemani.common import Model
+from bemani.data import Data
+
+
+class BishiBashiFactory(Factory):
+
+    MANAGED_CLASSES = [
+        TheStarBishiBashi,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['IBB']:
+            Base.register(game, BishiBashiFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        if model.game == 'IBB':
+            return TheStarBishiBashi(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/core/__init__.py b/bemani/backend/core/__init__.py
new file mode 100644
index 0000000..9c39e10
--- /dev/null
+++ b/bemani/backend/core/__init__.py
@@ -0,0 +1,3 @@
+from bemani.backend.core.core import CoreHandler
+from bemani.backend.core.cardmng import CardManagerHandler
+from bemani.backend.core.eacoin import PASELIHandler
diff --git a/bemani/backend/core/cardmng.py b/bemani/backend/core/cardmng.py
new file mode 100644
index 0000000..8812db7
--- /dev/null
+++ b/bemani/backend/core/cardmng.py
@@ -0,0 +1,116 @@
+from typing import Optional
+
+from bemani.backend.base import Base, Status
+from bemani.protocol import Node
+from bemani.common import Model
+
+
+class CardManagerHandler(Base):
+    """
+    The class that handles card management. This assumes it is attached as a mixin to a game
+    class so that it can understand if there's a profile for a game or not.
+    """
+
+    def handle_cardmng_request(self, request: Node) -> Optional[Node]:
+        """
+        Handle a request for card management. This is independent of a game's profile handling,
+        but still gives the game information as to whether or not a profile exists for a game.
+        These methods handle looking up a card, handling binding a profile to a game version,
+        returning whether a game profile exists or should be migrated, and creating a new account
+        when no account is associated with a card.
+        """
+        method = request.attribute('method')
+
+        if method == 'inquire':
+            # Given a cardid, look up the dataid/refid (same thing in this system).
+            # If the card doesn't exist or isn't allowed, return a status specifying this
+            # instead of the results of the dataid/refid lookup.
+            cardid = request.attribute('cardid')
+            modelstring = request.attribute('model')
+            userid = self.data.local.user.from_cardid(cardid)
+
+            if userid is None:
+                # This user doesn't exist, force system to create new account
+                root = Node.void('cardmng')
+                root.set_attribute('status', str(Status.NOT_REGISTERED))
+                return root
+
+            # Special handling for looking up whether the previous game's profile existed
+            bound = self.has_profile(userid)
+            expired = False
+            if bound is False:
+                if modelstring is not None:
+                    model = Model.from_modelstring(modelstring)
+                    oldgame = Base.create(self.data, self.config, model, self.model)
+                    if oldgame is None:
+                        bound = False
+                    else:
+                        bound = oldgame.has_profile(userid)
+                        expired = True
+
+            refid = self.data.local.user.get_refid(self.game, self.version, userid)
+            paseli_enabled = self.supports_paseli() and self.config['paseli']['enabled']
+
+            root = Node.void('cardmng')
+            root.set_attribute('refid', refid)
+            root.set_attribute('dataid', refid)
+            root.set_attribute('newflag', '1')  # Always seems to be set to 1
+            root.set_attribute('binded', '1' if bound else '0')  # Whether we've bound to this version of the game or not
+            root.set_attribute('expired', '1' if expired else '0')  # Whether we're expired
+            root.set_attribute('ecflag', '1' if paseli_enabled else '0')  # Whether to allow paseli
+            root.set_attribute('useridflag', '1')
+            root.set_attribute('extidflag', '1')
+            return root
+
+        elif method == 'authpass':
+            # Given a dataid/refid previously found via inquire, verify the pin
+            refid = request.attribute('refid')
+            pin = request.attribute('pass')
+            userid = self.data.local.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                valid = self.data.local.user.validate_pin(userid, pin)
+            else:
+                valid = False
+            root = Node.void('cardmng')
+            root.set_attribute('status', str(Status.SUCCESS if valid else Status.INVALID_PIN))
+            return root
+
+        elif method == 'getrefid':
+            # Given a cardid and a pin, register the card with the system and generate a new dataid/refid + extid
+            cardid = request.attribute('cardid')
+            pin = request.attribute('passwd')
+            userid = self.data.local.user.create_account(cardid, pin)
+            if userid is None:
+                # This user can't be created
+                root = Node.void('cardmng')
+                root.set_attribute('status', str(Status.NOT_ALLOWED))
+                return root
+
+            refid = self.data.local.user.create_refid(self.game, self.version, userid)
+            root = Node.void('cardmng')
+            root.set_attribute('dataid', refid)
+            root.set_attribute('refid', refid)
+            return root
+
+        elif method == 'bindmodel':
+            # Given a refid, bind the user's card to the current version of the game
+            refid = request.attribute('refid')
+            userid = self.data.local.user.from_refid(self.game, self.version, refid)
+            self.bind_profile(userid)
+            root = Node.void('cardmng')
+            root.set_attribute('dataid', refid)
+            return root
+
+        elif method == 'getkeepspan':
+            # Unclear what this method does, return an arbitrary span
+            root = Node.void('cardmng')
+            root.set_attribute('keepspan', '30')
+            return root
+
+        elif method == 'getdatalist':
+            # Unclear what this method does, return a dummy response
+            root = Node.void('cardmng')
+            return root
+
+        # Invalid method
+        return None
diff --git a/bemani/backend/core/core.py b/bemani/backend/core/core.py
new file mode 100644
index 0000000..e46e97b
--- /dev/null
+++ b/bemani/backend/core/core.py
@@ -0,0 +1,187 @@
+import socket
+
+from bemani.backend.base import Base
+from bemani.protocol import Node
+from bemani.common import ID
+
+
+class CoreHandler(Base):
+    """
+    Implements the core packets that are shared across all games.
+    """
+
+    def handle_services_get_request(self, request: Node) -> Node:
+        """
+        Handles a game request for services.get. This should return the URL of
+        each server which handles a particular service. For us, this is always
+        our URL since we serve everything.
+        """
+        def item(name: str, url: str) -> Node:
+            node = Node.void('item')
+            node.set_attribute('name', name)
+            node.set_attribute('url', url)
+            return node
+
+        url = '{}://{}:{}/'.format(
+            'https' if self.config['server']['https'] else 'http',
+            self.config['server']['address'],
+            self.config['server']['port'],
+        )
+        root = Node.void('services')
+        root.set_attribute('expire', '600')
+        # This can be set to 'operation', 'debug', 'test', and 'factory'.
+        root.set_attribute('mode', 'operation')
+        root.set_attribute('product_domain', '1')
+
+        root.add_child(item('cardmng', url))
+        root.add_child(item('dlstatus', url))
+        root.add_child(item('eacoin', url))
+        root.add_child(item('facility', url))
+        root.add_child(item('lobby', url))
+        root.add_child(item('local', url))
+        root.add_child(item('message', url))
+        root.add_child(item('package', url))
+        root.add_child(item('pcbevent', url))
+        root.add_child(item('pcbtracker', url))
+        root.add_child(item('pkglist', url))
+        root.add_child(item('posevent', url))
+        for srv in self.extra_services():
+            root.add_child(item(srv, url))
+
+        root.add_child(item('ntp', 'ntp://pool.ntp.org/'))
+        # Look up keepalive override if exists, otherwise use the server address
+        if 'keepalive' in self.config['server']:
+            keepalive = self.config['server']['keepalive']
+        else:
+            keepalive = self.config['server']['address']
+        # Translate to a raw IP because we can't give out a host here
+        keepalive = socket.gethostbyname(keepalive)
+        root.add_child(item(
+            'keepalive',
+            'http://{}/core/keepalive?pa={}&ia={}&ga={}&ma={}&t1=2&t2=10'.format(
+                keepalive,
+                keepalive,
+                keepalive,
+                keepalive,
+                keepalive,
+            ),
+        ))
+        return root
+
+    def handle_pcbtracker_alive_request(self, request: Node) -> Node:
+        """
+        Handle a PCBTracker.alive request. The only method of note is the 'alive' method
+        which returns whether PASELI should be active or not for this session.
+        """
+        # Reports that a machine is booting. Overloaded to enable/disable paseli
+        root = Node.void('pcbtracker')
+        root.set_attribute('ecenable', '1' if (self.supports_paseli() and self.config['paseli']['enabled']) else '0')
+        root.set_attribute('expire', '600')
+        return root
+
+    def handle_pcbevent_put_request(self, request: Node) -> Node:
+        """
+        Handle a PCBEvent request. We do nothing for this aside from logging the event.
+        """
+        for item in request.children:
+            if item.name == 'item':
+                name = item.child_value('name')
+                value = item.child_value('value')
+                timestamp = item.child_value('time')
+                self.data.local.network.put_event(
+                    'pcbevent',
+                    {
+                        'name': name,
+                        'value': value,
+                        'model': str(self.model),
+                        'pcbid': self.config['machine']['pcbid'],
+                        'ip': self.config['client']['address'],
+                    },
+                    timestamp=timestamp,
+                )
+
+        return Node.void('pcbevent')
+
+    def handle_package_list_request(self, request: Node) -> Node:
+        """
+        Handle a Package request. This is for supporting downloading of updates.
+        We don't support this at the moment.
+        """
+        # List all available update packages on the server
+        root = Node.void('package')
+        root.set_attribute('expire', '600')
+        return root
+
+    def handle_message_get_request(self, request: Node) -> Node:
+        """
+        I have absolutely no fucking idea what this does, but it might be for
+        operator messages?
+        """
+        root = Node.void('message')
+        root.set_attribute('expire', '600')
+        return root
+
+    def handle_dlstatus_progress_request(self, request: Node) -> Node:
+        """
+        I have absolutely no fucking idea what this does either, download
+        status reports maybe?
+        """
+        return Node.void('dlstatus')
+
+    def handle_facility_get_request(self, request: Node) -> Node:
+        """
+        Handle a facility request. The only method of note is the 'get' request,
+        which expects to return a bunch of information about the arcade this
+        cabinet is in, as well as some settings for URLs and the name of the cab.
+        """
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+
+        root = Node.void('facility')
+        root.set_attribute('expire', '600')
+        location = Node.void('location')
+        location.add_child(Node.string('id', ID.format_machine_id(machine.id)))
+        location.add_child(Node.string('country', 'US'))
+        location.add_child(Node.string('region', '.'))
+        location.add_child(Node.string('name', machine.name))
+        location.add_child(Node.u8('type', 0))
+
+        line = Node.void('line')
+        line.add_child(Node.string('id', '.'))
+        line.add_child(Node.u8('class', 0))
+
+        portfw = Node.void('portfw')
+        portfw.add_child(Node.ipv4('globalip', self.config['client']['address']))
+        portfw.add_child(Node.u16('globalport', machine.port))
+        portfw.add_child(Node.u16('privateport', machine.port))
+
+        public = Node.void('public')
+        public.add_child(Node.u8('flag', 1))
+        public.add_child(Node.string('name', '.'))
+        public.add_child(Node.string('latitude', '0'))
+        public.add_child(Node.string('longitude', '0'))
+
+        share = Node.void('share')
+        eacoin = Node.void('eacoin')
+        eacoin.add_child(Node.s32('notchamount', 3000))
+        eacoin.add_child(Node.s32('notchcount', 3))
+        eacoin.add_child(Node.s32('supplylimit', 10000))
+
+        eapass = Node.void('eapass')
+        eapass.add_child(Node.u16('valid', 365))
+
+        url = Node.void('url')
+        url.add_child(Node.string('eapass', self.config['server']['uri'] or 'www.ea-pass.konami.net'))
+        url.add_child(Node.string('arcadefan', self.config['server']['uri'] or 'www.konami.jp/am'))
+        url.add_child(Node.string('konaminetdx', self.config['server']['uri'] or 'http://am.573.jp'))
+        url.add_child(Node.string('konamiid', self.config['server']['uri'] or 'https://id.konami.net'))
+        url.add_child(Node.string('eagate', self.config['server']['uri'] or 'http://eagate.573.jp'))
+
+        share.add_child(eacoin)
+        share.add_child(url)
+        share.add_child(eapass)
+        root.add_child(location)
+        root.add_child(line)
+        root.add_child(portfw)
+        root.add_child(public)
+        root.add_child(share)
+        return root
diff --git a/bemani/backend/core/eacoin.py b/bemani/backend/core/eacoin.py
new file mode 100644
index 0000000..36a5a7e
--- /dev/null
+++ b/bemani/backend/core/eacoin.py
@@ -0,0 +1,439 @@
+from typing import Optional
+
+from bemani.backend.base import Base, Status
+from bemani.protocol import Node
+from bemani.common import Time, CardCipher
+
+
+class PASELIHandler(Base):
+    """
+    A mixin that can be used to provide PASELI services to a game.
+    """
+
+    INFINITE_PASELI_AMOUNT = 57300
+
+    """
+    Override this in your subclass if the particular game/series
+    needs a different padding amount to display PASELI transactions
+    on the operator menu.
+    """
+    paseli_padding = 1
+
+    def handle_eacoin_request(self, request: Node) -> Optional[Node]:
+        """
+        Handle PASELI requests. The game will check out a session at the beginning
+        of the game, make PASELI purchases against that session, and then close it
+        ad the end of of a game. This handler ensures that this works for all games.
+        """
+        method = request.attribute('method')
+
+        if not self.config['paseli']['enabled']:
+            # Refuse to respond, we don't have PASELI enabled
+            print("PASELI not enabled, ignoring eacoin request")
+            root = Node.void('eacoin')
+            root.set_attribute('status', str(Status.NOT_ALLOWED))
+            return root
+
+        if method == 'checkin':
+            root = Node.void('eacoin')
+            cardid = request.child_value('cardid')
+            pin = request.child_value('passwd')
+
+            if cardid is None or pin is None:
+                # Refuse to return anything
+                print("Invalid eacoin checkin request, missing cardid or pin")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            userid = self.data.local.user.from_cardid(cardid)
+            if userid is None:
+                # Refuse to do anything
+                print("No user for eacoin checkin request")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            valid = self.data.local.user.validate_pin(userid, pin)
+            if not valid:
+                # Refuse to do anything
+                print("User entered invalid pin for eacoin checkin request")
+                root.set_attribute('status', str(Status.INVALID_PIN))
+                return root
+
+            session = self.data.local.user.create_session(userid)
+
+            if self.config['paseli']['infinite']:
+                balance = PASELIHandler.INFINITE_PASELI_AMOUNT
+            else:
+                if self.config['machine']['arcade'] is None:
+                    # There's no arcade for this machine, but infinite is not
+                    # enabled, so there's no way to find a balance.
+                    balance = 0
+                else:
+                    balance = self.data.local.user.get_balance(userid, self.config['machine']['arcade'])
+
+            root.add_child(Node.s16('sequence', 0))
+            root.add_child(Node.u8('acstatus', 0))
+            root.add_child(Node.string('acid', 'DUMMY_ID'))
+            root.add_child(Node.string('acname', 'DUMMY_NAME'))
+            root.add_child(Node.s32('balance', balance))
+            root.add_child(Node.string('sessid', session))
+            return root
+
+        if method == 'opcheckin':
+            root = Node.void('eacoin')
+            passwd = request.child_value('passwd')
+
+            if passwd is None:
+                # Refuse to return anything
+                print("Invalid eacoin checkin request, missing passwd")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            if self.config['machine']['arcade'] is None:
+                # Machine doesn't belong to an arcade
+                print("Machine doesn't belong to an arcade")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            arcade = self.data.local.machine.get_arcade(self.config['machine']['arcade'])
+            if arcade is None:
+                # Refuse to do anything
+                print("No arcade for operator checkin request")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            if arcade.pin != passwd:
+                # Refuse to do anything
+                print("User entered invalid pin for operator checkin request")
+                root.set_attribute('status', str(Status.INVALID_PIN))
+                return root
+
+            session = self.data.local.machine.create_session(arcade.id)
+            root.add_child(Node.string('sessid', session))
+            return root
+
+        elif method == 'consume':
+
+            def make_resp(status: int, balance: int) -> Node:
+                root = Node.void('eacoin')
+                root.add_child(Node.u8('acstatus', status))
+                root.add_child(Node.u8('autocharge', 0))
+                root.add_child(Node.s32('balance', balance))
+                return root
+
+            session = request.child_value('sessid')
+            payment = request.child_value('payment')
+            service = request.child_value('service')
+            details = request.child_value('detail')
+            if session is None or payment is None:
+                # Refuse to do anything
+                print("Invalid eacoin consume request, missing sessid or payment")
+                return make_resp(2, 0)
+
+            userid = self.data.local.user.from_session(session)
+            if session is None:
+                # Refuse to do anything
+                print("Invalid session for eacoin consume request")
+                return make_resp(2, 0)
+
+            if self.config['paseli']['infinite']:
+                balance = PASELIHandler.INFINITE_PASELI_AMOUNT - payment
+            else:
+                if self.config['machine']['arcade'] is None:
+                    # There's no arcade for this machine, but infinite is not
+                    # enabled, so there's no way to find a balance, assume failed
+                    # consume payment.
+                    balance = None
+                else:
+                    # Look up the new balance based on this delta. If there isn't enough,
+                    # we will end up returning None here and exit without performing.
+                    balance = self.data.local.user.update_balance(userid, self.config['machine']['arcade'], -payment)
+
+                if balance is None:
+                    print("Not enough balance for eacoin consume request")
+                    return make_resp(1, self.data.local.user.get_balance(userid, self.config['machine']['arcade']))
+                else:
+                    self.data.local.network.put_event(
+                        'paseli_transaction',
+                        {
+                            'delta': -payment,
+                            'balance': balance,
+                            'service': -service,
+                            'reason': details,
+                            'pcbid': self.config['machine']['pcbid'],
+                        },
+                        userid=userid,
+                        arcadeid=self.config['machine']['arcade'],
+                    )
+
+            return make_resp(0, balance)
+
+        elif method == 'getlog':
+            root = Node.void('eacoin')
+            sessid = request.child_value('sessid')
+            logtype = request.child_value('logtype')
+            target = request.child_value('target')
+            limit = request.child_value('perpage')
+            offset = request.child_value('offset')
+
+            # Try to determine whether its a user or an arcade session
+            userid = self.data.local.user.from_session(sessid)
+            if userid is None:
+                arcadeid = self.data.local.machine.from_session(sessid)
+            else:
+                arcadeid = None
+
+            # Bail out if we don't have any idea what session this is
+            if userid is None and arcadeid is None:
+                print("Unable to determine session type")
+                return root
+
+            # If we're a user session, also look up the current arcade
+            # so we display only entries that happened on this arcade.
+            if userid is not None:
+                arcade = self.data.local.machine.get_arcade(self.config['machine']['arcade'])
+                if arcade is None:
+                    print("Machine doesn't belong to an arcade")
+                    return root
+                arcadeid = arcade.id
+
+            # Now, look up all transactions for this specific group
+            events = self.data.local.network.get_events(
+                userid=userid,
+                arcadeid=arcadeid,
+                event='paseli_transaction',
+            )
+
+            # Further filter it down to the current PCBID
+            events = [event for event in events if event.data.get('pcbid') == target]
+
+            # Grab the end of day today as a timestamp
+            end_of_today = Time.end_of_today()
+            time_format = '%Y-%m-%d %H:%M:%S'
+            date_format = '%Y-%m-%d'
+
+            # Set up common structure
+            lognode = Node.void(logtype)
+            topic = Node.void('topic')
+            lognode.add_child(topic)
+            summary = Node.void('summary')
+            lognode.add_child(summary)
+
+            # Display what day we are summed to
+            topic.add_child(Node.string('sumdate', Time.format(Time.now(), date_format)))
+
+            if logtype == 'last7days':
+                # We show today in the today total, last 7 days prior in the week total
+                beginning_of_today = end_of_today - Time.SECONDS_IN_DAY
+                end_of_week = beginning_of_today
+                beginning_of_week = end_of_week - Time.SECONDS_IN_WEEK
+
+                topic.add_child(Node.string('sumfrom', Time.format(beginning_of_week, date_format)))
+                topic.add_child(Node.string('sumto', Time.format(end_of_week, date_format)))
+                today_total = sum([
+                    -event.data.get_int('delta') for event in events
+                    if event.timestamp >= beginning_of_today and event.timestamp < end_of_today
+                ])
+
+                today_total = sum([
+                    -event.data.get_int('delta') for event in events
+                    if event.timestamp >= beginning_of_today and event.timestamp < end_of_today
+                ])
+                week_txns = [
+                    -event.data.get_int('delta') for event in events
+                    if event.timestamp >= beginning_of_week and event.timestamp < end_of_week
+                ]
+                week_total = sum(week_txns)
+                if len(week_txns) > 0:
+                    week_avg = int(sum(week_txns) / len(week_txns))
+                else:
+                    week_avg = 0
+
+                # We display the totals for each day starting with yesterday and up through 7 days prior.
+                # Index starts at 0 = yesterday, 1 = the day before, etc...
+                items = []
+                for days in range(0, 7):
+                    end_of_day = end_of_week - (days * Time.SECONDS_IN_DAY)
+                    start_of_day = end_of_day - Time.SECONDS_IN_DAY
+
+                    items.append(sum([
+                        -event.data.get_int('delta') for event in events
+                        if event.timestamp >= start_of_day and event.timestamp < end_of_day
+                    ]))
+
+                topic.add_child(Node.s32('today', today_total))
+                topic.add_child(Node.s32('average', week_avg))
+                topic.add_child(Node.s32('total', week_total))
+                summary.add_child(Node.s32_array('items', items))
+
+            if logtype == 'last52weeks':
+                # Start one week back, since the operator can look at last7days for newer stuff.
+                beginning_of_today = end_of_today - Time.SECONDS_IN_DAY
+                end_of_52_weeks = beginning_of_today - Time.SECONDS_IN_WEEK
+
+                topic.add_child(Node.string('sumfrom', Time.format(end_of_52_weeks - (52 * Time.SECONDS_IN_WEEK), date_format)))
+                topic.add_child(Node.string('sumto', Time.format(end_of_52_weeks, date_format)))
+
+                # We index backwards, where index 0 = the first week back, 1 = the next week back after that, etc...
+                items = []
+                for weeks in range(0, 52):
+                    end_of_range = end_of_52_weeks - (weeks * Time.SECONDS_IN_WEEK)
+                    beginning_of_range = end_of_range - Time.SECONDS_IN_WEEK
+
+                    items.append(sum([
+                        -event.data.get_int('delta') for event in events
+                        if event.timestamp >= beginning_of_range and event.timestamp < end_of_range
+                    ]))
+
+                summary.add_child(Node.s32_array('items', items))
+
+            if logtype == 'eachday':
+                start_ts = Time.now()
+                end_ts = Time.now()
+                weekdays = [0] * 7
+
+                for event in events:
+                    event_day = Time.days_into_week(event.timestamp)
+                    weekdays[event_day] = weekdays[event_day] - event.data.get_int('delta')
+                    if event.timestamp < start_ts:
+                        start_ts = event.timestamp
+
+                topic.add_child(Node.string('sumfrom', Time.format(start_ts, date_format)))
+                topic.add_child(Node.string('sumto', Time.format(end_ts, date_format)))
+                summary.add_child(Node.s32_array('items', weekdays))
+
+            if logtype == 'eachhour':
+                start_ts = Time.now()
+                end_ts = Time.now()
+                hours = [0] * 24
+
+                for event in events:
+                    event_hour = int((event.timestamp % Time.SECONDS_IN_DAY) / Time.SECONDS_IN_HOUR)
+                    hours[event_hour] = hours[event_hour] - event.data.get_int('delta')
+                    if event.timestamp < start_ts:
+                        start_ts = event.timestamp
+
+                topic.add_child(Node.string('sumfrom', Time.format(start_ts, date_format)))
+                topic.add_child(Node.string('sumto', Time.format(end_ts, date_format)))
+                summary.add_child(Node.s32_array('items', hours))
+
+            if logtype == 'detail':
+                history = Node.void('history')
+                lognode.add_child(history)
+
+                # Respect details paging
+                if offset is not None:
+                    events = events[offset:]
+                if limit is not None:
+                    events = events[:limit]
+
+                # Output the details themselves
+                for event in events:
+                    card_no = ''
+                    if event.userid is not None:
+                        user = self.data.local.user.get_user(event.userid)
+                        if user is not None:
+                            cards = self.data.local.user.get_cards(user.id)
+                            if len(cards) > 0:
+                                card_no = CardCipher.encode(cards[0])
+
+                    item = Node.void('item')
+                    history.add_child(item)
+                    item.add_child(Node.string('date', Time.format(event.timestamp, time_format)))
+                    item.add_child(Node.s32('consume', -event.data.get_int('delta')))
+                    item.add_child(Node.s32('service', -event.data.get_int('service')))
+                    item.add_child(Node.string('cardtype', ''))
+                    item.add_child(Node.string('cardno', ' ' * self.paseli_padding + card_no))
+                    item.add_child(Node.string('title', ''))
+                    item.add_child(Node.string('systemid', ''))
+
+            if logtype == 'lastmonths':
+                year, month, _ = Time.todays_date()
+                this_month = Time.timestamp_from_date(year, month)
+                last_month = Time.timestamp_from_date(year, month - 1)
+                month_before = Time.timestamp_from_date(year, month - 2)
+
+                topic.add_child(Node.string('sumfrom', Time.format(month_before, date_format)))
+                topic.add_child(Node.string('sumto', Time.format(this_month, date_format)))
+
+                for (start, end) in [(month_before, last_month), (last_month, this_month)]:
+                    year, month, _ = Time.date_from_timestamp(start)
+
+                    items = []
+                    for day in range(0, 31):
+                        begin_ts = start + (day * Time.SECONDS_IN_DAY)
+                        end_ts = begin_ts + Time.SECONDS_IN_DAY
+                        if begin_ts >= end:
+                            # Passed the end of this month
+                            items.append(0)
+                        else:
+                            # Sum up all the txns for this day
+                            items.append(sum([
+                                -event.data.get_int('delta') for event in events
+                                if event.timestamp >= begin_ts and event.timestamp < end_ts
+                            ]))
+
+                    item = Node.void('item')
+                    summary.add_child(item)
+                    item.add_child(Node.s32('year', year))
+                    item.add_child(Node.s32('month', month))
+                    item.add_child(Node.s32_array('items', items))
+
+            root.add_child(Node.u8('processing', 0))
+            root.add_child(lognode)
+            return root
+
+        elif method == 'opchpass':
+            root = Node.void('eacoin')
+            oldpass = request.child_value('passwd')
+            newpass = request.child_value('newpasswd')
+
+            if oldpass is None or newpass is None:
+                # Refuse to return anything
+                print("Invalid eacoin pass change request, missing passwd")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            if self.config['machine']['arcade'] is None:
+                # Machine doesn't belong to an arcade
+                print("Machine doesn't belong to an arcade")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            arcade = self.data.local.machine.get_arcade(self.config['machine']['arcade'])
+            if arcade is None:
+                # Refuse to do anything
+                print("No arcade for operator pass change request")
+                root.set_attribute('status', str(Status.NO_PROFILE))
+                return root
+
+            if arcade.pin != oldpass:
+                # Refuse to do anything
+                print("User entered invalid pin for operator pass change request")
+                root.set_attribute('status', str(Status.INVALID_PIN))
+                return root
+
+            arcade.pin = newpass
+            self.data.local.machine.put_arcade(arcade)
+            return root
+
+        elif method == 'checkout':
+            session = request.child_value('sessid')
+            if session is not None:
+                # Destroy the session so it can't be used for any other purchases
+                self.data.local.user.destroy_session(session)
+
+            root = Node.void('eacoin')
+            return root
+
+        elif method == 'opcheckout':
+            session = request.child_value('sessid')
+            if session is not None:
+                # Destroy the session so it can't be used for any other purchases
+                self.data.local.machine.destroy_session(session)
+
+            root = Node.void('eacoin')
+            return root
+
+        # Invalid method
+        return None
diff --git a/bemani/backend/ddr/__init__.py b/bemani/backend/ddr/__init__.py
new file mode 100644
index 0000000..63712bd
--- /dev/null
+++ b/bemani/backend/ddr/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.ddr.factory import DDRFactory
+from bemani.backend.ddr.base import DDRBase
diff --git a/bemani/backend/ddr/base.py b/bemani/backend/ddr/base.py
new file mode 100644
index 0000000..70582eb
--- /dev/null
+++ b/bemani/backend/ddr/base.py
@@ -0,0 +1,345 @@
+# vim: set fileencoding=utf-8
+from typing import Optional, Dict, List, Any
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import Model, ValidatedDict, GameConstants, DBConstants, Time
+from bemani.data import Data, Score, UserID, ScoreSaveException
+from bemani.protocol import Node
+
+
+class DDRBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all DDR versions. Handles common functionality for getting
+    profiles based on refid, creating new profiles, looking up and saving scores.
+    """
+
+    game = GameConstants.DDR
+
+    HALO_NONE = DBConstants.DDR_HALO_NONE
+    HALO_GOOD_FULL_COMBO = DBConstants.DDR_HALO_GOOD_FULL_COMBO
+    HALO_GREAT_FULL_COMBO = DBConstants.DDR_HALO_GREAT_FULL_COMBO
+    HALO_PERFECT_FULL_COMBO = DBConstants.DDR_HALO_PERFECT_FULL_COMBO
+    HALO_MARVELOUS_FULL_COMBO = DBConstants.DDR_HALO_MARVELOUS_FULL_COMBO
+
+    RANK_E = DBConstants.DDR_RANK_E
+    RANK_D = DBConstants.DDR_RANK_D
+    RANK_D_PLUS = DBConstants.DDR_RANK_D_PLUS
+    RANK_C_MINUS = DBConstants.DDR_RANK_C_MINUS
+    RANK_C = DBConstants.DDR_RANK_C
+    RANK_C_PLUS = DBConstants.DDR_RANK_C_PLUS
+    RANK_B_MINUS = DBConstants.DDR_RANK_B_MINUS
+    RANK_B = DBConstants.DDR_RANK_B
+    RANK_B_PLUS = DBConstants.DDR_RANK_B_PLUS
+    RANK_A_MINUS = DBConstants.DDR_RANK_A_MINUS
+    RANK_A = DBConstants.DDR_RANK_A
+    RANK_A_PLUS = DBConstants.DDR_RANK_A_PLUS
+    RANK_AA_MINUS = DBConstants.DDR_RANK_AA_MINUS
+    RANK_AA = DBConstants.DDR_RANK_AA
+    RANK_AA_PLUS = DBConstants.DDR_RANK_AA_PLUS
+    RANK_AAA = DBConstants.DDR_RANK_AAA
+
+    # These constants must agree with read.py for importing charts from the game.
+    CHART_SINGLE_BEGINNER = 0
+    CHART_SINGLE_BASIC = 1
+    CHART_SINGLE_DIFFICULT = 2
+    CHART_SINGLE_EXPERT = 3
+    CHART_SINGLE_CHALLENGE = 4
+    CHART_DOUBLE_BEGINNER = 5
+    CHART_DOUBLE_BASIC = 6
+    CHART_DOUBLE_DIFFICULT = 7
+    CHART_DOUBLE_EXPERT = 8
+    CHART_DOUBLE_CHALLENGE = 9
+
+    def __init__(self, data: Data, config: Dict[str, Any], model: Model) -> None:
+        super().__init__(data, config, model)
+        if model.rev == 'X':
+            self.omnimix = True
+        else:
+            self.omnimix = False
+
+    @property
+    def music_version(self) -> int:
+        if self.omnimix:
+            return DBConstants.OMNIMIX_VERSION_BUMP + self.version
+        return self.version
+
+    def extra_services(self) -> List[str]:
+        """
+        Return the local2 service so that DDR Ace will send certain packets.
+        """
+        return [
+            'local2',
+        ]
+
+    def game_to_db_rank(self, game_rank: int) -> int:
+        """
+        Given a game's rank constant, return the rank as defined above.
+        """
+        raise Exception('Implement in sub-class!')
+
+    def db_to_game_rank(self, db_rank: int) -> int:
+        """
+        Given a rank as defined above, return the game's rank constant.
+        """
+        raise Exception('Implement in sub-class!')
+
+    def game_to_db_chart(self, game_chart: int) -> int:
+        """
+        Given a game's chart for a song, return the chart as defined above.
+        """
+        raise Exception('Implement in sub-class!')
+
+    def db_to_game_chart(self, db_chart: int) -> int:
+        """
+        Given a chart as defined above, return the game's chart constant.
+        """
+        raise Exception('Implement in sub-class!')
+
+    def game_to_db_halo(self, game_halo: int) -> int:
+        """
+        Given a game's halo constant, return the halo as defined above.
+        """
+        raise Exception('Implement in sub-class!')
+
+    def db_to_game_halo(self, db_halo: int) -> int:
+        """
+        Given a halo as defined above, return the game's halo constant.
+        """
+        raise Exception('Implement in sub-class!')
+
+    def previous_version(self) -> Optional['DDRBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('game')
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        """
+        Base handler for a score list. Given a userid, profile and a score list,
+        return a Node representing a score list. Should be overridden.
+        """
+        return Node.void('game')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication.
+        """
+        if refid is None:
+            return None
+
+        # First try to load the actual profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+
+        # Now, return it
+        return self.format_profile(userid, profile)
+
+    def new_profile_by_refid(self, refid: Optional[str], name: Optional[str], area: Optional[int]) -> None:
+        """
+        Given a RefID and a name/area, create a new profile.
+        """
+        if refid is None:
+            return
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            return
+
+        defaultprofile = ValidatedDict({
+            'name': name,
+            'area': area,
+        })
+        self.put_profile(userid, defaultprofile)
+
+    def put_profile_by_refid(self, refid: Optional[str], request: Node) -> None:
+        """
+        Given a RefID and a request node, unformat the profile and save it.
+        """
+        if refid is None:
+            return
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            return
+
+        oldprofile = self.get_profile(userid)
+        newprofile = self.unformat_profile(userid, request, oldprofile)
+        if newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+    def update_score(
+        self,
+        userid: Optional[UserID],
+        songid: int,
+        chart: int,
+        points: int,
+        rank: int,
+        halo: int,
+        combo: int,
+        trace: Optional[List[int]]=None,
+        ghost: Optional[str]=None,
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in DDR series can expect
+        the same attributes in a score.
+        """
+        if chart not in [
+            self.CHART_SINGLE_BEGINNER,
+            self.CHART_SINGLE_BASIC,
+            self.CHART_SINGLE_DIFFICULT,
+            self.CHART_SINGLE_EXPERT,
+            self.CHART_SINGLE_CHALLENGE,
+            self.CHART_DOUBLE_BEGINNER,
+            self.CHART_DOUBLE_BASIC,
+            self.CHART_DOUBLE_DIFFICULT,
+            self.CHART_DOUBLE_EXPERT,
+            self.CHART_DOUBLE_CHALLENGE,
+        ]:
+            raise Exception('Invalid chart {}'.format(chart))
+        if halo not in [
+            self.HALO_NONE,
+            self.HALO_GOOD_FULL_COMBO,
+            self.HALO_GREAT_FULL_COMBO,
+            self.HALO_PERFECT_FULL_COMBO,
+            self.HALO_MARVELOUS_FULL_COMBO,
+        ]:
+            raise Exception('Invalid halo {}'.format(halo))
+        if rank not in [
+            self.RANK_E,
+            self.RANK_D,
+            self.RANK_D_PLUS,
+            self.RANK_C_MINUS,
+            self.RANK_C,
+            self.RANK_C_PLUS,
+            self.RANK_B_MINUS,
+            self.RANK_B,
+            self.RANK_B_PLUS,
+            self.RANK_A_MINUS,
+            self.RANK_A,
+            self.RANK_A_PLUS,
+            self.RANK_AA_MINUS,
+            self.RANK_AA,
+            self.RANK_AA_PLUS,
+            self.RANK_AAA,
+        ]:
+            raise Exception('Invalid rank {}'.format(rank))
+
+        if userid is not None:
+            oldscore = self.data.local.music.get_score(
+                self.game,
+                self.music_version,
+                userid,
+                songid,
+                chart,
+            )
+        else:
+            oldscore = None
+
+        # Score history is verbatum, instead of highest score
+        now = Time.now()
+        history = ValidatedDict({})
+        oldpoints = points
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({})
+            raised = True
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            raised = points > oldscore.points
+            highscore = points >= oldscore.points
+            points = max(oldscore.points, points)
+            scoredata = oldscore.data
+
+        # Save combo
+        history.replace_int('combo', combo)
+        scoredata.replace_int('combo', max(scoredata.get_int('combo'), combo))
+
+        # Save halo
+        history.replace_int('halo', halo)
+        scoredata.replace_int('halo', max(scoredata.get_int('halo'), halo))
+
+        # Save rank
+        history.replace_int('rank', rank)
+        scoredata.replace_int('rank', max(scoredata.get_int('rank'), rank))
+
+        # Save ghost steps
+        if trace is not None:
+            history.replace_int_array('trace', len(trace), trace)
+            if raised:
+                scoredata.replace_int_array('trace', len(trace), trace)
+        if ghost is not None:
+            history.replace_str('ghost', ghost)
+            if raised:
+                scoredata.replace_str('ghost', ghost)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        # DDR sometimes happens to send all songs that were played by a player
+        # at the end of the round. It sends timestamps for the songs, but as of
+        # Colette they were identical for each song in the round. So, if a user
+        # plays the same song/chart# more than once in a round, we will end up
+        # failing to store the attempt since we don't allow two of the same
+        # attempt at the same time for the same user and song/chart. So, bump
+        # the timestamp by one second and retry well past the maximum number of
+        # songs.
+        for bump in range(10):
+            timestamp = now + bump
+
+            if userid is not None:
+                # Write the new score back
+                self.data.local.music.put_score(
+                    self.game,
+                    self.music_version,
+                    userid,
+                    songid,
+                    chart,
+                    lid,
+                    points,
+                    scoredata,
+                    highscore,
+                    timestamp=timestamp,
+                )
+
+            try:
+                # Save the history of this score too
+                self.data.local.music.put_attempt(
+                    self.game,
+                    self.music_version,
+                    userid,
+                    songid,
+                    chart,
+                    lid,
+                    oldpoints,
+                    history,
+                    raised,
+                    timestamp=timestamp,
+                )
+            except ScoreSaveException:
+                # Try again one second in the future
+                continue
+
+            # We saved successfully
+            break
diff --git a/bemani/backend/ddr/common.py b/bemani/backend/ddr/common.py
new file mode 100644
index 0000000..8a361af
--- /dev/null
+++ b/bemani/backend/ddr/common.py
@@ -0,0 +1,508 @@
+from typing import Dict, Optional, Tuple
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.common import Time, ValidatedDict, intish
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class DDRGameShopHandler(DDRBase):
+
+    def handle_game_shop_request(self, request: Node) -> Node:
+        self.update_machine_name(request.attribute('name'))
+
+        game = Node.void('game')
+        game.set_attribute('stop', '0')
+        return game
+
+
+class DDRGameLogHandler(DDRBase):
+
+    def handle_game_log_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+
+class DDRGameMessageHandler(DDRBase):
+
+    def handle_game_message_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+
+class DDRGameRankingHandler(DDRBase):
+
+    def handle_game_ranking_request(self, request: Node) -> Node:
+        # Ranking request, unknown what its for
+        return Node.void('game')
+
+
+class DDRGameLockHandler(DDRBase):
+
+    def handle_game_lock_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        game.set_attribute('now_login', '0')
+        return game
+
+
+class DDRGameTaxInfoHandler(DDRBase):
+
+    def handle_game_tax_info_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        tax_info = Node.void('tax_info')
+        game.add_child(tax_info)
+        tax_info.set_attribute('tax_phase', '0')
+        return game
+
+
+class DDRGameRecorderHandler(DDRBase):
+
+    def handle_game_recorder_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+
+class DDRGameHiscoreHandler(DDRBase):
+
+    def handle_game_hiscore_request(self, request: Node) -> Node:
+        records = self.data.remote.music.get_all_records(self.game, self.music_version)
+
+        sortedrecords: Dict[int, Dict[int, Tuple[UserID, Score]]] = {}
+        missing_profiles = []
+        for (userid, score) in records:
+            if score.id not in sortedrecords:
+                sortedrecords[score.id] = {}
+            sortedrecords[score.id][score.chart] = (userid, score)
+            missing_profiles.append(userid)
+        users = {userid: profile for (userid, profile) in self.get_any_profiles(missing_profiles)}
+
+        game = Node.void('game')
+        for song in sortedrecords:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink_num', str(song))
+
+            for chart in sortedrecords[song]:
+                userid, score = sortedrecords[song][chart]
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                gamerank = self.db_to_game_rank(score.data.get_int('rank'))
+                combo_type = self.db_to_game_halo(score.data.get_int('halo'))
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.string('name', users[userid].get_str('name')))
+                typenode.add_child(Node.u32('score', score.points))
+                typenode.add_child(Node.u16('area', users[userid].get_int('area', 51)))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+                typenode.add_child(Node.u32('code', users[userid].get_int('extid')))
+
+        return game
+
+
+class DDRGameAreaHiscoreHandler(DDRBase):
+
+    def handle_game_area_hiscore_request(self, request: Node) -> Node:
+        shop_area = int(request.attribute('shop_area'))
+
+        # First, get all users that are in the current shop's area
+        area_users = {
+            uid: prof for (uid, prof) in self.data.local.user.get_all_profiles(self.game, self.version)
+            if prof.get_int('area', 51) == shop_area
+        }
+
+        # Second, look up records belonging only to those users
+        records = self.data.local.music.get_all_records(self.game, self.music_version, userlist=list(area_users.keys()))
+
+        # Now, do the same lazy thing as 'hiscore' because I don't want
+        # to think about how to change this knowing that we only pulled
+        # up area records.
+        area_records: Dict[int, Dict[int, Tuple[UserID, Score]]] = {}
+        for (userid, score) in records:
+            if score.id not in area_records:
+                area_records[score.id] = {}
+            area_records[score.id][score.chart] = (userid, score)
+
+        game = Node.void('game')
+        for song in area_records:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink_num', str(song))
+
+            for chart in area_records[song]:
+                userid, score = area_records[song][chart]
+                if area_users[userid].get_int('area', 51) != shop_area:
+                    # Don't return this, this user isn't in this area
+                    continue
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                gamerank = self.db_to_game_rank(score.data.get_int('rank'))
+                combo_type = self.db_to_game_halo(score.data.get_int('halo'))
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.string('name', area_users[userid].get_str('name')))
+                typenode.add_child(Node.u32('score', score.points))
+                typenode.add_child(Node.u16('area', area_users[userid].get_int('area', 51)))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+                typenode.add_child(Node.u32('code', area_users[userid].get_int('extid')))
+
+        return game
+
+
+class DDRGameScoreHandler(DDRBase):
+
+    def handle_game_score_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        songid = int(request.attribute('mid'))
+        chart = self.game_to_db_chart(int(request.attribute('type')))
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            attempts = self.data.local.music.get_all_attempts(
+                self.game,
+                self.music_version,
+                userid,
+                songid=songid,
+                songchart=chart,
+                limit=5,
+            )
+            recentscores = [attempt.points for (_, attempt) in attempts]
+        else:
+            recentscores = []
+
+        # Always pad to five, so we ensure that we return all the scores
+        while len(recentscores) < 5:
+            recentscores.append(0)
+
+        # Return the most recent five scores
+        game = Node.void('game')
+        for i in range(len(recentscores)):
+            game.set_attribute('sc{}'.format(i + 1), str(recentscores[i]))
+        return game
+
+
+class DDRGameTraceHandler(DDRBase):
+
+    def handle_game_trace_request(self, request: Node) -> Node:
+        extid = int(request.attribute('code'))
+        chart = int(request.attribute('type'))
+        cid = intish(request.attribute('cid'))
+        mid = intish(request.attribute('mid'))
+
+        # Base packet is just game, if we find something we add to it
+        game = Node.void('game')
+
+        # Rival trace loading
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            # Nothing to load
+            return game
+
+        if mid is not None:
+            # Load trace from song score
+            songscore = self.data.remote.music.get_score(
+                self.game,
+                self.music_version,
+                userid,
+                mid,
+                self.game_to_db_chart(chart),
+            )
+            if songscore is not None and 'trace' in songscore.data:
+                game.add_child(Node.u32('size', len(songscore.data['trace'])))
+                game.add_child(Node.u8_array('trace', songscore.data['trace']))
+
+        elif cid is not None:
+            # Load trace from achievement
+            coursescore = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                (cid * 4) + chart,
+                'course',
+            )
+            if coursescore is not None and 'trace' in coursescore:
+                game.add_child(Node.u32('size', len(coursescore['trace'])))
+                game.add_child(Node.u8_array('trace', coursescore['trace']))
+
+        # Nothing found, return empty
+        return game
+
+
+class DDRGameLoadHandler(DDRBase):
+
+    def handle_game_load_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        profile = self.get_profile_by_refid(refid)
+        if profile is not None:
+            return profile
+
+        game = Node.void('game')
+        game.set_attribute('none', '0')
+        return game
+
+
+class DDRGameLoadDailyHandler(DDRBase):
+
+    def handle_game_load_daily_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        refid = request.attribute('refid')
+        game = Node.void('game')
+        profiledict = None
+
+        if extid is not None:
+            # Rival daily loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        else:
+            # Self daily loading
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            profiledict = self.get_profile(userid)
+
+        if profiledict is not None:
+            play_stats = self.get_play_statistics(userid)
+
+            # Day play counts
+            last_play_date = play_stats.get_int_array('last_play_date', 3)
+            today_play_date = Time.todays_date()
+            if (
+                last_play_date[0] == today_play_date[0] and
+                last_play_date[1] == today_play_date[1] and
+                last_play_date[2] == today_play_date[2]
+            ):
+                today_count = play_stats.get_int('today_plays', 0)
+            else:
+                today_count = 0
+            daycount = Node.void('daycount')
+            game.add_child(daycount)
+            daycount.set_attribute('playcount', str(today_count))
+
+            # Daily combo stuff, unclear how this works
+            dailycombo = Node.void('dailycombo')
+            game.add_child(dailycombo)
+            dailycombo.set_attribute('daily_combo', str(0))
+            dailycombo.set_attribute('daily_combo_lv', str(0))
+
+        return game
+
+
+class DDRGameOldHandler(DDRBase):
+
+    def handle_game_old_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        game = Node.void('game')
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        previous_version: Optional[DDRBase] = None
+        oldprofile: Optional[ValidatedDict] = None
+
+        if userid is not None:
+            previous_version = self.previous_version()
+        if previous_version is not None:
+            oldprofile = previous_version.get_profile(userid)
+        if oldprofile is not None:
+            game.set_attribute('name', oldprofile.get_str('name'))
+            game.set_attribute('area', str(oldprofile.get_int('area', 51)))
+        return game
+
+
+class DDRGameNewHandler(DDRBase):
+
+    def handle_game_new_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        area = int(request.attribute('area'))
+        name = request.attribute('name').strip()
+
+        # Create a new profile for this user!
+        self.new_profile_by_refid(refid, name, area)
+
+        # No response needed
+        game = Node.void('game')
+        return game
+
+
+class DDRGameSaveHandler(DDRBase):
+
+    def handle_game_save_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        self.put_profile_by_refid(refid, request)
+
+        # No response needed
+        game = Node.void('game')
+        return game
+
+
+class DDRGameFriendHandler(DDRBase):
+
+    def handle_game_friend_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        userid = None
+        friend = None
+
+        if extid is not None:
+            # Rival score loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            friend = self.get_profile(userid)
+            play_stats = self.get_play_statistics(userid)
+
+        if friend is None:
+            # Return an empty node to tell the game we don't have a player here
+            game = Node.void('game')
+            return game
+
+        game = Node.void('game')
+        game.set_attribute('data', '1')
+        game.add_child(Node.u32('code', friend.get_int('extid')))
+        game.add_child(Node.string('name', friend.get_str('name')))
+        game.add_child(Node.u8('area', friend.get_int('area', 51)))
+        game.add_child(Node.u32('exp', play_stats.get_int('exp')))
+        game.add_child(Node.u32('star', friend.get_int('star')))
+
+        # Drill rankings
+        if 'title' in friend:
+            title = Node.void('title')
+            game.add_child(title)
+            titledict = friend.get_dict('title')
+            if 't' in titledict:
+                title.set_attribute('t', str(titledict.get_int('t')))
+            if 's' in titledict:
+                title.set_attribute('s', str(titledict.get_int('s')))
+            if 'd' in titledict:
+                title.set_attribute('d', str(titledict.get_int('d')))
+
+        if 'title_gr' in friend:
+            title_gr = Node.void('title_gr')
+            game.add_child(title_gr)
+            title_grdict = friend.get_dict('title_gr')
+            if 't' in title_grdict:
+                title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+            if 's' in title_grdict:
+                title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+            if 'd' in title_grdict:
+                title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+        # Groove gauge level-ups
+        gr_s = Node.void('gr_s')
+        game.add_child(gr_s)
+        index = 1
+        for entry in friend.get_int_array('gr_s', 5):
+            gr_s.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        gr_d = Node.void('gr_d')
+        game.add_child(gr_d)
+        index = 1
+        for entry in friend.get_int_array('gr_d', 5):
+            gr_d.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+        return game
+
+
+class DDRGameLoadCourseHandler(DDRBase):
+
+    def handle_game_load_c_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        refid = request.attribute('refid')
+
+        if extid is not None:
+            # Rival score loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        else:
+            # Self score loading
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        coursedata = [0] * 3200
+        if userid is not None:
+            for course in self.data.local.user.get_achievements(self.game, self.version, userid):
+                if course.type != 'course':
+                    continue
+
+                # Grab course ID and chart (kinda pointless because we add it right back up
+                # below, but it is more documented/readable this way.
+                courseid = int(course.id / 4)
+                coursechart = course.id % 4
+
+                # Populate course data
+                index = ((courseid * 4) + coursechart) * 8
+                if index >= 0 and index <= (len(coursedata) - 8):
+                    coursedata[index + 0] = int(course.data.get_int('score') / 10000)
+                    coursedata[index + 1] = course.data.get_int('score') % 10000
+                    coursedata[index + 2] = course.data.get_int('combo')
+                    coursedata[index + 3] = self.db_to_game_rank(course.data.get_int('rank'))
+                    coursedata[index + 5] = course.data.get_int('stage')
+                    coursedata[index + 6] = course.data.get_int('combo_type')
+
+        game = Node.void('game')
+        game.add_child(Node.u16_array('course', coursedata))
+        return game
+
+
+class DDRGameSaveCourseHandler(DDRBase):
+
+    def handle_game_save_c_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        courseid = int(request.attribute('cid'))
+        chart = int(request.attribute('ctype'))
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            # Calculate statistics
+            data = request.child('data')
+            points = int(data.attribute('score'))
+            combo = int(data.attribute('combo'))
+            combo_type = int(data.attribute('combo_type'))
+            stage = int(data.attribute('stage'))
+            rank = self.game_to_db_rank(int(data.attribute('rank')))
+            trace = request.child_value('trace')
+
+            # Grab the old course score
+            oldcourse = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                (courseid * 4) + chart,
+                'course',
+            )
+
+            if oldcourse is not None:
+                highscore = points > oldcourse.get_int('score')
+
+                points = max(points, oldcourse.get_int('score'))
+                combo = max(combo, oldcourse.get_int('combo'))
+                stage = max(stage, oldcourse.get_int('stage'))
+                rank = max(rank, oldcourse.get_int('rank'))
+                combo_type = max(combo_type, oldcourse.get_int('combo_type'))
+
+                if not highscore:
+                    # Don't overwrite the ghost for a non-highscore
+                    trace = oldcourse.get_int_array('trace', len(trace))
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                (courseid * 4) + chart,
+                'course',
+                {
+                    'score': points,
+                    'combo': combo,
+                    'stage': stage,
+                    'rank': rank,
+                    'combo_type': combo_type,
+                    'trace': trace,
+                },
+            )
+
+        # No response needed
+        game = Node.void('game')
+        return game
diff --git a/bemani/backend/ddr/ddr2013.py b/bemani/backend/ddr/ddr2013.py
new file mode 100644
index 0000000..937e021
--- /dev/null
+++ b/bemani/backend/ddr/ddr2013.py
@@ -0,0 +1,739 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Dict, List, Optional
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.backend.ddr.ddrx3 import DDRX3
+from bemani.backend.ddr.common import (
+    DDRGameAreaHiscoreHandler,
+    DDRGameFriendHandler,
+    DDRGameHiscoreHandler,
+    DDRGameLoadCourseHandler,
+    DDRGameLoadDailyHandler,
+    DDRGameLoadHandler,
+    DDRGameLockHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameRecorderHandler,
+    DDRGameSaveCourseHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTaxInfoHandler,
+    DDRGameTraceHandler,
+)
+from bemani.common import VersionConstants, ValidatedDict, Time, intish
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class DDR2013(
+    DDRGameAreaHiscoreHandler,
+    DDRGameFriendHandler,
+    DDRGameHiscoreHandler,
+    DDRGameLoadCourseHandler,
+    DDRGameLoadDailyHandler,
+    DDRGameLoadHandler,
+    DDRGameLockHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameRecorderHandler,
+    DDRGameSaveCourseHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTaxInfoHandler,
+    DDRGameTraceHandler,
+    DDRBase,
+):
+
+    name = 'DanceDanceRevolution 2013'
+    version = VersionConstants.DDR_2013
+
+    GAME_STYLE_SINGLE = 0
+    GAME_STYLE_DOUBLE = 1
+    GAME_STYLE_VERSUS = 2
+
+    GAME_RANK_AAA = 1
+    GAME_RANK_AA = 2
+    GAME_RANK_A = 3
+    GAME_RANK_B = 4
+    GAME_RANK_C = 5
+    GAME_RANK_D = 6
+    GAME_RANK_E = 7
+
+    GAME_CHART_SINGLE_BEGINNER = 0
+    GAME_CHART_SINGLE_BASIC = 1
+    GAME_CHART_SINGLE_DIFFICULT = 2
+    GAME_CHART_SINGLE_EXPERT = 3
+    GAME_CHART_SINGLE_CHALLENGE = 4
+    GAME_CHART_DOUBLE_BASIC = 5
+    GAME_CHART_DOUBLE_DIFFICULT = 6
+    GAME_CHART_DOUBLE_EXPERT = 7
+    GAME_CHART_DOUBLE_CHALLENGE = 8
+
+    GAME_HALO_NONE = 0
+    GAME_HALO_GREAT_COMBO = 1
+    GAME_HALO_PERFECT_COMBO = 2
+    GAME_HALO_MARVELOUS_COMBO = 3
+    GAME_HALO_GOOD_COMBO = 4
+
+    GAME_MAX_SONGS = 700
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRX3(self.data, self.config, self.model)
+
+    def game_to_db_rank(self, game_rank: int) -> int:
+        return {
+            self.GAME_RANK_AAA: self.RANK_AAA,
+            self.GAME_RANK_AA: self.RANK_AA,
+            self.GAME_RANK_A: self.RANK_A,
+            self.GAME_RANK_B: self.RANK_B,
+            self.GAME_RANK_C: self.RANK_C,
+            self.GAME_RANK_D: self.RANK_D,
+            self.GAME_RANK_E: self.RANK_E,
+        }[game_rank]
+
+    def db_to_game_rank(self, db_rank: int) -> int:
+        return {
+            self.RANK_AAA: self.GAME_RANK_AAA,
+            self.RANK_AA_PLUS: self.GAME_RANK_AA,
+            self.RANK_AA: self.GAME_RANK_AA,
+            self.RANK_AA_MINUS: self.GAME_RANK_A,
+            self.RANK_A_PLUS: self.GAME_RANK_A,
+            self.RANK_A: self.GAME_RANK_A,
+            self.RANK_A_MINUS: self.GAME_RANK_B,
+            self.RANK_B_PLUS: self.GAME_RANK_B,
+            self.RANK_B: self.GAME_RANK_B,
+            self.RANK_B_MINUS: self.GAME_RANK_C,
+            self.RANK_C_PLUS: self.GAME_RANK_C,
+            self.RANK_C: self.GAME_RANK_C,
+            self.RANK_C_MINUS: self.GAME_RANK_D,
+            self.RANK_D_PLUS: self.GAME_RANK_D,
+            self.RANK_D: self.GAME_RANK_D,
+            self.RANK_E: self.GAME_RANK_E,
+        }[db_rank]
+
+    def game_to_db_chart(self, game_chart: int) -> int:
+        return {
+            self.GAME_CHART_SINGLE_BEGINNER: self.CHART_SINGLE_BEGINNER,
+            self.GAME_CHART_SINGLE_BASIC: self.CHART_SINGLE_BASIC,
+            self.GAME_CHART_SINGLE_DIFFICULT: self.CHART_SINGLE_DIFFICULT,
+            self.GAME_CHART_SINGLE_EXPERT: self.CHART_SINGLE_EXPERT,
+            self.GAME_CHART_SINGLE_CHALLENGE: self.CHART_SINGLE_CHALLENGE,
+            self.GAME_CHART_DOUBLE_BASIC: self.CHART_DOUBLE_BASIC,
+            self.GAME_CHART_DOUBLE_DIFFICULT: self.CHART_DOUBLE_DIFFICULT,
+            self.GAME_CHART_DOUBLE_EXPERT: self.CHART_DOUBLE_EXPERT,
+            self.GAME_CHART_DOUBLE_CHALLENGE: self.CHART_DOUBLE_CHALLENGE,
+        }[game_chart]
+
+    def db_to_game_chart(self, db_chart: int) -> int:
+        return {
+            self.CHART_SINGLE_BEGINNER: self.GAME_CHART_SINGLE_BEGINNER,
+            self.CHART_SINGLE_BASIC: self.GAME_CHART_SINGLE_BASIC,
+            self.CHART_SINGLE_DIFFICULT: self.GAME_CHART_SINGLE_DIFFICULT,
+            self.CHART_SINGLE_EXPERT: self.GAME_CHART_SINGLE_EXPERT,
+            self.CHART_SINGLE_CHALLENGE: self.GAME_CHART_SINGLE_CHALLENGE,
+            self.CHART_DOUBLE_BASIC: self.GAME_CHART_DOUBLE_BASIC,
+            self.CHART_DOUBLE_DIFFICULT: self.GAME_CHART_DOUBLE_DIFFICULT,
+            self.CHART_DOUBLE_EXPERT: self.GAME_CHART_DOUBLE_EXPERT,
+            self.CHART_DOUBLE_CHALLENGE: self.GAME_CHART_DOUBLE_CHALLENGE,
+        }[db_chart]
+
+    def db_to_game_halo(self, db_halo: int) -> int:
+        if db_halo == self.HALO_MARVELOUS_FULL_COMBO:
+            combo_type = self.GAME_HALO_MARVELOUS_COMBO
+        elif db_halo == self.HALO_PERFECT_FULL_COMBO:
+            combo_type = self.GAME_HALO_PERFECT_COMBO
+        elif db_halo == self.HALO_GREAT_FULL_COMBO:
+            combo_type = self.GAME_HALO_GREAT_COMBO
+        elif db_halo == self.HALO_GOOD_FULL_COMBO:
+            combo_type = self.GAME_HALO_GOOD_COMBO
+        else:
+            combo_type = self.GAME_HALO_NONE
+        return combo_type
+
+    def handle_game_common_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        for flagid in range(256):
+            flag = Node.void('flag')
+            game.add_child(flag)
+
+            flag.set_attribute('id', str(flagid))
+            flag.set_attribute('t', '0')
+            flag.set_attribute('s1', '0')
+            flag.set_attribute('s2', '0')
+            flag.set_attribute('area', '51')
+            flag.set_attribute('is_final', '1')
+
+        hit_chart = self.data.local.music.get_hit_chart(self.game, self.music_version, self.GAME_MAX_SONGS)
+        counts_by_reflink = [0] * self.GAME_MAX_SONGS
+        for (reflink, plays) in hit_chart:
+            if reflink >= 0 and reflink < self.GAME_MAX_SONGS:
+                counts_by_reflink[reflink] = plays
+        game.add_child(Node.u32_array('cnt_music', counts_by_reflink))
+
+        return game
+
+    def handle_game_load_m_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        refid = request.attribute('refid')
+
+        if extid is not None:
+            # Rival score loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        else:
+            # Self score loading
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+        else:
+            scores = []
+
+        sortedscores: Dict[int, Dict[int, Score]] = {}
+        for score in scores:
+            if score.id not in sortedscores:
+                sortedscores[score.id] = {}
+            sortedscores[score.id][score.chart] = score
+
+        game = Node.void('game')
+        for song in sortedscores:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink', str(song))
+
+            for chart in sortedscores[song]:
+                score = sortedscores[song][chart]
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                gamerank = self.db_to_game_rank(score.data.get_int('rank'))
+                combo_type = self.db_to_game_halo(score.data.get_int('halo'))
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.u32('score', score.points))
+                typenode.add_child(Node.u16('count', score.plays))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+
+        return game
+
+    def handle_game_save_m_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        songid = int(request.attribute('mid'))
+        chart = self.game_to_db_chart(int(request.attribute('mtype')))
+
+        # Calculate statistics
+        data = request.child('data')
+        points = int(data.attribute('score'))
+        combo = int(data.attribute('combo'))
+        rank = self.game_to_db_rank(int(data.attribute('rank')))
+        if points == 1000000:
+            halo = self.HALO_MARVELOUS_FULL_COMBO
+        elif int(data.attribute('perf_fc')) != 0:
+            halo = self.HALO_PERFECT_FULL_COMBO
+        elif int(data.attribute('great_fc')) != 0:
+            halo = self.HALO_GREAT_FULL_COMBO
+        elif int(data.attribute('good_fc')) != 0:
+            halo = self.HALO_GOOD_FULL_COMBO
+        else:
+            halo = self.HALO_NONE
+        trace = request.child_value('trace')
+
+        # Save the score, regardless of whether we have a refid. If we save
+        # an anonymous score, it only goes into the DB to count against the
+        # number of plays for that song/chart.
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        self.update_score(
+            userid,
+            songid,
+            chart,
+            points,
+            rank,
+            halo,
+            combo,
+            trace,
+        )
+
+        # No response needed
+        game = Node.void('game')
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('game')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Basic game settings
+        root.add_child(Node.string('seq', ''))
+        root.add_child(Node.u32('code', profile.get_int('extid')))
+        root.add_child(Node.string('name', profile.get_str('name')))
+        root.add_child(Node.u8('area', profile.get_int('area', 51)))
+        root.add_child(Node.u32('cnt_s', play_stats.get_int('single_plays')))
+        root.add_child(Node.u32('cnt_d', play_stats.get_int('double_plays')))
+        root.add_child(Node.u32('cnt_b', play_stats.get_int('battle_plays')))  # This could be wrong, its a guess
+        root.add_child(Node.u32('cnt_m0', play_stats.get_int('cnt_m0')))
+        root.add_child(Node.u32('cnt_m1', play_stats.get_int('cnt_m1')))
+        root.add_child(Node.u32('cnt_m2', play_stats.get_int('cnt_m2')))
+        root.add_child(Node.u32('cnt_m3', play_stats.get_int('cnt_m3')))
+        root.add_child(Node.u32('cnt_m4', play_stats.get_int('cnt_m4')))
+        root.add_child(Node.u32('cnt_m5', play_stats.get_int('cnt_m5')))
+        root.add_child(Node.u32('exp', play_stats.get_int('exp')))
+        root.add_child(Node.u32('exp_o', profile.get_int('exp_o')))
+        root.add_child(Node.u32('star', profile.get_int('star')))
+        root.add_child(Node.u32('star_c', profile.get_int('star_c')))
+        root.add_child(Node.u8('combo', profile.get_int('combo', 0)))
+        root.add_child(Node.u8('timing_diff', profile.get_int('early_late', 0)))
+
+        # Character stuff
+        chara = Node.void('chara')
+        root.add_child(chara)
+        chara.set_attribute('my', str(profile.get_int('chara', 30)))
+        root.add_child(Node.u16_array('chara_opt', profile.get_int_array('chara_opt', 96, [208] * 96)))
+
+        # Drill rankings
+        if 'title_gr' in profile:
+            title_gr = Node.void('title_gr')
+            root.add_child(title_gr)
+            title_grdict = profile.get_dict('title_gr')
+            if 't' in title_grdict:
+                title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+            if 's' in title_grdict:
+                title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+            if 'd' in title_grdict:
+                title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+        # Calorie mode
+        if 'weight' in profile:
+            workouts = self.data.local.user.get_time_based_achievements(
+                self.game,
+                self.version,
+                userid,
+                achievementtype='workout',
+                since=Time.now() - Time.SECONDS_IN_DAY,
+            )
+            total = sum([w.data.get_int('calories') for w in workouts])
+            workout = Node.void('workout')
+            root.add_child(workout)
+            workout.set_attribute('weight', str(profile.get_int('weight')))
+            workout.set_attribute('day', str(total))
+            workout.set_attribute('disp', '1')
+
+        # Daily play counts
+        last_play_date = play_stats.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = play_stats.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        daycount = Node.void('daycount')
+        root.add_child(daycount)
+        daycount.set_attribute('playcount', str(today_count))
+
+        # Daily combo stuff, unknown how this works
+        dailycombo = Node.void('dailycombo')
+        root.add_child(dailycombo)
+        dailycombo.set_attribute('daily_combo', str(0))
+        dailycombo.set_attribute('daily_combo_lv', str(0))
+
+        # Last cursor settings
+        last = Node.void('last')
+        root.add_child(last)
+        lastdict = profile.get_dict('last')
+        last.set_attribute('rival1', str(lastdict.get_int('rival1', -1)))
+        last.set_attribute('rival2', str(lastdict.get_int('rival2', -1)))
+        last.set_attribute('rival3', str(lastdict.get_int('rival3', -1)))
+        last.set_attribute('fri', str(lastdict.get_int('rival1', -1)))  # This literally goes to the same memory in 2013
+        last.set_attribute('style', str(lastdict.get_int('style')))
+        last.set_attribute('mode', str(lastdict.get_int('mode')))
+        last.set_attribute('cate', str(lastdict.get_int('cate')))
+        last.set_attribute('sort', str(lastdict.get_int('sort')))
+        last.set_attribute('mid', str(lastdict.get_int('mid')))
+        last.set_attribute('mtype', str(lastdict.get_int('mtype')))
+        last.set_attribute('cid', str(lastdict.get_int('cid')))
+        last.set_attribute('ctype', str(lastdict.get_int('ctype')))
+        last.set_attribute('sid', str(lastdict.get_int('sid')))
+
+        # Result stars
+        result_star = Node.void('result_star')
+        root.add_child(result_star)
+        result_stars = profile.get_int_array('result_stars', 9)
+        for i in range(9):
+            result_star.set_attribute('slot{}'.format(i + 1), str(result_stars[i]))
+
+        # Target stuff
+        target = Node.void('target')
+        root.add_child(target)
+        target.set_attribute('flag', str(profile.get_int('target_flag')))
+        target.set_attribute('setnum', str(profile.get_int('target_setnum')))
+
+        # Groove gauge level-ups
+        gr_s = Node.void('gr_s')
+        root.add_child(gr_s)
+        index = 1
+        for entry in profile.get_int_array('gr_s', 5):
+            gr_s.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        gr_d = Node.void('gr_d')
+        root.add_child(gr_d)
+        index = 1
+        for entry in profile.get_int_array('gr_d', 5):
+            gr_d.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        # Options in menus
+        root.add_child(Node.s16_array('opt', profile.get_int_array('opt', 16)))
+        root.add_child(Node.s16_array('opt_ex', profile.get_int_array('opt_ex', 16)))
+
+        # Unlock flags
+        root.add_child(Node.u8_array('flag', profile.get_int_array('flag', 256, [1] * 256)))
+
+        # Ranking display?
+        root.add_child(Node.u16_array('rank', profile.get_int_array('rank', 100)))
+
+        # Rivals
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            friend = self.get_profile(link.other_userid)
+            play_stats = self.get_play_statistics(link.other_userid)
+            if friend is not None:
+                friendnode = Node.void('friend')
+                root.add_child(friendnode)
+                friendnode.set_attribute('pos', str(pos))
+                friendnode.set_attribute('vs', '0')
+                friendnode.set_attribute('up', '0')
+                friendnode.add_child(Node.u32('code', friend.get_int('extid')))
+                friendnode.add_child(Node.string('name', friend.get_str('name')))
+                friendnode.add_child(Node.u8('area', friend.get_int('area', 51)))
+                friendnode.add_child(Node.u32('exp', play_stats.get_int('exp')))
+                friendnode.add_child(Node.u32('star', friend.get_int('star')))
+
+                # Drill rankings
+                if 'title' in friend:
+                    title = Node.void('title')
+                    friendnode.add_child(title)
+                    titledict = friend.get_dict('title')
+                    if 't' in titledict:
+                        title.set_attribute('t', str(titledict.get_int('t')))
+                    if 's' in titledict:
+                        title.set_attribute('s', str(titledict.get_int('s')))
+                    if 'd' in titledict:
+                        title.set_attribute('d', str(titledict.get_int('d')))
+
+                if 'title_gr' in friend:
+                    title_gr = Node.void('title_gr')
+                    friendnode.add_child(title_gr)
+                    title_grdict = friend.get_dict('title_gr')
+                    if 't' in title_grdict:
+                        title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+                    if 's' in title_grdict:
+                        title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+                    if 'd' in title_grdict:
+                        title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+                # Groove gauge level-ups
+                gr_s = Node.void('gr_s')
+                friendnode.add_child(gr_s)
+                index = 1
+                for entry in friend.get_int_array('gr_s', 5):
+                    gr_s.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+                gr_d = Node.void('gr_d')
+                friendnode.add_child(gr_d)
+                index = 1
+                for entry in friend.get_int_array('gr_d', 5):
+                    gr_d.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+        # Play area
+        areas = profile.get_int_array('play_area', 55)
+        play_area = Node.void('play_area')
+        root.add_child(play_area)
+        for i in range(len(areas)):
+            play_area.set_attribute('play_cnt{}'.format(i), str(areas[i]))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Grab last node and accessories so we can make decisions based on type
+        last = request.child('last')
+        lastdict = newprofile.get_dict('last')
+        mode = int(last.attribute('mode'))
+        style = int(last.attribute('style'))
+        is_dp = style == self.GAME_STYLE_DOUBLE
+
+        # Drill rankings
+        title = request.child('title')
+        title_gr = request.child('title_gr')
+        titledict = newprofile.get_dict('title')
+        title_grdict = newprofile.get_dict('title_gr')
+
+        # Groove radar level ups
+        gr = request.child('gr')
+
+        # Set the correct values depending on if we're single or double play
+        if is_dp:
+            play_stats.increment_int('double_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_d',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('d', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('d', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        else:
+            play_stats.increment_int('single_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_s',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('s', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('s', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        play_stats.increment_int('cnt_m{}'.format(mode))
+
+        # Result stars
+        result_star = request.child('result_star')
+        if result_star is not None:
+            newprofile.replace_int_array(
+                'result_stars',
+                9,
+                [
+                    intish(result_star.attribute('slot1')),
+                    intish(result_star.attribute('slot2')),
+                    intish(result_star.attribute('slot3')),
+                    intish(result_star.attribute('slot4')),
+                    intish(result_star.attribute('slot5')),
+                    intish(result_star.attribute('slot6')),
+                    intish(result_star.attribute('slot7')),
+                    intish(result_star.attribute('slot8')),
+                    intish(result_star.attribute('slot9')),
+                ],
+            )
+
+        # Target stuff
+        target = request.child('target')
+        if target is not None:
+            newprofile.replace_int('target_flag', intish(target.attribute('flag')))
+            newprofile.replace_int('target_setnum', intish(target.attribute('setnum')))
+
+        # Update last attributes
+        lastdict.replace_int('rival1', intish(last.attribute('rival1')))
+        lastdict.replace_int('rival2', intish(last.attribute('rival2')))
+        lastdict.replace_int('rival3', intish(last.attribute('rival3')))
+        lastdict.replace_int('style', intish(last.attribute('style')))
+        lastdict.replace_int('mode', intish(last.attribute('mode')))
+        lastdict.replace_int('cate', intish(last.attribute('cate')))
+        lastdict.replace_int('sort', intish(last.attribute('sort')))
+        lastdict.replace_int('mid', intish(last.attribute('mid')))
+        lastdict.replace_int('mtype', intish(last.attribute('mtype')))
+        lastdict.replace_int('cid', intish(last.attribute('cid')))
+        lastdict.replace_int('ctype', intish(last.attribute('ctype')))
+        lastdict.replace_int('sid', intish(last.attribute('sid')))
+        newprofile.replace_dict('last', lastdict)
+
+        # Grab character options
+        chara = request.child('chara')
+        if chara is not None:
+            newprofile.replace_int('chara', intish(chara.attribute('my')))
+        chara_opt = request.child('chara_opt')
+        if chara_opt is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('chara_opt', 96, chara_opt.value[:96])
+
+        # Options
+        opt = request.child('opt')
+        if opt is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('opt', 16, opt.value[:16])
+
+        # Experience and stars
+        exp = request.child_value('exp')
+        if exp is not None:
+            play_stats.replace_int('exp', play_stats.get_int('exp') + exp)
+        star = request.child_value('star')
+        if star is not None:
+            newprofile.replace_int('star', newprofile.get_int('star') + star)
+        star_c = request.child_value('star_c')
+        if star_c is not None:
+            newprofile.replace_int('star_c', newprofile.get_int('star_c') + exp)
+
+        # Update game flags
+        for child in request.children:
+            if child.name != 'flag':
+                continue
+            try:
+                value = int(child.attribute('data'))
+                offset = int(child.attribute('no'))
+            except ValueError:
+                continue
+
+            flags = newprofile.get_int_array('flag', 256, [1] * 256)
+            if offset < 0 or offset >= len(flags):
+                continue
+            flags[offset] = value
+            newprofile.replace_int_array('flag', 256, flags)
+
+        # Workout mode support
+        newweight = -1
+        oldweight = newprofile.get_int('weight')
+        for child in request.children:
+            if child.name != 'weight':
+                continue
+            newweight = child.value
+        if newweight < 0:
+            newweight = oldweight
+
+        # Either update or unset the weight depending on the game
+        if newweight == 0:
+            # Weight is unset or we declined to use this feature, remove from profile
+            if 'weight' in newprofile:
+                del newprofile['weight']
+        else:
+            # Weight has been set or previously retrieved, we should save calories
+            newprofile.replace_int('weight', newweight)
+            total = 0
+            for child in request.children:
+                if child.name != 'calory':
+                    continue
+                total += child.value
+            self.data.local.user.put_time_based_achievement(
+                self.game,
+                self.version,
+                userid,
+                0,
+                'workout',
+                {
+                    'calories': total,
+                    'weight': newweight,
+                },
+            )
+
+        # Look up old friends
+        oldfriends: List[Optional[UserID]] = [None] * 10
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            oldfriends[pos] = link.other_userid
+
+        # Save any rivals that were added/removed/changed
+        newfriends = oldfriends[:]
+        for child in request.children:
+            if child.name != 'friend':
+                continue
+
+            code = int(child.attribute('code'))
+            pos = int(child.attribute('pos'))
+
+            if pos >= 0 and pos < 10:
+                if code == 0:
+                    # We cleared this friend
+                    newfriends[pos] = None
+                else:
+                    # Try looking up the userid
+                    newfriends[pos] = self.data.remote.user.from_extid(self.game, self.version, code)
+
+        # Diff the set of links to determine updates
+        for i in range(10):
+            if newfriends[i] == oldfriends[i]:
+                continue
+
+            if newfriends[i] is None:
+                # Kill the rival in this location
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+            elif oldfriends[i] is None:
+                # Add rival in this location
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+            else:
+                # Changed the rival here, kill the old one, add the new one
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+
+        # Play area counter
+        shop_area = int(request.attribute('shop_area'))
+        if shop_area >= 0 and shop_area < 55:
+            areas = newprofile.get_int_array('play_area', 55)
+            areas[shop_area] = areas[shop_area] + 1
+            newprofile.replace_int_array('play_area', 55, areas)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/ddr/ddr2014.py b/bemani/backend/ddr/ddr2014.py
new file mode 100644
index 0000000..368ba57
--- /dev/null
+++ b/bemani/backend/ddr/ddr2014.py
@@ -0,0 +1,800 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Dict, List, Optional
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.backend.ddr.ddr2013 import DDR2013
+from bemani.backend.ddr.common import (
+    DDRGameAreaHiscoreHandler,
+    DDRGameFriendHandler,
+    DDRGameHiscoreHandler,
+    DDRGameLoadDailyHandler,
+    DDRGameLoadHandler,
+    DDRGameLockHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameRecorderHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTaxInfoHandler,
+)
+from bemani.common import VersionConstants, ValidatedDict, Time, intish
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class DDR2014(
+    DDRGameAreaHiscoreHandler,
+    DDRGameFriendHandler,
+    DDRGameHiscoreHandler,
+    DDRGameLoadDailyHandler,
+    DDRGameLoadHandler,
+    DDRGameLockHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameRecorderHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTaxInfoHandler,
+    DDRBase,
+):
+
+    name = 'DanceDanceRevolution 2014'
+    version = VersionConstants.DDR_2014
+
+    GAME_STYLE_SINGLE = 0
+    GAME_STYLE_DOUBLE = 1
+    GAME_STYLE_VERSUS = 2
+
+    GAME_RANK_AAA = 1
+    GAME_RANK_AA = 2
+    GAME_RANK_A = 3
+    GAME_RANK_B = 4
+    GAME_RANK_C = 5
+    GAME_RANK_D = 6
+    GAME_RANK_E = 7
+
+    GAME_CHART_SINGLE_BEGINNER = 0
+    GAME_CHART_SINGLE_BASIC = 1
+    GAME_CHART_SINGLE_DIFFICULT = 2
+    GAME_CHART_SINGLE_EXPERT = 3
+    GAME_CHART_SINGLE_CHALLENGE = 4
+    GAME_CHART_DOUBLE_BASIC = 5
+    GAME_CHART_DOUBLE_DIFFICULT = 6
+    GAME_CHART_DOUBLE_EXPERT = 7
+    GAME_CHART_DOUBLE_CHALLENGE = 8
+
+    GAME_HALO_NONE = 0
+    GAME_HALO_GREAT_COMBO = 1
+    GAME_HALO_PERFECT_COMBO = 2
+    GAME_HALO_MARVELOUS_COMBO = 3
+    GAME_HALO_GOOD_COMBO = 4
+
+    GAME_MAX_SONGS = 800
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR2013(self.data, self.config, self.model)
+
+    def game_to_db_rank(self, game_rank: int) -> int:
+        return {
+            self.GAME_RANK_AAA: self.RANK_AAA,
+            self.GAME_RANK_AA: self.RANK_AA,
+            self.GAME_RANK_A: self.RANK_A,
+            self.GAME_RANK_B: self.RANK_B,
+            self.GAME_RANK_C: self.RANK_C,
+            self.GAME_RANK_D: self.RANK_D,
+            self.GAME_RANK_E: self.RANK_E,
+        }[game_rank]
+
+    def db_to_game_rank(self, db_rank: int) -> int:
+        return {
+            self.RANK_AAA: self.GAME_RANK_AAA,
+            self.RANK_AA_PLUS: self.GAME_RANK_AA,
+            self.RANK_AA: self.GAME_RANK_AA,
+            self.RANK_AA_MINUS: self.GAME_RANK_A,
+            self.RANK_A_PLUS: self.GAME_RANK_A,
+            self.RANK_A: self.GAME_RANK_A,
+            self.RANK_A_MINUS: self.GAME_RANK_B,
+            self.RANK_B_PLUS: self.GAME_RANK_B,
+            self.RANK_B: self.GAME_RANK_B,
+            self.RANK_B_MINUS: self.GAME_RANK_C,
+            self.RANK_C_PLUS: self.GAME_RANK_C,
+            self.RANK_C: self.GAME_RANK_C,
+            self.RANK_C_MINUS: self.GAME_RANK_D,
+            self.RANK_D_PLUS: self.GAME_RANK_D,
+            self.RANK_D: self.GAME_RANK_D,
+            self.RANK_E: self.GAME_RANK_E,
+        }[db_rank]
+
+    def game_to_db_chart(self, game_chart: int) -> int:
+        return {
+            self.GAME_CHART_SINGLE_BEGINNER: self.CHART_SINGLE_BEGINNER,
+            self.GAME_CHART_SINGLE_BASIC: self.CHART_SINGLE_BASIC,
+            self.GAME_CHART_SINGLE_DIFFICULT: self.CHART_SINGLE_DIFFICULT,
+            self.GAME_CHART_SINGLE_EXPERT: self.CHART_SINGLE_EXPERT,
+            self.GAME_CHART_SINGLE_CHALLENGE: self.CHART_SINGLE_CHALLENGE,
+            self.GAME_CHART_DOUBLE_BASIC: self.CHART_DOUBLE_BASIC,
+            self.GAME_CHART_DOUBLE_DIFFICULT: self.CHART_DOUBLE_DIFFICULT,
+            self.GAME_CHART_DOUBLE_EXPERT: self.CHART_DOUBLE_EXPERT,
+            self.GAME_CHART_DOUBLE_CHALLENGE: self.CHART_DOUBLE_CHALLENGE,
+        }[game_chart]
+
+    def db_to_game_chart(self, db_chart: int) -> int:
+        return {
+            self.CHART_SINGLE_BEGINNER: self.GAME_CHART_SINGLE_BEGINNER,
+            self.CHART_SINGLE_BASIC: self.GAME_CHART_SINGLE_BASIC,
+            self.CHART_SINGLE_DIFFICULT: self.GAME_CHART_SINGLE_DIFFICULT,
+            self.CHART_SINGLE_EXPERT: self.GAME_CHART_SINGLE_EXPERT,
+            self.CHART_SINGLE_CHALLENGE: self.GAME_CHART_SINGLE_CHALLENGE,
+            self.CHART_DOUBLE_BASIC: self.GAME_CHART_DOUBLE_BASIC,
+            self.CHART_DOUBLE_DIFFICULT: self.GAME_CHART_DOUBLE_DIFFICULT,
+            self.CHART_DOUBLE_EXPERT: self.GAME_CHART_DOUBLE_EXPERT,
+            self.CHART_DOUBLE_CHALLENGE: self.GAME_CHART_DOUBLE_CHALLENGE,
+        }[db_chart]
+
+    def db_to_game_halo(self, db_halo: int) -> int:
+        if db_halo == self.HALO_MARVELOUS_FULL_COMBO:
+            combo_type = self.GAME_HALO_MARVELOUS_COMBO
+        elif db_halo == self.HALO_PERFECT_FULL_COMBO:
+            combo_type = self.GAME_HALO_PERFECT_COMBO
+        elif db_halo == self.HALO_GREAT_FULL_COMBO:
+            combo_type = self.GAME_HALO_GREAT_COMBO
+        elif db_halo == self.HALO_GOOD_FULL_COMBO:
+            combo_type = self.GAME_HALO_GOOD_COMBO
+        else:
+            combo_type = self.GAME_HALO_NONE
+        return combo_type
+
+    def handle_game_common_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        for flagid in range(512):
+            flag = Node.void('flag')
+            game.add_child(flag)
+
+            flag.set_attribute('id', str(flagid))
+            flag.set_attribute('t', '0')
+            flag.set_attribute('s1', '0')
+            flag.set_attribute('s2', '0')
+            flag.set_attribute('area', '51')
+            flag.set_attribute('is_final', '0')
+
+        # Last month's hit chart
+        hit_chart = self.data.local.music.get_hit_chart(self.game, self.music_version, self.GAME_MAX_SONGS, 30)
+        counts_by_reflink = [0] * self.GAME_MAX_SONGS
+        for (reflink, plays) in hit_chart:
+            if reflink >= 0 and reflink < self.GAME_MAX_SONGS:
+                counts_by_reflink[reflink] = plays
+        game.add_child(Node.u32_array('cnt_music_monthly', counts_by_reflink))
+
+        # Last week's hit chart
+        hit_chart = self.data.local.music.get_hit_chart(self.game, self.music_version, self.GAME_MAX_SONGS, 7)
+        counts_by_reflink = [0] * self.GAME_MAX_SONGS
+        for (reflink, plays) in hit_chart:
+            if reflink >= 0 and reflink < self.GAME_MAX_SONGS:
+                counts_by_reflink[reflink] = plays
+        game.add_child(Node.u32_array('cnt_music_weekly', counts_by_reflink))
+
+        # Last day's hit chart
+        hit_chart = self.data.local.music.get_hit_chart(self.game, self.music_version, self.GAME_MAX_SONGS, 1)
+        counts_by_reflink = [0] * self.GAME_MAX_SONGS
+        for (reflink, plays) in hit_chart:
+            if reflink >= 0 and reflink < self.GAME_MAX_SONGS:
+                counts_by_reflink[reflink] = plays
+        game.add_child(Node.u32_array('cnt_music_daily', counts_by_reflink))
+
+        return game
+
+    def handle_game_load_m_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        refid = request.attribute('refid')
+
+        if extid is not None:
+            # Rival score loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        else:
+            # Self score loading
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+        else:
+            scores = []
+
+        sortedscores: Dict[int, Dict[int, Score]] = {}
+        for score in scores:
+            if score.id not in sortedscores:
+                sortedscores[score.id] = {}
+            sortedscores[score.id][score.chart] = score
+
+        game = Node.void('game')
+        for song in sortedscores:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink', str(song))
+
+            for chart in sortedscores[song]:
+                score = sortedscores[song][chart]
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                gamerank = self.db_to_game_rank(score.data.get_int('rank'))
+                combo_type = self.db_to_game_halo(score.data.get_int('halo'))
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.u32('score', score.points))
+                typenode.add_child(Node.u16('count', score.plays))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+                # The game optionally receives hard, life8, life4, risky, assist_clear, normal_clear
+                # u8 values too, and saves music scores with these set, but the UI doesn't appear to
+                # do anything with them, so we don't care.
+
+        return game
+
+    def handle_game_save_m_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        songid = int(request.attribute('mid'))
+        chart = self.game_to_db_chart(int(request.attribute('mtype')))
+
+        # Calculate statistics
+        data = request.child('data')
+        points = int(data.attribute('score'))
+        combo = int(data.attribute('combo'))
+        rank = self.game_to_db_rank(int(data.attribute('rank')))
+        if points == 1000000:
+            halo = self.HALO_MARVELOUS_FULL_COMBO
+        elif int(data.attribute('perf_fc')) != 0:
+            halo = self.HALO_PERFECT_FULL_COMBO
+        elif int(data.attribute('great_fc')) != 0:
+            halo = self.HALO_GREAT_FULL_COMBO
+        elif int(data.attribute('good_fc')) != 0:
+            halo = self.HALO_GOOD_FULL_COMBO
+        else:
+            halo = self.HALO_NONE
+        trace = request.child_value('trace')
+
+        # Save the score, regardless of whether we have a refid. If we save
+        # an anonymous score, it only goes into the DB to count against the
+        # number of plays for that song/chart.
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        self.update_score(
+            userid,
+            songid,
+            chart,
+            points,
+            rank,
+            halo,
+            combo,
+            trace,
+        )
+
+        # No response needed
+        game = Node.void('game')
+        return game
+
+    def handle_game_load_edit_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+    def handle_game_save_resultshot_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+    def handle_game_trace_request(self, request: Node) -> Node:
+        # This is almost identical to 2013 and below, except it will never
+        # even try to request course traces, so we fork from common functionality.
+        extid = int(request.attribute('code'))
+        chart = int(request.attribute('type'))
+        mid = intish(request.attribute('mid'))
+
+        # Base packet is just game, if we find something we add to it
+        game = Node.void('game')
+
+        # Rival trace loading
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            # Nothing to load
+            return game
+
+        # Load trace from song score
+        songscore = self.data.remote.music.get_score(
+            self.game,
+            self.music_version,
+            userid,
+            mid,
+            self.game_to_db_chart(chart),
+        )
+        if songscore is not None and 'trace' in songscore.data:
+            game.add_child(Node.u32('size', len(songscore.data['trace'])))
+            game.add_child(Node.u8_array('trace', songscore.data['trace']))
+
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('game')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Basic game settings
+        root.add_child(Node.string('seq', ''))
+        root.add_child(Node.u32('code', profile.get_int('extid')))
+        root.add_child(Node.string('name', profile.get_str('name')))
+        root.add_child(Node.u8('area', profile.get_int('area', 51)))
+        root.add_child(Node.u32('cnt_s', play_stats.get_int('single_plays')))
+        root.add_child(Node.u32('cnt_d', play_stats.get_int('double_plays')))
+        root.add_child(Node.u32('cnt_b', play_stats.get_int('battle_plays')))  # This could be wrong, its a guess
+        root.add_child(Node.u32('cnt_m0', play_stats.get_int('cnt_m0')))
+        root.add_child(Node.u32('cnt_m1', play_stats.get_int('cnt_m1')))
+        root.add_child(Node.u32('cnt_m2', play_stats.get_int('cnt_m2')))
+        root.add_child(Node.u32('cnt_m3', play_stats.get_int('cnt_m3')))
+        root.add_child(Node.u32('cnt_m4', play_stats.get_int('cnt_m4')))
+        root.add_child(Node.u32('cnt_m5', play_stats.get_int('cnt_m5')))
+        root.add_child(Node.u32('exp', play_stats.get_int('exp')))
+        root.add_child(Node.u32('exp_o', profile.get_int('exp_o')))
+        root.add_child(Node.u32('star', profile.get_int('star')))
+        root.add_child(Node.u32('star_c', profile.get_int('star_c')))
+        root.add_child(Node.u8('combo', profile.get_int('combo', 0)))
+        root.add_child(Node.u8('timing_diff', profile.get_int('early_late', 0)))
+
+        # Character stuff
+        chara = Node.void('chara')
+        root.add_child(chara)
+        chara.set_attribute('my', str(profile.get_int('chara', 30)))
+        root.add_child(Node.u16_array('chara_opt', profile.get_int_array('chara_opt', 96, [208] * 96)))
+
+        # Drill rankings
+        if 'title_gr' in profile:
+            title_gr = Node.void('title_gr')
+            root.add_child(title_gr)
+            title_grdict = profile.get_dict('title_gr')
+            if 't' in title_grdict:
+                title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+            if 's' in title_grdict:
+                title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+            if 'd' in title_grdict:
+                title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+        # Calorie mode
+        if 'weight' in profile:
+            workouts = self.data.local.user.get_time_based_achievements(
+                self.game,
+                self.version,
+                userid,
+                achievementtype='workout',
+                since=Time.now() - Time.SECONDS_IN_DAY,
+            )
+            total = sum([w.data.get_int('calories') for w in workouts])
+            workout = Node.void('workout')
+            root.add_child(workout)
+            workout.set_attribute('weight', str(profile.get_int('weight')))
+            workout.set_attribute('day', str(total))
+            workout.set_attribute('disp', '1')
+
+            # Unsure if this should be last day, or total calories ever
+            totalcalorie = Node.void('totalcalorie')
+            root.add_child(totalcalorie)
+            totalcalorie.set_attribute('total', str(total))
+
+        # Daily play counts
+        last_play_date = play_stats.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = play_stats.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        daycount = Node.void('daycount')
+        root.add_child(daycount)
+        daycount.set_attribute('playcount', str(today_count))
+
+        # Daily combo stuff, unknown how this works
+        dailycombo = Node.void('dailycombo')
+        root.add_child(dailycombo)
+        dailycombo.set_attribute('daily_combo', str(0))
+        dailycombo.set_attribute('daily_combo_lv', str(0))
+
+        # Last cursor settings
+        last = Node.void('last')
+        root.add_child(last)
+        lastdict = profile.get_dict('last')
+        last.set_attribute('rival1', str(lastdict.get_int('rival1', -1)))
+        last.set_attribute('rival2', str(lastdict.get_int('rival2', -1)))
+        last.set_attribute('rival3', str(lastdict.get_int('rival3', -1)))
+        last.set_attribute('fri', str(lastdict.get_int('rival1', -1)))  # This literally goes to the same memory in 2014
+        last.set_attribute('style', str(lastdict.get_int('style')))
+        last.set_attribute('mode', str(lastdict.get_int('mode')))
+        last.set_attribute('cate', str(lastdict.get_int('cate')))
+        last.set_attribute('sort', str(lastdict.get_int('sort')))
+        last.set_attribute('mid', str(lastdict.get_int('mid')))
+        last.set_attribute('mtype', str(lastdict.get_int('mtype')))
+        last.set_attribute('cid', str(lastdict.get_int('cid')))
+        last.set_attribute('ctype', str(lastdict.get_int('ctype')))
+        last.set_attribute('sid', str(lastdict.get_int('sid')))
+
+        # Result stars
+        result_star = Node.void('result_star')
+        root.add_child(result_star)
+        result_stars = profile.get_int_array('result_stars', 9)
+        for i in range(9):
+            result_star.set_attribute('slot{}'.format(i + 1), str(result_stars[i]))
+
+        # Groove gauge level-ups
+        gr_s = Node.void('gr_s')
+        root.add_child(gr_s)
+        index = 1
+        for entry in profile.get_int_array('gr_s', 5):
+            gr_s.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        gr_d = Node.void('gr_d')
+        root.add_child(gr_d)
+        index = 1
+        for entry in profile.get_int_array('gr_d', 5):
+            gr_d.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        # Options in menus
+        root.add_child(Node.s16_array('opt', profile.get_int_array('opt', 16)))
+        root.add_child(Node.s16_array('opt_ex', profile.get_int_array('opt_ex', 16)))
+        option_ver = Node.void('option_ver')
+        root.add_child(option_ver)
+        option_ver.set_attribute('ver', str(profile.get_int('option_ver', 2)))
+        if 'option_02' in profile:
+            root.add_child(Node.s16_array('option_02', profile.get_int_array('option_02', 24)))
+
+        # Unlock flags
+        root.add_child(Node.u8_array('flag', profile.get_int_array('flag', 512, [1] * 512)[:256]))
+        root.add_child(Node.u8_array('flag_ex', profile.get_int_array('flag', 512, [1] * 512)))
+
+        # Ranking display?
+        root.add_child(Node.u16_array('rank', profile.get_int_array('rank', 100)))
+
+        # Rivals
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            friend = self.get_profile(link.other_userid)
+            play_stats = self.get_play_statistics(link.other_userid)
+            if friend is not None:
+                friendnode = Node.void('friend')
+                root.add_child(friendnode)
+                friendnode.set_attribute('pos', str(pos))
+                friendnode.set_attribute('vs', '0')
+                friendnode.set_attribute('up', '0')
+                friendnode.add_child(Node.u32('code', friend.get_int('extid')))
+                friendnode.add_child(Node.string('name', friend.get_str('name')))
+                friendnode.add_child(Node.u8('area', friend.get_int('area', 51)))
+                friendnode.add_child(Node.u32('exp', play_stats.get_int('exp')))
+                friendnode.add_child(Node.u32('star', friend.get_int('star')))
+
+                # Drill rankings
+                if 'title' in friend:
+                    title = Node.void('title')
+                    friendnode.add_child(title)
+                    titledict = friend.get_dict('title')
+                    if 't' in titledict:
+                        title.set_attribute('t', str(titledict.get_int('t')))
+                    if 's' in titledict:
+                        title.set_attribute('s', str(titledict.get_int('s')))
+                    if 'd' in titledict:
+                        title.set_attribute('d', str(titledict.get_int('d')))
+
+                if 'title_gr' in friend:
+                    title_gr = Node.void('title_gr')
+                    friendnode.add_child(title_gr)
+                    title_grdict = friend.get_dict('title_gr')
+                    if 't' in title_grdict:
+                        title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+                    if 's' in title_grdict:
+                        title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+                    if 'd' in title_grdict:
+                        title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+                # Groove gauge level-ups
+                gr_s = Node.void('gr_s')
+                friendnode.add_child(gr_s)
+                index = 1
+                for entry in friend.get_int_array('gr_s', 5):
+                    gr_s.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+                gr_d = Node.void('gr_d')
+                friendnode.add_child(gr_d)
+                index = 1
+                for entry in friend.get_int_array('gr_d', 5):
+                    gr_d.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+        # Target stuff
+        target = Node.void('target')
+        root.add_child(target)
+        target.set_attribute('flag', str(profile.get_int('target_flag')))
+        target.set_attribute('setnum', str(profile.get_int('target_setnum')))
+
+        # Play area
+        areas = profile.get_int_array('play_area', 55)
+        play_area = Node.void('play_area')
+        root.add_child(play_area)
+        for i in range(len(areas)):
+            play_area.set_attribute('play_cnt{}'.format(i), str(areas[i]))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Grab last node and accessories so we can make decisions based on type
+        last = request.child('last')
+        lastdict = newprofile.get_dict('last')
+        mode = int(last.attribute('mode'))
+        style = int(last.attribute('style'))
+        is_dp = style == self.GAME_STYLE_DOUBLE
+
+        # Drill rankings
+        title = request.child('title')
+        title_gr = request.child('title_gr')
+        titledict = newprofile.get_dict('title')
+        title_grdict = newprofile.get_dict('title_gr')
+
+        # Groove radar level ups
+        gr = request.child('gr')
+
+        # Set the correct values depending on if we're single or double play
+        if is_dp:
+            play_stats.increment_int('double_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_d',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('d', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('d', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        else:
+            play_stats.increment_int('single_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_s',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('s', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('s', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        play_stats.increment_int('cnt_m{}'.format(mode))
+
+        # Result stars
+        result_star = request.child('result_star')
+        if result_star is not None:
+            newprofile.replace_int_array(
+                'result_stars',
+                9,
+                [
+                    intish(result_star.attribute('slot1')),
+                    intish(result_star.attribute('slot2')),
+                    intish(result_star.attribute('slot3')),
+                    intish(result_star.attribute('slot4')),
+                    intish(result_star.attribute('slot5')),
+                    intish(result_star.attribute('slot6')),
+                    intish(result_star.attribute('slot7')),
+                    intish(result_star.attribute('slot8')),
+                    intish(result_star.attribute('slot9')),
+                ],
+            )
+
+        # Target stuff
+        target = request.child('target')
+        if target is not None:
+            newprofile.replace_int('target_flag', intish(target.attribute('flag')))
+            newprofile.replace_int('target_setnum', intish(target.attribute('setnum')))
+
+        # Update last attributes
+        lastdict.replace_int('rival1', intish(last.attribute('rival1')))
+        lastdict.replace_int('rival2', intish(last.attribute('rival2')))
+        lastdict.replace_int('rival3', intish(last.attribute('rival3')))
+        lastdict.replace_int('style', intish(last.attribute('style')))
+        lastdict.replace_int('mode', intish(last.attribute('mode')))
+        lastdict.replace_int('cate', intish(last.attribute('cate')))
+        lastdict.replace_int('sort', intish(last.attribute('sort')))
+        lastdict.replace_int('mid', intish(last.attribute('mid')))
+        lastdict.replace_int('mtype', intish(last.attribute('mtype')))
+        lastdict.replace_int('cid', intish(last.attribute('cid')))
+        lastdict.replace_int('ctype', intish(last.attribute('ctype')))
+        lastdict.replace_int('sid', intish(last.attribute('sid')))
+        newprofile.replace_dict('last', lastdict)
+
+        # Grab character options
+        chara = request.child('chara')
+        if chara is not None:
+            newprofile.replace_int('chara', intish(chara.attribute('my')))
+        chara_opt = request.child('chara_opt')
+        if chara_opt is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('chara_opt', 96, chara_opt.value[:96])
+
+        # Options
+        option_02 = request.child('option_02')
+        if option_02 is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('option_02', 24, option_02.value[:24])
+
+        # Experience and stars
+        exp = request.child_value('exp')
+        if exp is not None:
+            play_stats.replace_int('exp', play_stats.get_int('exp') + exp)
+        star = request.child_value('star')
+        if star is not None:
+            newprofile.replace_int('star', newprofile.get_int('star') + star)
+        star_c = request.child_value('star_c')
+        if star_c is not None:
+            newprofile.replace_int('star_c', newprofile.get_int('star_c') + exp)
+
+        # Update game flags
+        for child in request.children:
+            if child.name not in ['flag', 'flag_ex']:
+                continue
+            try:
+                value = int(child.attribute('data'))
+                offset = int(child.attribute('no'))
+            except ValueError:
+                continue
+
+            flags = newprofile.get_int_array('flag', 512, [1] * 512)
+            if offset < 0 or offset >= len(flags):
+                continue
+            flags[offset] = value
+            newprofile.replace_int_array('flag', 512, flags)
+
+        # Workout mode support
+        newweight = -1
+        oldweight = newprofile.get_int('weight')
+        for child in request.children:
+            if child.name != 'weight':
+                continue
+            newweight = child.value
+        if newweight < 0:
+            newweight = oldweight
+
+        # Either update or unset the weight depending on the game
+        if newweight == 0:
+            # Weight is unset or we declined to use this feature, remove from profile
+            if 'weight' in newprofile:
+                del newprofile['weight']
+        else:
+            # Weight has been set or previously retrieved, we should save calories
+            newprofile.replace_int('weight', newweight)
+            total = 0
+            for child in request.children:
+                if child.name != 'calory':
+                    continue
+                total += child.value
+            self.data.local.user.put_time_based_achievement(
+                self.game,
+                self.version,
+                userid,
+                0,
+                'workout',
+                {
+                    'calories': total,
+                    'weight': newweight,
+                },
+            )
+
+        # Look up old friends
+        oldfriends: List[Optional[UserID]] = [None] * 10
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            oldfriends[pos] = link.other_userid
+
+        # Save any rivals that were added/removed/changed
+        newfriends = oldfriends[:]
+        for child in request.children:
+            if child.name != 'friend':
+                continue
+
+            code = int(child.attribute('code'))
+            pos = int(child.attribute('pos'))
+
+            if pos >= 0 and pos < 10:
+                if code == 0:
+                    # We cleared this friend
+                    newfriends[pos] = None
+                else:
+                    # Try looking up the userid
+                    newfriends[pos] = self.data.remote.user.from_extid(self.game, self.version, code)
+
+        # Diff the set of links to determine updates
+        for i in range(10):
+            if newfriends[i] == oldfriends[i]:
+                continue
+
+            if newfriends[i] is None:
+                # Kill the rival in this location
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+            elif oldfriends[i] is None:
+                # Add rival in this location
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+            else:
+                # Changed the rival here, kill the old one, add the new one
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+
+        # Play area counter
+        shop_area = int(request.attribute('shop_area'))
+        if shop_area >= 0 and shop_area < 55:
+            areas = newprofile.get_int_array('play_area', 55)
+            areas[shop_area] = areas[shop_area] + 1
+            newprofile.replace_int_array('play_area', 55, areas)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/ddr/ddra20.py b/bemani/backend/ddr/ddra20.py
new file mode 100644
index 0000000..51b50e8
--- /dev/null
+++ b/bemani/backend/ddr/ddra20.py
@@ -0,0 +1,26 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.backend.ddr.ddrace import DDRAce
+from bemani.common import VersionConstants
+
+
+class DDRA20(
+    DDRBase,
+):
+
+    name = 'DanceDanceRevolution A20'
+    version = VersionConstants.DDR_A20
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRAce(self.data, self.config, self.model)
+
+    def supports_paseli(self) -> bool:
+        if self.model.dest != 'J':
+            # DDR Ace in USA mode doesn't support PASELI properly.
+            # When in Asia mode it shows PASELI but won't let you select it.
+            return False
+        else:
+            # All other modes should work with PASELI.
+            return True
diff --git a/bemani/backend/ddr/ddrace.py b/bemani/backend/ddr/ddrace.py
new file mode 100644
index 0000000..194adc6
--- /dev/null
+++ b/bemani/backend/ddr/ddrace.py
@@ -0,0 +1,801 @@
+# vim: set fileencoding=utf-8
+import base64
+from typing import Dict, List, Optional
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.ddr.base import DDRBase
+from bemani.backend.ddr.ddr2014 import DDR2014
+from bemani.common import ValidatedDict, VersionConstants, CardCipher, Time, ID, intish
+from bemani.data import Achievement, Machine, Score, UserID
+from bemani.protocol import Node
+
+
+class DDRAce(
+    DDRBase,
+    EventLogHandler,
+):
+
+    name = 'DanceDanceRevolution A'
+    version = VersionConstants.DDR_ACE
+
+    GAME_STYLE_SINGLE = 0
+    GAME_STYLE_DOUBLE = 1
+    GAME_STYLE_VERSUS = 2
+
+    GAME_RIVAL_TYPE_RIVAL3 = 32
+    GAME_RIVAL_TYPE_RIVAL2 = 16
+    GAME_RIVAL_TYPE_RIVAL1 = 8
+    GAME_RIVAL_TYPE_WORLD = 4
+    GAME_RIVAL_TYPE_AREA = 2
+    GAME_RIVAL_TYPE_MACHINE = 1
+
+    GAME_CHART_SINGLE_BEGINNER = 0
+    GAME_CHART_SINGLE_BASIC = 1
+    GAME_CHART_SINGLE_DIFFICULT = 2
+    GAME_CHART_SINGLE_EXPERT = 3
+    GAME_CHART_SINGLE_CHALLENGE = 4
+    GAME_CHART_DOUBLE_BASIC = 5
+    GAME_CHART_DOUBLE_DIFFICULT = 6
+    GAME_CHART_DOUBLE_EXPERT = 7
+    GAME_CHART_DOUBLE_CHALLENGE = 8
+
+    GAME_HALO_NONE = 6
+    GAME_HALO_GOOD_COMBO = 7
+    GAME_HALO_GREAT_COMBO = 8
+    GAME_HALO_PERFECT_COMBO = 9
+    GAME_HALO_MARVELOUS_COMBO = 10
+
+    GAME_RANK_E = 15
+    GAME_RANK_D = 14
+    GAME_RANK_D_PLUS = 13
+    GAME_RANK_C_MINUS = 12
+    GAME_RANK_C = 11
+    GAME_RANK_C_PLUS = 10
+    GAME_RANK_B_MINUS = 9
+    GAME_RANK_B = 8
+    GAME_RANK_B_PLUS = 7
+    GAME_RANK_A_MINUS = 6
+    GAME_RANK_A = 5
+    GAME_RANK_A_PLUS = 4
+    GAME_RANK_AA_MINUS = 3
+    GAME_RANK_AA = 2
+    GAME_RANK_AA_PLUS = 1
+    GAME_RANK_AAA = 0
+
+    GAME_MAX_SONGS = 1024
+
+    GAME_COMMON_AREA_OFFSET = 1
+    GAME_COMMON_WEIGHT_DISPLAY_OFFSET = 3
+    GAME_COMMON_CHARACTER_OFFSET = 4
+    GAME_COMMON_EXTRA_CHARGE_OFFSET = 5
+    GAME_COMMON_TOTAL_PLAYS_OFFSET = 9
+    GAME_COMMON_SINGLE_PLAYS_OFFSET = 11
+    GAME_COMMON_DOUBLE_PLAYS_OFFSET = 12
+    GAME_COMMON_WEIGHT_OFFSET = 17
+    GAME_COMMON_NAME_OFFSET = 25
+    GAME_COMMON_SEQ_OFFSET = 26
+
+    GAME_OPTION_SCROLL_OFFSET = 1
+    GAME_OPTION_BOOST_OFFSET = 2
+    GAME_OPTION_APPEARANCE_OFFSET = 3
+    GAME_OPTION_TURN_OFFSET = 4
+    GAME_OPTION_STEP_ZONE_OFFSET = 5
+    GAME_OPTION_SCROLL_OFFSET = 6
+    GAME_OPTION_ARROW_COLOR_OFFSET = 7
+    GAME_OPTION_CUT_OFFSET = 8
+    GAME_OPTION_FREEZE_OFFSET = 9
+    GAME_OPTION_JUMPS_OFFSET = 10
+    GAME_OPTION_ARROW_SKIN_OFFSET = 11
+    GAME_OPTION_FILTER_OFFSET = 12
+    GAME_OPTION_GUIDELINE_OFFSET = 13
+    GAME_OPTION_GAUGE_OFFSET = 14
+    GAME_OPTION_COMBO_POSITION_OFFSET = 15
+    GAME_OPTION_FAST_SLOW_OFFSET = 16
+
+    GAME_LAST_CALORIES_OFFSET = 10
+
+    GAME_RIVAL_SLOT_1_ACTIVE_OFFSET = 1
+    GAME_RIVAL_SLOT_2_ACTIVE_OFFSET = 2
+    GAME_RIVAL_SLOT_3_ACTIVE_OFFSET = 3
+    GAME_RIVAL_SLOT_1_DDRCODE_OFFSET = 9
+    GAME_RIVAL_SLOT_2_DDRCODE_OFFSET = 10
+    GAME_RIVAL_SLOT_3_DDRCODE_OFFSET = 11
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR2014(self.data, self.config, self.model)
+
+    def supports_paseli(self) -> bool:
+        if self.model.dest != 'J':
+            # DDR Ace in USA mode doesn't support PASELI properly.
+            # When in Asia mode it shows PASELI but won't let you select it.
+            return False
+        else:
+            # All other modes should work with PASELI.
+            return True
+
+    def game_to_db_rank(self, game_rank: int) -> int:
+        return {
+            self.GAME_RANK_AAA: self.RANK_AAA,
+            self.GAME_RANK_AA_PLUS: self.RANK_AA_PLUS,
+            self.GAME_RANK_AA: self.RANK_AA,
+            self.GAME_RANK_AA_MINUS: self.RANK_AA_MINUS,
+            self.GAME_RANK_A_PLUS: self.RANK_A_PLUS,
+            self.GAME_RANK_A: self.RANK_A,
+            self.GAME_RANK_A_MINUS: self.RANK_A_MINUS,
+            self.GAME_RANK_B_PLUS: self.RANK_B_PLUS,
+            self.GAME_RANK_B: self.RANK_B,
+            self.GAME_RANK_B_MINUS: self.RANK_B_MINUS,
+            self.GAME_RANK_C_PLUS: self.RANK_C_PLUS,
+            self.GAME_RANK_C: self.RANK_C,
+            self.GAME_RANK_C_MINUS: self.RANK_C_MINUS,
+            self.GAME_RANK_D_PLUS: self.RANK_D_PLUS,
+            self.GAME_RANK_D: self.RANK_D,
+            self.GAME_RANK_E: self.RANK_E,
+        }[game_rank]
+
+    def db_to_game_rank(self, db_rank: int) -> int:
+        return {
+            self.RANK_AAA: self.GAME_RANK_AAA,
+            self.RANK_AA_PLUS: self.GAME_RANK_AA_PLUS,
+            self.RANK_AA: self.GAME_RANK_AA,
+            self.RANK_AA_MINUS: self.GAME_RANK_AA_MINUS,
+            self.RANK_A_PLUS: self.GAME_RANK_A_PLUS,
+            self.RANK_A: self.GAME_RANK_A,
+            self.RANK_A_MINUS: self.GAME_RANK_A_MINUS,
+            self.RANK_B_PLUS: self.GAME_RANK_B_PLUS,
+            self.RANK_B: self.GAME_RANK_B,
+            self.RANK_B_MINUS: self.GAME_RANK_B_MINUS,
+            self.RANK_C_PLUS: self.GAME_RANK_C_PLUS,
+            self.RANK_C: self.GAME_RANK_C,
+            self.RANK_C_MINUS: self.GAME_RANK_C_MINUS,
+            self.RANK_D_PLUS: self.GAME_RANK_D_PLUS,
+            self.RANK_D: self.GAME_RANK_D,
+            self.RANK_E: self.GAME_RANK_E,
+        }[db_rank]
+
+    def game_to_db_chart(self, game_chart: int) -> int:
+        return {
+            self.GAME_CHART_SINGLE_BEGINNER: self.CHART_SINGLE_BEGINNER,
+            self.GAME_CHART_SINGLE_BASIC: self.CHART_SINGLE_BASIC,
+            self.GAME_CHART_SINGLE_DIFFICULT: self.CHART_SINGLE_DIFFICULT,
+            self.GAME_CHART_SINGLE_EXPERT: self.CHART_SINGLE_EXPERT,
+            self.GAME_CHART_SINGLE_CHALLENGE: self.CHART_SINGLE_CHALLENGE,
+            self.GAME_CHART_DOUBLE_BASIC: self.CHART_DOUBLE_BASIC,
+            self.GAME_CHART_DOUBLE_DIFFICULT: self.CHART_DOUBLE_DIFFICULT,
+            self.GAME_CHART_DOUBLE_EXPERT: self.CHART_DOUBLE_EXPERT,
+            self.GAME_CHART_DOUBLE_CHALLENGE: self.CHART_DOUBLE_CHALLENGE,
+        }[game_chart]
+
+    def db_to_game_chart(self, db_chart: int) -> int:
+        return {
+            self.CHART_SINGLE_BEGINNER: self.GAME_CHART_SINGLE_BEGINNER,
+            self.CHART_SINGLE_BASIC: self.GAME_CHART_SINGLE_BASIC,
+            self.CHART_SINGLE_DIFFICULT: self.GAME_CHART_SINGLE_DIFFICULT,
+            self.CHART_SINGLE_EXPERT: self.GAME_CHART_SINGLE_EXPERT,
+            self.CHART_SINGLE_CHALLENGE: self.GAME_CHART_SINGLE_CHALLENGE,
+            self.CHART_DOUBLE_BASIC: self.GAME_CHART_DOUBLE_BASIC,
+            self.CHART_DOUBLE_DIFFICULT: self.GAME_CHART_DOUBLE_DIFFICULT,
+            self.CHART_DOUBLE_EXPERT: self.GAME_CHART_DOUBLE_EXPERT,
+            self.CHART_DOUBLE_CHALLENGE: self.GAME_CHART_DOUBLE_CHALLENGE,
+        }[db_chart]
+
+    def game_to_db_halo(self, game_halo: int) -> int:
+        if game_halo == self.GAME_HALO_MARVELOUS_COMBO:
+            return self.HALO_MARVELOUS_FULL_COMBO
+        elif game_halo == self.GAME_HALO_PERFECT_COMBO:
+            return self.HALO_PERFECT_FULL_COMBO
+        elif game_halo == self.GAME_HALO_GREAT_COMBO:
+            return self.HALO_GREAT_FULL_COMBO
+        elif game_halo == self.GAME_HALO_GOOD_COMBO:
+            return self.HALO_GOOD_FULL_COMBO
+        else:
+            return self.HALO_NONE
+
+    def db_to_game_halo(self, db_halo: int) -> int:
+        if db_halo == self.HALO_MARVELOUS_FULL_COMBO:
+            return self.GAME_HALO_MARVELOUS_COMBO
+        elif db_halo == self.HALO_PERFECT_FULL_COMBO:
+            return self.GAME_HALO_PERFECT_COMBO
+        elif db_halo == self.HALO_GREAT_FULL_COMBO:
+            return self.GAME_HALO_GREAT_COMBO
+        elif db_halo == self.HALO_GOOD_FULL_COMBO:
+            return self.GAME_HALO_GOOD_COMBO
+        else:
+            return self.GAME_HALO_NONE
+
+    def handle_tax_get_phase_request(self, request: Node) -> Node:
+        tax = Node.void('tax')
+        tax.add_child(Node.s32('phase', 0))
+        return tax
+
+    def __handle_userload(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
+        has_profile: bool = False
+        achievements: List[Achievement] = []
+        scores: List[Score] = []
+
+        if userid is not None:
+            has_profile = self.has_profile(userid)
+            achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+            scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+
+        # Place scores into an arrangement for easier distribution to Ace.
+        scores_by_mcode: Dict[int, List[Optional[Score]]] = {}
+        for score in scores:
+            if score.id not in scores_by_mcode:
+                scores_by_mcode[score.id] = [None] * 9
+
+            scores_by_mcode[score.id][self.db_to_game_chart(score.chart)] = score
+
+        # First, set new flag
+        response.add_child(Node.bool('is_new', not has_profile))
+
+        # Now, return the scores to Ace
+        for mcode in scores_by_mcode:
+            music = Node.void('music')
+            response.add_child(music)
+            music.add_child(Node.u32('mcode', mcode))
+
+            scores_that_matter = scores_by_mcode[mcode]
+            while scores_that_matter[-1] is None:
+                scores_that_matter = scores_that_matter[:-1]
+
+            for score in scores_that_matter:
+                note = Node.void('note')
+                music.add_child(note)
+
+                if score is None:
+                    note.add_child(Node.u16('count', 0))
+                    note.add_child(Node.u8('rank', 0))
+                    note.add_child(Node.u8('clearkind', 0))
+                    note.add_child(Node.s32('score', 0))
+                    note.add_child(Node.s32('ghostid', 0))
+                else:
+                    note.add_child(Node.u16('count', score.plays))
+                    note.add_child(Node.u8('rank', self.db_to_game_rank(score.data.get_int('rank'))))
+                    note.add_child(Node.u8('clearkind', self.db_to_game_halo(score.data.get_int('halo'))))
+                    note.add_child(Node.s32('score', score.points))
+                    note.add_child(Node.s32('ghostid', score.key))
+
+        # Active event settings
+        activeevents = [
+            1,
+            3,
+            5,
+            9,
+            10,
+            11,
+            12,
+            13,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+        ]
+
+        # Event reward settings
+        rewards = {
+            '30': {
+                999: 5,
+            }
+        }
+
+        # Now handle event progress and activation.
+        events = {ach.id: ach.data for ach in achievements if ach.type == '9999'}
+        progress = [ach for ach in achievements if ach.type != '9999']
+
+        # Make sure we always send a babylon's adventure save event or the game won't send progress
+        babylon_included = False
+        for evtprogress in progress:
+            if evtprogress.id == 999 and evtprogress.type == '30':
+                babylon_included = True
+                break
+
+        if not babylon_included:
+            progress.append(Achievement(
+                999,
+                '30',
+                None,
+                {
+                    'completed': False,
+                    'progress': 0,
+                },
+            ))
+
+        for event in activeevents:
+            # Get completion data
+            playerstats = events.get(event, ValidatedDict({'completed': False}))
+
+            # Return the data
+            eventdata = Node.void('eventdata')
+            response.add_child(eventdata)
+            eventdata.add_child(Node.u32('eventid', event))
+            eventdata.add_child(Node.s32('eventtype', 9999))
+            eventdata.add_child(Node.u32('eventno', 0))
+            eventdata.add_child(Node.s64('condition', 0))
+            eventdata.add_child(Node.u32('reward', 0))
+            eventdata.add_child(Node.s32('comptime', 1 if playerstats.get_bool('completed') else 0))
+            eventdata.add_child(Node.s64('savedata', 0))
+
+        for evtprogress in progress:
+            # Babylon's adventure progres and anything else the game sends
+            eventdata = Node.void('eventdata')
+            response.add_child(eventdata)
+            eventdata.add_child(Node.u32('eventid', evtprogress.id))
+            eventdata.add_child(Node.s32('eventtype', int(evtprogress.type)))
+            eventdata.add_child(Node.u32('eventno', 0))
+            eventdata.add_child(Node.s64('condition', 0))
+            eventdata.add_child(Node.u32('reward', rewards.get(evtprogress.type, {}).get(evtprogress.id)))
+            eventdata.add_child(Node.s32('comptime', 1 if evtprogress.data.get_bool('completed') else 0))
+            eventdata.add_child(Node.s64('savedata', evtprogress.data.get_int('progress')))
+
+    def __handle_usersave(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
+        if userid is None:
+            # the game sends us empty user ID strings when a guest is playing.
+            # Return early so it doesn't wait a minute and a half to show the
+            # results screen.
+            return
+
+        if requestdata.child_value('isgameover'):
+            style = int(requestdata.child_value('playstyle'))
+            is_dp = style == self.GAME_STYLE_DOUBLE
+
+            # We don't save anything for gameover requests, since we
+            # already saved scores on individual ones. So, just use this
+            # as a spot to bump play counts and such
+            play_stats = self.get_play_statistics(userid)
+            if is_dp:
+                play_stats.increment_int('double_plays')
+            else:
+                play_stats.increment_int('single_plays')
+            self.update_play_statistics(userid, play_stats)
+
+            # Now is a good time to check if we have workout mode enabled,
+            # and if so, store the calories earned for this set.
+            profile = self.get_profile(userid)
+            enabled = profile.get_bool('workout_mode')
+            weight = profile.get_int('weight')
+
+            if enabled and weight > 0:
+                # We enabled weight display, find the calories and save them
+                total = 0
+                for child in requestdata.children:
+                    if child.name != 'note':
+                        continue
+
+                    total = total + (child.child_value('calorie') or 0)
+
+                self.data.local.user.put_time_based_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    0,
+                    'workout',
+                    {
+                        'calories': total,
+                        'weight': weight,
+                    },
+                )
+
+            # Find any event updates
+            for child in requestdata.children:
+                if child.name != 'event':
+                    continue
+
+                # Skip empty events or events we don't support
+                eventid = child.child_value('eventid')
+                eventtype = child.child_value('eventtype')
+                if eventid == 0 or eventtype == 0:
+                    continue
+
+                # Save data to replay to the client later
+                completed = child.child_value('comptime') != 0
+                progress = child.child_value('savedata')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    str(eventtype),
+                    {
+                        'completed': completed,
+                        'progress': progress,
+                    },
+                )
+
+            return
+
+        # Find the highest stagenum played
+        score = None
+        stagenum = 0
+        for child in requestdata.children:
+            if child.name != 'note':
+                continue
+
+            if child.child_value('stagenum') > stagenum:
+                score = child
+                stagenum = child.child_value('stagenum')
+
+        if score is None:
+            raise Exception('Couldn\'t find newest score to save!')
+
+        songid = score.child_value('mcode')
+        chart = self.game_to_db_chart(score.child_value('notetype'))
+        rank = self.game_to_db_rank(score.child_value('rank'))
+        halo = self.game_to_db_halo(score.child_value('clearkind'))
+        points = score.child_value('score')
+        combo = score.child_value('maxcombo')
+        ghost = score.child_value('ghost')
+        self.update_score(
+            userid,
+            songid,
+            chart,
+            points,
+            rank,
+            halo,
+            combo,
+            ghost=ghost,
+        )
+
+    def __handle_rivalload(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
+        data = Node.void('data')
+        response.add_child(data)
+        data.add_child(Node.s32('recordtype', requestdata.child_value('loadflag')))
+
+        thismachine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        machines_by_id: Dict[int, Optional[Machine]] = {thismachine.id: thismachine}
+
+        loadkind = requestdata.child_value('loadflag')
+        profiles_by_userid: Dict[UserID, ValidatedDict] = {}
+
+        def get_machine(lid: int) -> Optional[Machine]:
+            if lid not in machines_by_id:
+                pcbid = self.data.local.machine.from_machine_id(lid)
+                if pcbid is None:
+                    machines_by_id[lid] = None
+                    return None
+
+                machine = self.data.local.machine.get_machine(pcbid)
+                if machine is None:
+                    machines_by_id[lid] = None
+                    return None
+
+                machines_by_id[lid] = machine
+            return machines_by_id[lid]
+
+        if loadkind == self.GAME_RIVAL_TYPE_WORLD:
+            # Just load all scores for this network
+            scores = self.data.remote.music.get_all_records(self.game, self.music_version)
+        elif loadkind == self.GAME_RIVAL_TYPE_AREA:
+            if thismachine.arcade is not None:
+                match_arcade = thismachine.arcade
+                match_machine = None
+            else:
+                match_arcade = None
+                match_machine = thismachine.id
+
+            # Load up all scores by any user registered on a machine in the same arcade
+            profiles = self.data.local.user.get_all_profiles(self.game, self.version)
+            userids: List[UserID] = []
+            for userid, profiledata in profiles:
+                profiles_by_userid[userid] = profiledata
+
+                # If we have an arcade to match, see if this user's location matches the arcade.
+                # If we don't, just match lid directly
+                if match_arcade is not None:
+                    theirmachine = get_machine(profiledata.get_int('lid'))
+                    if theirmachine is not None and theirmachine.arcade == match_arcade:
+                        userids.append(userid)
+                elif match_machine is not None:
+                    if profiledata.get_int('lid') == match_machine:
+                        userids.append(userid)
+
+            # Load all scores for users in the area
+            scores = self.data.local.music.get_all_records(self.game, self.music_version, userlist=userids)
+        elif loadkind == self.GAME_RIVAL_TYPE_MACHINE:
+            # Load up all scores and filter them by those earned at this location
+            scores = self.data.local.music.get_all_records(self.game, self.music_version, locationlist=[thismachine.id])
+        elif loadkind in [
+            self.GAME_RIVAL_TYPE_RIVAL1,
+            self.GAME_RIVAL_TYPE_RIVAL2,
+            self.GAME_RIVAL_TYPE_RIVAL3,
+        ]:
+            # Load up this user's highscores, format the way the below code expects it
+            extid = requestdata.child_value('ddrcode')
+            otherid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            userscores = self.data.remote.music.get_scores(self.game, self.music_version, otherid)
+            scores = [(otherid, score) for score in userscores]
+        else:
+            # Nothing here
+            scores = []
+
+        missing_users = [userid for (userid, _) in scores if userid not in profiles_by_userid]
+        for (userid, profile) in self.get_any_profiles(missing_users):
+            profiles_by_userid[userid] = profile
+
+        for userid, score in scores:
+            if profiles_by_userid.get(userid) is None:
+                raise Exception('Logic error, couldn\'t find any profile for {}'.format(userid))
+            profiledata = profiles_by_userid[userid]
+
+            record = Node.void('record')
+            data.add_child(record)
+            record.add_child(Node.u32('mcode', score.id))
+            record.add_child(Node.u8('notetype', self.db_to_game_chart(score.chart)))
+            record.add_child(Node.u8('rank', self.db_to_game_rank(score.data.get_int('rank'))))
+            record.add_child(Node.u8('clearkind', self.db_to_game_halo(score.data.get_int('halo'))))
+            record.add_child(Node.u8('flagdata', 0))
+            record.add_child(Node.string('name', profiledata.get_str('name')))
+            record.add_child(Node.s32('area', profiledata.get_int('area', 58)))
+            record.add_child(Node.s32('code', profiledata.get_int('extid')))
+            record.add_child(Node.s32('score', score.points))
+            record.add_child(Node.s32('ghostid', score.key))
+
+    def __handle_usernew(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
+        if userid is None:
+            raise Exception('Expecting valid UserID to create new profile!')
+
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        self.put_profile(userid, ValidatedDict({
+            'lid': machine.id,
+        }))
+        profile = self.get_profile(userid)
+
+        response.add_child(Node.string('seq', ID.format_extid(profile.get_int('extid'))))
+        response.add_child(Node.s32('code', profile.get_int('extid')))
+        response.add_child(Node.string('shoparea', ''))
+
+    def __handle_inheritance(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
+        response.add_child(Node.s32('InheritanceStatus', 0))
+
+    def __handle_ghostload(self, userid: Optional[UserID], requestdata: Node, response: Node) -> None:
+        ghostid = requestdata.child_value('ghostid')
+        ghost = self.data.local.music.get_score_by_key(self.game, self.music_version, ghostid)
+        if ghost is None:
+            return
+
+        userid, score = ghost
+        profile = self.get_profile(userid)
+        if profile is None:
+            return
+
+        if 'ghost' not in score.data:
+            return
+
+        ghostdata = Node.void('ghostdata')
+        response.add_child(ghostdata)
+        ghostdata.add_child(Node.s32('code', profile.get_int('extid')))
+        ghostdata.add_child(Node.u32('mcode', score.id))
+        ghostdata.add_child(Node.u8('notetype', self.db_to_game_chart(score.chart)))
+        ghostdata.add_child(Node.s32('ghostsize', len(score.data['ghost'])))
+        ghostdata.add_child(Node.string('ghost', score.data['ghost']))
+
+    def handle_playerdata_usergamedata_advanced_request(self, request: Node) -> Optional[Node]:
+        playerdata = Node.void('playerdata')
+
+        # DDR Ace decides to be difficult and have a third level of packet switching
+        mode = request.child_value('data/mode')
+        refid = request.child_value('data/refid')
+        extid = request.child_value('data/ddrcode')
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            # Possibly look up by extid instead
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        if mode == 'userload':
+            self.__handle_userload(userid, request.child('data'), playerdata)
+        elif mode == 'usersave':
+            self.__handle_usersave(userid, request.child('data'), playerdata)
+        elif mode == 'rivalload':
+            self.__handle_rivalload(userid, request.child('data'), playerdata)
+        elif mode == 'usernew':
+            self.__handle_usernew(userid, request.child('data'), playerdata)
+        elif mode == 'inheritance':
+            self.__handle_inheritance(userid, request.child('data'), playerdata)
+        elif mode == 'ghostload':
+            self.__handle_ghostload(userid, request.child('data'), playerdata)
+        else:
+            # We don't support this
+            return None
+
+        playerdata.add_child(Node.s32('result', 0))
+        return playerdata
+
+    def handle_playerdata_usergamedata_send_request(self, request: Node) -> Node:
+        playerdata = Node.void('playerdata')
+        refid = request.child_value('data/refid')
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            profile = self.get_profile(userid) or ValidatedDict()
+            usergamedata = profile.get_dict('usergamedata')
+
+            for record in request.child('data/record').children:
+                if record.name != 'd':
+                    continue
+
+                strdata = base64.b64decode(record.value)
+                bindata = base64.b64decode(record.child_value('bin1'))
+
+                # Grab and format the profile objects
+                strdatalist = strdata.split(b',')
+                profiletype = strdatalist[1].decode('utf-8')
+                strdatalist = strdatalist[2:]
+
+                # Extract relevant bits for frontend/API
+                if profiletype == 'COMMON':
+                    profile.replace_str('name', strdatalist[self.GAME_COMMON_NAME_OFFSET].decode('ascii'))
+                    profile.replace_int('area', intish(strdatalist[self.GAME_COMMON_AREA_OFFSET].decode('ascii'), 16))
+                    profile.replace_bool('workout_mode', int(strdatalist[self.GAME_COMMON_WEIGHT_DISPLAY_OFFSET].decode('ascii'), 16) != 0)
+                    profile.replace_int('weight', int(float(strdatalist[self.GAME_COMMON_WEIGHT_OFFSET].decode('ascii')) * 10))
+                    profile.replace_int('character', int(strdatalist[self.GAME_COMMON_CHARACTER_OFFSET].decode('ascii'), 16))
+                if profiletype == 'OPTION':
+                    profile.replace_int('combo', int(strdatalist[self.GAME_OPTION_COMBO_POSITION_OFFSET].decode('ascii'), 16))
+                    profile.replace_int('early_late', int(strdatalist[self.GAME_OPTION_FAST_SLOW_OFFSET].decode('ascii'), 16))
+                    profile.replace_int('arrowskin', int(strdatalist[self.GAME_OPTION_ARROW_SKIN_OFFSET].decode('ascii'), 16))
+                    profile.replace_int('guidelines', int(strdatalist[self.GAME_OPTION_GUIDELINE_OFFSET].decode('ascii'), 16))
+                    profile.replace_int('filter', int(strdatalist[self.GAME_OPTION_FILTER_OFFSET].decode('ascii'), 16))
+
+                usergamedata[profiletype] = {
+                    'strdata': b','.join(strdatalist),
+                    'bindata': bindata,
+                }
+
+            profile.replace_dict('usergamedata', usergamedata)
+            self.put_profile(userid, profile)
+
+        playerdata.add_child(Node.s32('result', 0))
+        return playerdata
+
+    def handle_playerdata_usergamedata_recv_request(self, request: Node) -> Node:
+        playerdata = Node.void('playerdata')
+
+        player = Node.void('player')
+        playerdata.add_child(player)
+
+        refid = request.child_value('data/refid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            links = self.data.local.user.get_links(self.game, self.version, userid)
+            records = 0
+
+            record = Node.void('record')
+            player.add_child(record)
+
+            def acehex(val: int) -> str:
+                return hex(val)[2:]
+
+            if profile is None:
+                # Just return a default empty node
+                record.add_child(Node.string('d', '<NODATA>'))
+                records = 1
+            else:
+                # Figure out what profiles are being requested
+                profiletypes = request.child_value('data/recv_csv').split(',')[::2]
+                usergamedata = profile.get_dict('usergamedata')
+                for ptype in profiletypes:
+                    if ptype in usergamedata:
+                        records = records + 1
+
+                        if ptype == "COMMON":
+                            # Return basic profile options
+                            common = usergamedata[ptype]['strdata'].split(b',')
+                            common[self.GAME_COMMON_NAME_OFFSET] = profile.get_str('name').encode('ascii')
+                            common[self.GAME_COMMON_AREA_OFFSET] = acehex(profile.get_int('area')).encode('ascii')
+                            common[self.GAME_COMMON_WEIGHT_DISPLAY_OFFSET] = b'1' if profile.get_bool('workout_mode') else b'0'
+                            common[self.GAME_COMMON_WEIGHT_OFFSET] = str(float(profile.get_int('weight')) / 10.0).encode('ascii')
+                            common[self.GAME_COMMON_CHARACTER_OFFSET] = acehex(profile.get_int('character')).encode('ascii')
+                            usergamedata[ptype]['strdata'] = b','.join(common)
+                        if ptype == "OPTION":
+                            # Return user settings for frontend
+                            option = usergamedata[ptype]['strdata'].split(b',')
+                            option[self.GAME_OPTION_FAST_SLOW_OFFSET] = acehex(profile.get_int('early_late')).encode('ascii')
+                            option[self.GAME_OPTION_COMBO_POSITION_OFFSET] = acehex(profile.get_int('combo')).encode('ascii')
+                            option[self.GAME_OPTION_ARROW_SKIN_OFFSET] = acehex(profile.get_int('arrowskin')).encode('ascii')
+                            option[self.GAME_OPTION_GUIDELINE_OFFSET] = acehex(profile.get_int('guidelines')).encode('ascii')
+                            option[self.GAME_OPTION_FILTER_OFFSET] = acehex(profile.get_int('filter')).encode('ascii')
+                            usergamedata[ptype]['strdata'] = b','.join(option)
+                        if ptype == "LAST":
+                            # Return the number of calories expended in the last day
+                            workouts = self.data.local.user.get_time_based_achievements(
+                                self.game,
+                                self.version,
+                                userid,
+                                achievementtype='workout',
+                                since=Time.now() - Time.SECONDS_IN_DAY,
+                            )
+                            total = sum([w.data.get_int('calories') for w in workouts])
+
+                            last = usergamedata[ptype]['strdata'].split(b',')
+                            last[self.GAME_LAST_CALORIES_OFFSET] = acehex(total).encode('ascii')
+                            usergamedata[ptype]['strdata'] = b','.join(last)
+                        if ptype == "RIVAL":
+                            # Fill in the DDR code and active status of the three active
+                            # rivals.
+                            rival = usergamedata[ptype]['strdata'].split(b',')
+                            lastdict = profile.get_dict('last')
+
+                            friends: Dict[int, Optional[ValidatedDict]] = {}
+                            for link in links:
+                                if link.type[:7] != 'friend_':
+                                    continue
+
+                                pos = int(link.type[7:])
+                                friends[pos] = self.get_profile(link.other_userid)
+
+                            for rivalno in [1, 2, 3]:
+                                activeslot = {
+                                    1: self.GAME_RIVAL_SLOT_1_ACTIVE_OFFSET,
+                                    2: self.GAME_RIVAL_SLOT_2_ACTIVE_OFFSET,
+                                    3: self.GAME_RIVAL_SLOT_3_ACTIVE_OFFSET,
+                                }[rivalno]
+
+                                whichfriend = lastdict.get_int('rival{}'.format(rivalno)) - 1
+                                if whichfriend < 0:
+                                    # This rival isn't active
+                                    rival[activeslot] = b'0'
+                                    continue
+
+                                friendprofile = friends.get(whichfriend)
+                                if friendprofile is None:
+                                    # This rival doesn't exist
+                                    rival[activeslot] = b'0'
+                                    continue
+
+                                ddrcodeslot = {
+                                    1: self.GAME_RIVAL_SLOT_1_DDRCODE_OFFSET,
+                                    2: self.GAME_RIVAL_SLOT_2_DDRCODE_OFFSET,
+                                    3: self.GAME_RIVAL_SLOT_3_DDRCODE_OFFSET,
+                                }[rivalno]
+
+                                rival[activeslot] = acehex(rivalno).encode('ascii')
+                                rival[ddrcodeslot] = acehex(friendprofile.get_int('extid')).encode('ascii')
+
+                            usergamedata[ptype]['strdata'] = b','.join(rival)
+
+                        dnode = Node.string('d', base64.b64encode(usergamedata[ptype]['strdata']).decode('ascii'))
+                        dnode.add_child(Node.string('bin1', base64.b64encode(usergamedata[ptype]['bindata']).decode('ascii')))
+                        record.add_child(dnode)
+
+            player.add_child(Node.u32('record_num', records))
+
+        playerdata.add_child(Node.s32('result', 0))
+        return playerdata
+
+    def handle_system_convcardnumber_request(self, request: Node) -> Node:
+        cardid = request.child_value('data/card_id')
+        cardnumber = CardCipher.encode(cardid)
+
+        system = Node.void('system')
+        data = Node.void('data')
+        system.add_child(data)
+
+        system.add_child(Node.s32('result', 0))
+        data.add_child(Node.string('card_number', cardnumber))
+        return system
diff --git a/bemani/backend/ddr/ddrx2.py b/bemani/backend/ddr/ddrx2.py
new file mode 100644
index 0000000..64cec6e
--- /dev/null
+++ b/bemani/backend/ddr/ddrx2.py
@@ -0,0 +1,781 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Dict, List, Optional, Tuple
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.backend.ddr.stubs import DDRX
+from bemani.backend.ddr.common import (
+    DDRGameFriendHandler,
+    DDRGameLockHandler,
+    DDRGameLoadCourseHandler,
+    DDRGameLoadHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameSaveCourseHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTraceHandler,
+)
+from bemani.common import Time, VersionConstants, ValidatedDict, intish
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class DDRX2(
+    DDRGameFriendHandler,
+    DDRGameLockHandler,
+    DDRGameLoadCourseHandler,
+    DDRGameLoadHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameOldHandler,
+    DDRGameNewHandler,
+    DDRGameRankingHandler,
+    DDRGameSaveCourseHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTraceHandler,
+    DDRBase,
+):
+
+    name = 'DanceDanceRevolution X2'
+    version = VersionConstants.DDR_X2
+
+    GAME_STYLE_SINGLE = 0
+    GAME_STYLE_DOUBLE = 1
+    GAME_STYLE_VERSUS = 2
+
+    GAME_RANK_AAA = 1
+    GAME_RANK_AA = 2
+    GAME_RANK_A = 3
+    GAME_RANK_B = 4
+    GAME_RANK_C = 5
+    GAME_RANK_D = 6
+    GAME_RANK_E = 7
+
+    GAME_CHART_SINGLE_BEGINNER = 0
+    GAME_CHART_SINGLE_BASIC = 1
+    GAME_CHART_SINGLE_DIFFICULT = 2
+    GAME_CHART_SINGLE_EXPERT = 3
+    GAME_CHART_SINGLE_CHALLENGE = 4
+    GAME_CHART_DOUBLE_BASIC = 5
+    GAME_CHART_DOUBLE_DIFFICULT = 6
+    GAME_CHART_DOUBLE_EXPERT = 7
+    GAME_CHART_DOUBLE_CHALLENGE = 8
+
+    GAME_HALO_NONE = 0
+    GAME_HALO_FULL_COMBO = 1
+    GAME_HALO_PERFECT_COMBO = 2
+    GAME_HALO_MARVELOUS_COMBO = 3
+
+    GAME_MAX_SONGS = 600
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRX(self.data, self.config, self.model)
+
+    def game_to_db_rank(self, game_rank: int) -> int:
+        return {
+            self.GAME_RANK_AAA: self.RANK_AAA,
+            self.GAME_RANK_AA: self.RANK_AA,
+            self.GAME_RANK_A: self.RANK_A,
+            self.GAME_RANK_B: self.RANK_B,
+            self.GAME_RANK_C: self.RANK_C,
+            self.GAME_RANK_D: self.RANK_D,
+            self.GAME_RANK_E: self.RANK_E,
+        }[game_rank]
+
+    def db_to_game_rank(self, db_rank: int) -> int:
+        return {
+            self.RANK_AAA: self.GAME_RANK_AAA,
+            self.RANK_AA_PLUS: self.GAME_RANK_AA,
+            self.RANK_AA: self.GAME_RANK_AA,
+            self.RANK_AA_MINUS: self.GAME_RANK_A,
+            self.RANK_A_PLUS: self.GAME_RANK_A,
+            self.RANK_A: self.GAME_RANK_A,
+            self.RANK_A_MINUS: self.GAME_RANK_B,
+            self.RANK_B_PLUS: self.GAME_RANK_B,
+            self.RANK_B: self.GAME_RANK_B,
+            self.RANK_B_MINUS: self.GAME_RANK_C,
+            self.RANK_C_PLUS: self.GAME_RANK_C,
+            self.RANK_C: self.GAME_RANK_C,
+            self.RANK_C_MINUS: self.GAME_RANK_D,
+            self.RANK_D_PLUS: self.GAME_RANK_D,
+            self.RANK_D: self.GAME_RANK_D,
+            self.RANK_E: self.GAME_RANK_E,
+        }[db_rank]
+
+    def game_to_db_chart(self, game_chart: int) -> int:
+        return {
+            self.GAME_CHART_SINGLE_BEGINNER: self.CHART_SINGLE_BEGINNER,
+            self.GAME_CHART_SINGLE_BASIC: self.CHART_SINGLE_BASIC,
+            self.GAME_CHART_SINGLE_DIFFICULT: self.CHART_SINGLE_DIFFICULT,
+            self.GAME_CHART_SINGLE_EXPERT: self.CHART_SINGLE_EXPERT,
+            self.GAME_CHART_SINGLE_CHALLENGE: self.CHART_SINGLE_CHALLENGE,
+            self.GAME_CHART_DOUBLE_BASIC: self.CHART_DOUBLE_BASIC,
+            self.GAME_CHART_DOUBLE_DIFFICULT: self.CHART_DOUBLE_DIFFICULT,
+            self.GAME_CHART_DOUBLE_EXPERT: self.CHART_DOUBLE_EXPERT,
+            self.GAME_CHART_DOUBLE_CHALLENGE: self.CHART_DOUBLE_CHALLENGE,
+        }[game_chart]
+
+    def db_to_game_chart(self, db_chart: int) -> int:
+        return {
+            self.CHART_SINGLE_BEGINNER: self.GAME_CHART_SINGLE_BEGINNER,
+            self.CHART_SINGLE_BASIC: self.GAME_CHART_SINGLE_BASIC,
+            self.CHART_SINGLE_DIFFICULT: self.GAME_CHART_SINGLE_DIFFICULT,
+            self.CHART_SINGLE_EXPERT: self.GAME_CHART_SINGLE_EXPERT,
+            self.CHART_SINGLE_CHALLENGE: self.GAME_CHART_SINGLE_CHALLENGE,
+            self.CHART_DOUBLE_BASIC: self.GAME_CHART_DOUBLE_BASIC,
+            self.CHART_DOUBLE_DIFFICULT: self.GAME_CHART_DOUBLE_DIFFICULT,
+            self.CHART_DOUBLE_EXPERT: self.GAME_CHART_DOUBLE_EXPERT,
+            self.CHART_DOUBLE_CHALLENGE: self.GAME_CHART_DOUBLE_CHALLENGE,
+        }[db_chart]
+
+    def db_to_game_halo(self, db_halo: int) -> int:
+        if db_halo == self.HALO_MARVELOUS_FULL_COMBO:
+            combo_type = self.GAME_HALO_MARVELOUS_COMBO
+        elif db_halo == self.HALO_PERFECT_FULL_COMBO:
+            combo_type = self.GAME_HALO_PERFECT_COMBO
+        elif db_halo == self.HALO_GREAT_FULL_COMBO:
+            combo_type = self.GAME_HALO_FULL_COMBO
+        else:
+            combo_type = self.GAME_HALO_NONE
+        return combo_type
+
+    def handle_game_common_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        for flagid in range(256):
+            flag = Node.void('flag')
+            game.add_child(flag)
+
+            flag.set_attribute('id', str(flagid))
+            flag.set_attribute('s2', '0')
+            flag.set_attribute('s1', '0')
+            flag.set_attribute('t', '0')
+
+        hit_chart = self.data.local.music.get_hit_chart(self.game, self.music_version, self.GAME_MAX_SONGS)
+        counts_by_reflink = [0] * self.GAME_MAX_SONGS
+        for (reflink, plays) in hit_chart:
+            if reflink >= 0 and reflink < self.GAME_MAX_SONGS:
+                counts_by_reflink[reflink] = plays
+        game.add_child(Node.u32_array('cnt_music', counts_by_reflink))
+
+        return game
+
+    def handle_game_hiscore_request(self, request: Node) -> Node:
+        # This is almost identical to X3 and above, except X3 added a 'code' field
+        # that isn't present here. In the interest of correctness, keep a separate
+        # implementation here.
+        records = self.data.remote.music.get_all_records(self.game, self.music_version)
+
+        sortedrecords: Dict[int, Dict[int, Tuple[UserID, Score]]] = {}
+        missing_profiles = []
+        for (userid, score) in records:
+            if score.id not in sortedrecords:
+                sortedrecords[score.id] = {}
+            sortedrecords[score.id][score.chart] = (userid, score)
+            missing_profiles.append(userid)
+        users = {userid: profile for (userid, profile) in self.get_any_profiles(missing_profiles)}
+
+        game = Node.void('game')
+        for song in sortedrecords:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink_num', str(song))
+
+            for chart in sortedrecords[song]:
+                userid, score = sortedrecords[song][chart]
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                gamerank = self.db_to_game_rank(score.data.get_int('rank'))
+                combo_type = self.db_to_game_halo(score.data.get_int('halo'))
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.string('name', users[userid].get_str('name')))
+                typenode.add_child(Node.u32('score', score.points))
+                typenode.add_child(Node.u16('area', users[userid].get_int('area', 51)))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+
+        return game
+
+    def handle_game_load_m_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        refid = request.attribute('refid')
+
+        if extid is not None:
+            # Rival score loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        else:
+            # Self score loading
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+        else:
+            scores = []
+
+        sortedscores: Dict[int, Dict[int, Score]] = {}
+        for score in scores:
+            if score.id not in sortedscores:
+                sortedscores[score.id] = {}
+            sortedscores[score.id][score.chart] = score
+
+        game = Node.void('game')
+        for song in sortedscores:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink', str(song))
+
+            for chart in sortedscores[song]:
+                score = sortedscores[song][chart]
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                gamerank = self.db_to_game_rank(score.data.get_int('rank'))
+                combo_type = self.db_to_game_halo(score.data.get_int('halo'))
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.u32('score', score.points))
+                typenode.add_child(Node.u16('count', score.plays))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+
+        return game
+
+    def handle_game_save_m_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        songid = int(request.attribute('mid'))
+        chart = self.game_to_db_chart(int(request.attribute('mtype')))
+
+        # Calculate statistics
+        data = request.child('data')
+        points = int(data.attribute('score'))
+        combo = int(data.attribute('combo'))
+        rank = self.game_to_db_rank(int(data.attribute('rank')))
+        if int(data.attribute('full')) == 0:
+            halo = self.HALO_NONE
+        elif int(data.attribute('perf')) == 0:
+            halo = self.HALO_GREAT_FULL_COMBO
+        elif points < 1000000:
+            halo = self.HALO_PERFECT_FULL_COMBO
+        else:
+            halo = self.HALO_MARVELOUS_FULL_COMBO
+        trace = request.child_value('trace')
+
+        # Save the score, regardless of whether we have a refid. If we save
+        # an anonymous score, it only goes into the DB to count against the
+        # number of plays for that song/chart.
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        self.update_score(
+            userid,
+            songid,
+            chart,
+            points,
+            rank,
+            halo,
+            combo,
+            trace,
+        )
+
+        # No response needed
+        game = Node.void('game')
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('game')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Basic game settings
+        root.add_child(Node.string('seq', ''))
+        root.add_child(Node.u32('code', profile.get_int('extid')))
+        root.add_child(Node.string('name', profile.get_str('name')))
+        root.add_child(Node.u8('area', profile.get_int('area', 51)))
+        root.add_child(Node.u32('cnt_s', play_stats.get_int('single_plays')))
+        root.add_child(Node.u32('cnt_d', play_stats.get_int('double_plays')))
+        root.add_child(Node.u32('cnt_b', play_stats.get_int('battle_plays')))  # This could be wrong, its a guess
+        root.add_child(Node.u32('cnt_m0', play_stats.get_int('cnt_m0')))
+        root.add_child(Node.u32('cnt_m1', play_stats.get_int('cnt_m1')))
+        root.add_child(Node.u32('cnt_m2', play_stats.get_int('cnt_m2')))
+        root.add_child(Node.u32('cnt_m3', play_stats.get_int('cnt_m3')))
+        root.add_child(Node.u32('exp', play_stats.get_int('exp')))
+        root.add_child(Node.u32('exp_o', profile.get_int('exp_o')))
+        root.add_child(Node.u32('star', profile.get_int('star')))
+        root.add_child(Node.u32('star_c', profile.get_int('star_c')))
+        root.add_child(Node.u8('combo', profile.get_int('combo', 0)))
+        root.add_child(Node.u8('timing_diff', profile.get_int('early_late', 0)))
+
+        # Character stuff
+        chara = Node.void('chara')
+        root.add_child(chara)
+        if 'chara' in profile:
+            chara.set_attribute('my', str(profile.get_int('chara')))
+
+        root.add_child(Node.u8_array('chara_opt', profile.get_int_array('chara_opt', 96)))
+
+        # Drill rankings
+        if 'title' in profile:
+            title = Node.void('title')
+            root.add_child(title)
+            titledict = profile.get_dict('title')
+            if 't' in titledict:
+                title.set_attribute('t', str(titledict.get_int('t')))
+            if 's' in titledict:
+                title.set_attribute('s', str(titledict.get_int('s')))
+            if 'd' in titledict:
+                title.set_attribute('d', str(titledict.get_int('d')))
+
+        if 'title_gr' in profile:
+            title_gr = Node.void('title_gr')
+            root.add_child(title_gr)
+            title_grdict = profile.get_dict('title_gr')
+            if 't' in title_grdict:
+                title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+            if 's' in title_grdict:
+                title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+            if 'd' in title_grdict:
+                title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+        # Event progrses
+        if 'event' in profile:
+            event = Node.void('event')
+            root.add_child(event)
+            event_dict = profile.get_dict('event')
+            if 'diff_sum' in event_dict:
+                event.set_attribute('diff_sum', str(event_dict.get_int('diff_sum')))
+            if 'welcome' in event_dict:
+                event.set_attribute('welcome', str(event_dict.get_int('welcome')))
+            if 'e_flags' in event_dict:
+                event.set_attribute('e_flags', str(event_dict.get_int('e_flags')))
+
+        if 'e_panel' in profile:
+            e_panel = Node.void('e_panel')
+            root.add_child(e_panel)
+            e_panel_dict = profile.get_dict('e_panel')
+            if 'play_id' in e_panel_dict:
+                e_panel.set_attribute('play_id', str(e_panel_dict.get_int('play_id')))
+            e_panel.add_child(Node.u8_array('cell', e_panel_dict.get_int_array('cell', 24)))
+            e_panel.add_child(Node.u8_array('panel_state', e_panel_dict.get_int_array('panel_state', 6)))
+
+        if 'e_pix' in profile:
+            e_pix = Node.void('e_pix')
+            root.add_child(e_pix)
+            e_pix_dict = profile.get_dict('e_pix')
+            if 'max_distance' in e_pix_dict:
+                e_pix.set_attribute('max_distance', str(e_pix_dict.get_int('max_distance')))
+            if 'max_planet' in e_pix_dict:
+                e_pix.set_attribute('max_planet', str(e_pix_dict.get_int('max_planet')))
+            if 'total_distance' in e_pix_dict:
+                e_pix.set_attribute('total_distance', str(e_pix_dict.get_int('total_distance')))
+            if 'total_planet' in e_pix_dict:
+                e_pix.set_attribute('total_planet', str(e_pix_dict.get_int('total_planet')))
+            if 'border_character' in e_pix_dict:
+                e_pix.set_attribute('border_character', str(e_pix_dict.get_int('border_character')))
+            if 'border_balloon' in e_pix_dict:
+                e_pix.set_attribute('border_balloon', str(e_pix_dict.get_int('border_balloon')))
+            if 'border_music_aftr' in e_pix_dict:
+                e_pix.set_attribute('border_music_aftr', str(e_pix_dict.get_int('border_music_aftr')))
+            if 'border_music_meii' in e_pix_dict:
+                e_pix.set_attribute('border_music_meii', str(e_pix_dict.get_int('border_music_meii')))
+            if 'border_music_dirt' in e_pix_dict:
+                e_pix.set_attribute('border_music_dirt', str(e_pix_dict.get_int('border_music_dirt')))
+            if 'flags' in e_pix_dict:
+                e_pix.set_attribute('flags', str(e_pix_dict.get_int('flags')))
+
+        # Calorie mode
+        if 'weight' in profile:
+            workouts = self.data.local.user.get_time_based_achievements(
+                self.game,
+                self.version,
+                userid,
+                achievementtype='workout',
+                since=Time.now() - Time.SECONDS_IN_DAY,
+            )
+            total = sum([w.data.get_int('calories') for w in workouts])
+            workout = Node.void('workout')
+            root.add_child(workout)
+            workout.set_attribute('weight', str(profile.get_int('weight')))
+            workout.set_attribute('day', str(total))
+            workout.set_attribute('disp', '1')
+
+        # Last cursor settings
+        last = Node.void('last')
+        root.add_child(last)
+        lastdict = profile.get_dict('last')
+        last.set_attribute('fri', str(lastdict.get_int('fri')))
+        last.set_attribute('style', str(lastdict.get_int('style')))
+        last.set_attribute('mode', str(lastdict.get_int('mode')))
+        last.set_attribute('cate', str(lastdict.get_int('cate')))
+        last.set_attribute('sort', str(lastdict.get_int('sort')))
+        last.set_attribute('mid', str(lastdict.get_int('mid')))
+        last.set_attribute('mtype', str(lastdict.get_int('mtype')))
+        last.set_attribute('cid', str(lastdict.get_int('cid')))
+        last.set_attribute('ctype', str(lastdict.get_int('ctype')))
+        last.set_attribute('sid', str(lastdict.get_int('sid')))
+
+        # Groove gauge level-ups
+        gr_s = Node.void('gr_s')
+        root.add_child(gr_s)
+        index = 1
+        for entry in profile.get_int_array('gr_s', 5):
+            gr_s.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        gr_d = Node.void('gr_d')
+        root.add_child(gr_d)
+        index = 1
+        for entry in profile.get_int_array('gr_d', 5):
+            gr_d.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        # Options in menus
+        root.add_child(Node.s16_array('opt', profile.get_int_array('opt', 16)))
+        root.add_child(Node.s16_array('opt_ex', profile.get_int_array('opt_ex', 16)))
+
+        # Unlock flags
+        root.add_child(Node.u8_array('flag', profile.get_int_array('flag', 256, [1] * 256)))
+
+        # Ranking display?
+        root.add_child(Node.u16_array('rank', profile.get_int_array('rank', 100)))
+
+        # Rivals
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            friend = self.get_profile(link.other_userid)
+            play_stats = self.get_play_statistics(link.other_userid)
+            if friend is not None:
+                friendnode = Node.void('friend')
+                root.add_child(friendnode)
+                friendnode.set_attribute('pos', str(pos))
+                friendnode.set_attribute('vs', '0')
+                friendnode.set_attribute('up', '0')
+                friendnode.add_child(Node.u32('code', friend.get_int('extid')))
+                friendnode.add_child(Node.string('name', friend.get_str('name')))
+                friendnode.add_child(Node.u8('area', friend.get_int('area', 51)))
+                friendnode.add_child(Node.u32('exp', play_stats.get_int('exp')))
+                friendnode.add_child(Node.u32('star', friend.get_int('star')))
+
+                # Drill rankings
+                if 'title' in friend:
+                    title = Node.void('title')
+                    friendnode.add_child(title)
+                    titledict = friend.get_dict('title')
+                    if 't' in titledict:
+                        title.set_attribute('t', str(titledict.get_int('t')))
+                    if 's' in titledict:
+                        title.set_attribute('s', str(titledict.get_int('s')))
+                    if 'd' in titledict:
+                        title.set_attribute('d', str(titledict.get_int('d')))
+
+                if 'title_gr' in friend:
+                    title_gr = Node.void('title_gr')
+                    friendnode.add_child(title_gr)
+                    title_grdict = friend.get_dict('title_gr')
+                    if 't' in title_grdict:
+                        title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+                    if 's' in title_grdict:
+                        title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+                    if 'd' in title_grdict:
+                        title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+                # Groove gauge level-ups
+                gr_s = Node.void('gr_s')
+                friendnode.add_child(gr_s)
+                index = 1
+                for entry in friend.get_int_array('gr_s', 5):
+                    gr_s.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+                gr_d = Node.void('gr_d')
+                friendnode.add_child(gr_d)
+                index = 1
+                for entry in friend.get_int_array('gr_d', 5):
+                    gr_d.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Grab last node and accessories so we can make decisions based on type
+        last = request.child('last')
+        lastdict = newprofile.get_dict('last')
+        mode = int(last.attribute('mode'))
+        style = int(last.attribute('style'))
+        is_dp = style == self.GAME_STYLE_DOUBLE
+
+        # Drill rankings
+        title = request.child('title')
+        title_gr = request.child('title_gr')
+        titledict = newprofile.get_dict('title')
+        title_grdict = newprofile.get_dict('title_gr')
+
+        # Groove radar level ups
+        gr = request.child('gr')
+
+        # Set the correct values depending on if we're single or double play
+        if is_dp:
+            play_stats.increment_int('double_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_d',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('d', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('d', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        else:
+            play_stats.increment_int('single_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_s',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('s', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('s', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        play_stats.increment_int('cnt_m{}'.format(mode))
+
+        # Update last attributes
+        lastdict.replace_int('fri', intish(last.attribute('fri')))
+        lastdict.replace_int('style', intish(last.attribute('style')))
+        lastdict.replace_int('mode', intish(last.attribute('mode')))
+        lastdict.replace_int('cate', intish(last.attribute('cate')))
+        lastdict.replace_int('sort', intish(last.attribute('sort')))
+        lastdict.replace_int('mid', intish(last.attribute('mid')))
+        lastdict.replace_int('mtype', intish(last.attribute('mtype')))
+        lastdict.replace_int('cid', intish(last.attribute('cid')))
+        lastdict.replace_int('ctype', intish(last.attribute('ctype')))
+        lastdict.replace_int('sid', intish(last.attribute('sid')))
+        newprofile.replace_dict('last', lastdict)
+
+        # Grab character options
+        chara = request.child('chara')
+        if chara is not None:
+            newprofile.replace_int('chara', intish(chara.attribute('my')))
+        newprofile.replace_int_array('chara_opt', 96, request.child_value('chara_opt'))
+
+        # Track event progress
+        event = request.child('event')
+        if event is not None:
+            event_dict = newprofile.get_dict('event')
+            event_dict.replace_int('diff_sum', intish(event.attribute('diff_sum')))
+            event_dict.replace_int('e_flags', intish(event.attribute('e_flags')))
+            event_dict.replace_int('welcome', intish(event.attribute('welcome')))
+            newprofile.replace_dict('event', event_dict)
+
+        e_panel = request.child('e_panel')
+        if e_panel is not None:
+            e_panel_dict = newprofile.get_dict('e_panel')
+            e_panel_dict.replace_int('play_id', intish(e_panel.attribute('play_id')))
+            e_panel_dict.replace_int_array('cell', 24, e_panel.child_value('cell'))
+            e_panel_dict.replace_int_array('panel_state', 6, e_panel.child_value('panel_state'))
+            newprofile.replace_dict('e_panel', e_panel_dict)
+
+        e_pix = request.child('e_pix')
+        if e_pix is not None:
+            e_pix_dict = newprofile.get_dict('e_pix')
+            max_distance = e_pix_dict.get_int('max_distance')
+            max_planet = e_pix_dict.get_int('max_planet')
+            total_distance = e_pix_dict.get_int('total_distance')
+            total_planet = e_pix_dict.get_int('total_planet')
+            cur_distance = intish(e_pix.attribute('this_distance'))
+            cur_planet = intish(e_pix.attribute('this_planet'))
+            if cur_distance is not None:
+                max_distance = max(max_distance, cur_distance)
+                total_distance += cur_distance
+            if cur_planet is not None:
+                max_planet = max(max_planet, cur_planet)
+                total_planet += cur_planet
+
+            e_pix_dict.replace_int('max_distance', max_distance)
+            e_pix_dict.replace_int('max_planet', max_planet)
+            e_pix_dict.replace_int('total_distance', total_distance)
+            e_pix_dict.replace_int('total_planet', total_planet)
+            e_pix_dict.replace_int('flags', intish(e_pix.attribute('flags')))
+            newprofile.replace_dict('e_pix', e_pix_dict)
+
+        # Options
+        opt = request.child('opt')
+        if opt is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('opt', 16, opt.value[:16])
+
+        # Experience and stars
+        exp = request.child_value('exp')
+        if exp is not None:
+            play_stats.replace_int('exp', play_stats.get_int('exp') + exp)
+        star = request.child_value('star')
+        if star is not None:
+            newprofile.replace_int('star', newprofile.get_int('star') + star)
+        star_c = request.child_value('star_c')
+        if star_c is not None:
+            newprofile.replace_int('star_c', newprofile.get_int('star_c') + exp)
+
+        # Update game flags
+        for child in request.children:
+            if child.name != 'flag':
+                continue
+            try:
+                value = int(child.attribute('data'))
+                offset = int(child.attribute('no'))
+            except ValueError:
+                continue
+
+            flags = newprofile.get_int_array('flag', 256, [1] * 256)
+            if offset < 0 or offset >= len(flags):
+                continue
+            flags[offset] = value
+            newprofile.replace_int_array('flag', 256, flags)
+
+        # Workout mode support
+        newweight = -1
+        oldweight = newprofile.get_int('weight')
+        for child in request.children:
+            if child.name != 'weight':
+                continue
+            newweight = child.value
+        if newweight < 0:
+            newweight = oldweight
+
+        # Either update or unset the weight depending on the game
+        if newweight == 0:
+            # Weight is unset or we declined to use this feature, remove from profile
+            if 'weight' in newprofile:
+                del newprofile['weight']
+        else:
+            # Weight has been set or previously retrieved, we should save calories
+            newprofile.replace_int('weight', newweight)
+            total = 0
+            for child in request.children:
+                if child.name != 'calory':
+                    continue
+                total += child.value
+            self.data.local.user.put_time_based_achievement(
+                self.game,
+                self.version,
+                userid,
+                0,
+                'workout',
+                {
+                    'calories': total,
+                    'weight': newweight,
+                },
+            )
+
+        # Look up old friends
+        oldfriends: List[Optional[UserID]] = [None] * 10
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            oldfriends[pos] = link.other_userid
+
+        # Save any rivals that were added/removed/changed
+        newfriends = oldfriends[:]
+        for child in request.children:
+            if child.name != 'friend':
+                continue
+
+            code = int(child.attribute('code'))
+            pos = int(child.attribute('pos'))
+
+            if pos >= 0 and pos < 10:
+                if code == 0:
+                    # We cleared this friend
+                    newfriends[pos] = None
+                else:
+                    # Try looking up the userid
+                    newfriends[pos] = self.data.remote.user.from_extid(self.game, self.version, code)
+
+        # Diff the set of links to determine updates
+        for i in range(10):
+            if newfriends[i] == oldfriends[i]:
+                continue
+
+            if newfriends[i] is None:
+                # Kill the rival in this location
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+            elif oldfriends[i] is None:
+                # Add rival in this location
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+            else:
+                # Changed the rival here, kill the old one, add the new one
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/ddr/ddrx3.py b/bemani/backend/ddr/ddrx3.py
new file mode 100644
index 0000000..fd3bd05
--- /dev/null
+++ b/bemani/backend/ddr/ddrx3.py
@@ -0,0 +1,814 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Dict, List, Optional, Union
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.backend.ddr.ddrx2 import DDRX2
+from bemani.backend.ddr.common import (
+    DDRGameAreaHiscoreHandler,
+    DDRGameFriendHandler,
+    DDRGameHiscoreHandler,
+    DDRGameLoadCourseHandler,
+    DDRGameLoadDailyHandler,
+    DDRGameLoadHandler,
+    DDRGameLockHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameSaveCourseHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTraceHandler,
+)
+from bemani.common import ValidatedDict, VersionConstants, Time, intish
+from bemani.data import Achievement, Score, UserID
+from bemani.protocol import Node
+
+
+class DDRX3(
+    DDRGameAreaHiscoreHandler,
+    DDRGameFriendHandler,
+    DDRGameHiscoreHandler,
+    DDRGameLockHandler,
+    DDRGameLoadCourseHandler,
+    DDRGameLoadDailyHandler,
+    DDRGameLoadHandler,
+    DDRGameLogHandler,
+    DDRGameMessageHandler,
+    DDRGameNewHandler,
+    DDRGameOldHandler,
+    DDRGameRankingHandler,
+    DDRGameSaveCourseHandler,
+    DDRGameSaveHandler,
+    DDRGameScoreHandler,
+    DDRGameShopHandler,
+    DDRGameTraceHandler,
+    DDRBase,
+):
+
+    name = 'DanceDanceRevolution X3 VS 2ndMIX'
+    version = VersionConstants.DDR_X3_VS_2NDMIX
+
+    GAME_STYLE_SINGLE = 0
+    GAME_STYLE_DOUBLE = 1
+    GAME_STYLE_VERSUS = 2
+
+    GAME_RANK_AAA = 1
+    GAME_RANK_AA = 2
+    GAME_RANK_A = 3
+    GAME_RANK_B = 4
+    GAME_RANK_C = 5
+    GAME_RANK_D = 6
+    GAME_RANK_E = 7
+
+    GAME_CHART_SINGLE_BEGINNER = 0
+    GAME_CHART_SINGLE_BASIC = 1
+    GAME_CHART_SINGLE_DIFFICULT = 2
+    GAME_CHART_SINGLE_EXPERT = 3
+    GAME_CHART_SINGLE_CHALLENGE = 4
+    GAME_CHART_DOUBLE_BASIC = 5
+    GAME_CHART_DOUBLE_DIFFICULT = 6
+    GAME_CHART_DOUBLE_EXPERT = 7
+    GAME_CHART_DOUBLE_CHALLENGE = 8
+
+    GAME_HALO_NONE = 0
+    GAME_HALO_FULL_COMBO = 1
+    GAME_HALO_PERFECT_COMBO = 2
+    GAME_HALO_MARVELOUS_COMBO = 3
+
+    GAME_PLAY_MODE_NORMAL = 1
+    GAME_PLAY_MODE_2NDMIX = 5
+
+    GAME_MAX_SONGS = 700
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRX2(self.data, self.config, self.model)
+
+    def game_to_db_rank(self, game_rank: int) -> int:
+        return {
+            self.GAME_RANK_AAA: self.RANK_AAA,
+            self.GAME_RANK_AA: self.RANK_AA,
+            self.GAME_RANK_A: self.RANK_A,
+            self.GAME_RANK_B: self.RANK_B,
+            self.GAME_RANK_C: self.RANK_C,
+            self.GAME_RANK_D: self.RANK_D,
+            self.GAME_RANK_E: self.RANK_E,
+        }[game_rank]
+
+    def db_to_game_rank(self, db_rank: int) -> int:
+        return {
+            self.RANK_AAA: self.GAME_RANK_AAA,
+            self.RANK_AA_PLUS: self.GAME_RANK_AA,
+            self.RANK_AA: self.GAME_RANK_AA,
+            self.RANK_AA_MINUS: self.GAME_RANK_A,
+            self.RANK_A_PLUS: self.GAME_RANK_A,
+            self.RANK_A: self.GAME_RANK_A,
+            self.RANK_A_MINUS: self.GAME_RANK_B,
+            self.RANK_B_PLUS: self.GAME_RANK_B,
+            self.RANK_B: self.GAME_RANK_B,
+            self.RANK_B_MINUS: self.GAME_RANK_C,
+            self.RANK_C_PLUS: self.GAME_RANK_C,
+            self.RANK_C: self.GAME_RANK_C,
+            self.RANK_C_MINUS: self.GAME_RANK_D,
+            self.RANK_D_PLUS: self.GAME_RANK_D,
+            self.RANK_D: self.GAME_RANK_D,
+            self.RANK_E: self.GAME_RANK_E,
+        }[db_rank]
+
+    def game_to_db_chart(self, game_chart: int) -> int:
+        return {
+            self.GAME_CHART_SINGLE_BEGINNER: self.CHART_SINGLE_BEGINNER,
+            self.GAME_CHART_SINGLE_BASIC: self.CHART_SINGLE_BASIC,
+            self.GAME_CHART_SINGLE_DIFFICULT: self.CHART_SINGLE_DIFFICULT,
+            self.GAME_CHART_SINGLE_EXPERT: self.CHART_SINGLE_EXPERT,
+            self.GAME_CHART_SINGLE_CHALLENGE: self.CHART_SINGLE_CHALLENGE,
+            self.GAME_CHART_DOUBLE_BASIC: self.CHART_DOUBLE_BASIC,
+            self.GAME_CHART_DOUBLE_DIFFICULT: self.CHART_DOUBLE_DIFFICULT,
+            self.GAME_CHART_DOUBLE_EXPERT: self.CHART_DOUBLE_EXPERT,
+            self.GAME_CHART_DOUBLE_CHALLENGE: self.CHART_DOUBLE_CHALLENGE,
+        }[game_chart]
+
+    def db_to_game_chart(self, db_chart: int) -> int:
+        return {
+            self.CHART_SINGLE_BEGINNER: self.GAME_CHART_SINGLE_BEGINNER,
+            self.CHART_SINGLE_BASIC: self.GAME_CHART_SINGLE_BASIC,
+            self.CHART_SINGLE_DIFFICULT: self.GAME_CHART_SINGLE_DIFFICULT,
+            self.CHART_SINGLE_EXPERT: self.GAME_CHART_SINGLE_EXPERT,
+            self.CHART_SINGLE_CHALLENGE: self.GAME_CHART_SINGLE_CHALLENGE,
+            self.CHART_DOUBLE_BASIC: self.GAME_CHART_DOUBLE_BASIC,
+            self.CHART_DOUBLE_DIFFICULT: self.GAME_CHART_DOUBLE_DIFFICULT,
+            self.CHART_DOUBLE_EXPERT: self.GAME_CHART_DOUBLE_EXPERT,
+            self.CHART_DOUBLE_CHALLENGE: self.GAME_CHART_DOUBLE_CHALLENGE,
+        }[db_chart]
+
+    def db_to_game_halo(self, db_halo: int) -> int:
+        if db_halo == self.HALO_MARVELOUS_FULL_COMBO:
+            combo_type = self.GAME_HALO_MARVELOUS_COMBO
+        elif db_halo == self.HALO_PERFECT_FULL_COMBO:
+            combo_type = self.GAME_HALO_PERFECT_COMBO
+        elif db_halo == self.HALO_GREAT_FULL_COMBO:
+            combo_type = self.GAME_HALO_FULL_COMBO
+        else:
+            combo_type = self.GAME_HALO_NONE
+        return combo_type
+
+    def handle_game_common_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        for flagid in range(256):
+            flag = Node.void('flag')
+            game.add_child(flag)
+
+            flag.set_attribute('id', str(flagid))
+            flag.set_attribute('s2', '0')
+            flag.set_attribute('s1', '0')
+            flag.set_attribute('t', '0')
+
+        hit_chart = self.data.local.music.get_hit_chart(self.game, self.music_version, self.GAME_MAX_SONGS)
+        counts_by_reflink = [0] * self.GAME_MAX_SONGS
+        for (reflink, plays) in hit_chart:
+            if reflink >= 0 and reflink < self.GAME_MAX_SONGS:
+                counts_by_reflink[reflink] = plays
+        game.add_child(Node.u32_array('cnt_music', counts_by_reflink))
+
+        return game
+
+    def handle_game_load_m_request(self, request: Node) -> Node:
+        extid = intish(request.attribute('code'))
+        refid = request.attribute('refid')
+
+        if extid is not None:
+            # Rival score loading
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        else:
+            # Self score loading
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+            old_scores = [
+                score for score in self.data.local.user.get_achievements(self.game, self.music_version, userid)
+                if score.type == '2ndmix'
+            ]
+        else:
+            scores = []
+            old_scores = []
+
+        sortedscores: Dict[int, Dict[int, Dict[str, Union[Score, Achievement]]]] = {}
+
+        for score in scores:
+            if score.id not in sortedscores:
+                sortedscores[score.id] = {}
+            if score.chart not in sortedscores[score.id]:
+                sortedscores[score.id][score.chart] = {}
+            sortedscores[score.id][score.chart]['score'] = score
+
+        for oldscore in old_scores:
+            songid = int(oldscore.id / 100)
+            chart = int(oldscore.id % 100)
+            if songid not in sortedscores:
+                sortedscores[songid] = {}
+            if chart not in sortedscores[songid]:
+                sortedscores[songid][chart] = {}
+            sortedscores[songid][chart]['oldscore'] = oldscore
+
+        game = Node.void('game')
+        for song in sortedscores:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('reclink', str(song))
+
+            for chart in sortedscores[song]:
+                try:
+                    gamechart = self.db_to_game_chart(chart)
+                except KeyError:
+                    # Don't support this chart in this game
+                    continue
+                scoredict = sortedscores[song][chart]
+
+                if 'score' in scoredict:
+                    # We played the normal version of this song
+                    gamerank = self.db_to_game_rank(scoredict['score'].data.get_int('rank'))
+                    combo_type = self.db_to_game_halo(scoredict['score'].data.get_int('halo'))
+                    points = scoredict['score'].points  # type: ignore
+                    plays = scoredict['score'].plays  # type: ignore
+                else:
+                    # We only played 2nd mix version of this song
+                    gamerank = 0
+                    combo_type = self.GAME_HALO_NONE
+                    points = 0
+                    plays = 0
+
+                if 'oldscore' in scoredict:
+                    # We played the 2nd mix version of this song
+                    oldpoints = scoredict['oldscore'].data.get_int('points')
+                    oldrank = scoredict['oldscore'].data.get_int('rank')
+                    oldplays = scoredict['oldscore'].data.get_int('plays')
+                else:
+                    oldpoints = 0
+                    oldrank = 0
+                    oldplays = 0
+
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('diff', str(gamechart))
+
+                typenode.add_child(Node.u32('score', points))
+                typenode.add_child(Node.u16('count', plays))
+                typenode.add_child(Node.u8('rank', gamerank))
+                typenode.add_child(Node.u8('combo_type', combo_type))
+                typenode.add_child(Node.u32('score_2nd', oldpoints))
+                typenode.add_child(Node.u8('rank_2nd', oldrank))
+                typenode.add_child(Node.u16('cnt_2nd', oldplays))
+
+        return game
+
+    def handle_game_save_m_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        songid = int(request.attribute('mid'))
+        chart = self.game_to_db_chart(int(request.attribute('mtype')))
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        # Calculate statistics
+        data = request.child('data')
+        playmode = int(data.attribute('playmode'))
+        if playmode == self.GAME_PLAY_MODE_2NDMIX:
+            if userid is not None:
+                # These are special cased and treated like achievements
+                points = int(data.attribute('score_2nd'))
+                combo = int(data.attribute('combo_2nd'))
+                rank = int(data.attribute('rank_2nd'))
+
+                # Grab the old 2nd mix score
+                existingscore = self.data.local.user.get_achievement(
+                    self.game,
+                    self.music_version,
+                    userid,
+                    (songid * 100) + chart,
+                    '2ndmix',
+                )
+
+                if existingscore is not None:
+                    highscore = points > existingscore.get_int('points')
+
+                    plays = existingscore.get_int('plays', 0) + 1
+                    points = max(points, existingscore.get_int('points'))
+                    if not highscore:
+                        combo = existingscore.get_int('combo', combo)
+                        rank = existingscore.get_int('rank', rank)
+                else:
+                    plays = 1
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.music_version,
+                    userid,
+                    (songid * 100) + chart,
+                    '2ndmix',
+                    {
+                        'points': points,
+                        'combo': combo,
+                        'rank': rank,
+                        'plays': plays,
+                    },
+                )
+        else:
+            points = int(data.attribute('score'))
+            combo = int(data.attribute('combo'))
+            rank = self.game_to_db_rank(int(data.attribute('rank')))
+            if int(data.attribute('full')) == 0:
+                halo = self.HALO_NONE
+            elif int(data.attribute('perf')) == 0:
+                halo = self.HALO_GREAT_FULL_COMBO
+            elif points < 1000000:
+                halo = self.HALO_PERFECT_FULL_COMBO
+            else:
+                halo = self.HALO_MARVELOUS_FULL_COMBO
+            trace = request.child_value('trace')
+
+            # Save the score, regardless of whether we have a refid. If we save
+            # an anonymous score, it only goes into the DB to count against the
+            # number of plays for that song/chart.
+            self.update_score(
+                userid,
+                songid,
+                chart,
+                points,
+                rank,
+                halo,
+                combo,
+                trace,
+            )
+
+        # No response needed
+        game = Node.void('game')
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('game')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Basic game settings
+        root.add_child(Node.string('seq', ''))
+        root.add_child(Node.u32('code', profile.get_int('extid')))
+        root.add_child(Node.string('name', profile.get_str('name')))
+        root.add_child(Node.u8('area', profile.get_int('area', 51)))
+        root.add_child(Node.u32('cnt_s', play_stats.get_int('single_plays')))
+        root.add_child(Node.u32('cnt_d', play_stats.get_int('double_plays')))
+        root.add_child(Node.u32('cnt_b', play_stats.get_int('battle_plays')))  # This could be wrong, its a guess
+        root.add_child(Node.u32('cnt_m0', play_stats.get_int('cnt_m0')))
+        root.add_child(Node.u32('cnt_m1', play_stats.get_int('cnt_m1')))
+        root.add_child(Node.u32('cnt_m2', play_stats.get_int('cnt_m2')))
+        root.add_child(Node.u32('cnt_m3', play_stats.get_int('cnt_m3')))
+        root.add_child(Node.u32('cnt_m4', play_stats.get_int('cnt_m4')))
+        root.add_child(Node.u32('cnt_m5', play_stats.get_int('cnt_m5')))
+        root.add_child(Node.u32('exp', play_stats.get_int('exp')))
+        root.add_child(Node.u32('exp_o', profile.get_int('exp_o')))
+        root.add_child(Node.u32('star', profile.get_int('star')))
+        root.add_child(Node.u32('star_c', profile.get_int('star_c')))
+        root.add_child(Node.u8('combo', profile.get_int('combo', 0)))
+        root.add_child(Node.u8('timing_diff', profile.get_int('early_late', 0)))
+
+        # Character stuff
+        chara = Node.void('chara')
+        root.add_child(chara)
+        chara.set_attribute('my', str(profile.get_int('chara', 30)))
+        root.add_child(Node.u16_array('chara_opt', profile.get_int_array('chara_opt', 96, [208] * 96)))
+
+        # Drill rankings
+        if 'title_gr' in profile:
+            title_gr = Node.void('title_gr')
+            root.add_child(title_gr)
+            title_grdict = profile.get_dict('title_gr')
+            if 't' in title_grdict:
+                title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+            if 's' in title_grdict:
+                title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+            if 'd' in title_grdict:
+                title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+        # Calorie mode
+        if 'weight' in profile:
+            workouts = self.data.local.user.get_time_based_achievements(
+                self.game,
+                self.version,
+                userid,
+                achievementtype='workout',
+                since=Time.now() - Time.SECONDS_IN_DAY,
+            )
+            total = sum([w.data.get_int('calories') for w in workouts])
+            workout = Node.void('workout')
+            root.add_child(workout)
+            workout.set_attribute('weight', str(profile.get_int('weight')))
+            workout.set_attribute('day', str(total))
+            workout.set_attribute('disp', '1')
+
+        # Daily play counts
+        last_play_date = play_stats.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = play_stats.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        daycount = Node.void('daycount')
+        root.add_child(daycount)
+        daycount.set_attribute('playcount', str(today_count))
+
+        # Daily combo stuff, unknown how this works
+        dailycombo = Node.void('dailycombo')
+        root.add_child(dailycombo)
+        dailycombo.set_attribute('daily_combo', str(0))
+        dailycombo.set_attribute('daily_combo_lv', str(0))
+
+        # Last cursor settings
+        last = Node.void('last')
+        root.add_child(last)
+        lastdict = profile.get_dict('last')
+        last.set_attribute('rival1', str(lastdict.get_int('rival1', -1)))
+        last.set_attribute('rival2', str(lastdict.get_int('rival2', -1)))
+        last.set_attribute('rival3', str(lastdict.get_int('rival3', -1)))
+        last.set_attribute('fri', str(lastdict.get_int('rival1', -1)))  # This literally goes to the same memory in X3
+        last.set_attribute('style', str(lastdict.get_int('style')))
+        last.set_attribute('mode', str(lastdict.get_int('mode')))
+        last.set_attribute('cate', str(lastdict.get_int('cate')))
+        last.set_attribute('sort', str(lastdict.get_int('sort')))
+        last.set_attribute('mid', str(lastdict.get_int('mid')))
+        last.set_attribute('mtype', str(lastdict.get_int('mtype')))
+        last.set_attribute('cid', str(lastdict.get_int('cid')))
+        last.set_attribute('ctype', str(lastdict.get_int('ctype')))
+        last.set_attribute('sid', str(lastdict.get_int('sid')))
+
+        # Result stars
+        result_star = Node.void('result_star')
+        root.add_child(result_star)
+        result_stars = profile.get_int_array('result_stars', 9)
+        for i in range(9):
+            result_star.set_attribute('slot{}'.format(i + 1), str(result_stars[i]))
+
+        # Target stuff
+        target = Node.void('target')
+        root.add_child(target)
+        target.set_attribute('flag', str(profile.get_int('target_flag')))
+        target.set_attribute('setnum', str(profile.get_int('target_setnum')))
+
+        # Groove gauge level-ups
+        gr_s = Node.void('gr_s')
+        root.add_child(gr_s)
+        index = 1
+        for entry in profile.get_int_array('gr_s', 5):
+            gr_s.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        gr_d = Node.void('gr_d')
+        root.add_child(gr_d)
+        index = 1
+        for entry in profile.get_int_array('gr_d', 5):
+            gr_d.set_attribute('gr{}'.format(index), str(entry))
+            index = index + 1
+
+        # Options in menus
+        root.add_child(Node.s16_array('opt', profile.get_int_array('opt', 16)))
+        root.add_child(Node.s16_array('opt_ex', profile.get_int_array('opt_ex', 16)))
+
+        # Unlock flags
+        root.add_child(Node.u8_array('flag', profile.get_int_array('flag', 256, [1] * 256)))
+
+        # Ranking display?
+        root.add_child(Node.u16_array('rank', profile.get_int_array('rank', 100)))
+
+        # Rivals
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            friend = self.get_profile(link.other_userid)
+            play_stats = self.get_play_statistics(link.other_userid)
+            if friend is not None:
+                friendnode = Node.void('friend')
+                root.add_child(friendnode)
+                friendnode.set_attribute('pos', str(pos))
+                friendnode.set_attribute('vs', '0')
+                friendnode.set_attribute('up', '0')
+                friendnode.add_child(Node.u32('code', friend.get_int('extid')))
+                friendnode.add_child(Node.string('name', friend.get_str('name')))
+                friendnode.add_child(Node.u8('area', friend.get_int('area', 51)))
+                friendnode.add_child(Node.u32('exp', play_stats.get_int('exp')))
+                friendnode.add_child(Node.u32('star', friend.get_int('star')))
+
+                # Drill rankings
+                if 'title' in friend:
+                    title = Node.void('title')
+                    friendnode.add_child(title)
+                    titledict = friend.get_dict('title')
+                    if 't' in titledict:
+                        title.set_attribute('t', str(titledict.get_int('t')))
+                    if 's' in titledict:
+                        title.set_attribute('s', str(titledict.get_int('s')))
+                    if 'd' in titledict:
+                        title.set_attribute('d', str(titledict.get_int('d')))
+
+                if 'title_gr' in friend:
+                    title_gr = Node.void('title_gr')
+                    friendnode.add_child(title_gr)
+                    title_grdict = friend.get_dict('title_gr')
+                    if 't' in title_grdict:
+                        title_gr.set_attribute('t', str(title_grdict.get_int('t')))
+                    if 's' in title_grdict:
+                        title_gr.set_attribute('s', str(title_grdict.get_int('s')))
+                    if 'd' in title_grdict:
+                        title_gr.set_attribute('d', str(title_grdict.get_int('d')))
+
+                # Groove gauge level-ups
+                gr_s = Node.void('gr_s')
+                friendnode.add_child(gr_s)
+                index = 1
+                for entry in friend.get_int_array('gr_s', 5):
+                    gr_s.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+                gr_d = Node.void('gr_d')
+                friendnode.add_child(gr_d)
+                index = 1
+                for entry in friend.get_int_array('gr_d', 5):
+                    gr_d.set_attribute('gr{}'.format(index), str(entry))
+                    index = index + 1
+
+        # Play area
+        areas = profile.get_int_array('play_area', 55)
+        play_area = Node.void('play_area')
+        root.add_child(play_area)
+        for i in range(len(areas)):
+            play_area.set_attribute('play_cnt{}'.format(i), str(areas[i]))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Grab last node and accessories so we can make decisions based on type
+        last = request.child('last')
+        lastdict = newprofile.get_dict('last')
+        mode = int(last.attribute('mode'))
+        style = int(last.attribute('style'))
+        is_dp = style == self.GAME_STYLE_DOUBLE
+
+        # Drill rankings
+        title = request.child('title')
+        title_gr = request.child('title_gr')
+        titledict = newprofile.get_dict('title')
+        title_grdict = newprofile.get_dict('title_gr')
+
+        # Groove radar level ups
+        gr = request.child('gr')
+
+        # Set the correct values depending on if we're single or double play
+        if is_dp:
+            play_stats.increment_int('double_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_d',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('d', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('d', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        else:
+            play_stats.increment_int('single_plays')
+            if gr is not None:
+                newprofile.replace_int_array(
+                    'gr_s',
+                    5,
+                    [
+                        intish(gr.attribute('gr1')),
+                        intish(gr.attribute('gr2')),
+                        intish(gr.attribute('gr3')),
+                        intish(gr.attribute('gr4')),
+                        intish(gr.attribute('gr5')),
+                    ],
+                )
+            if title is not None:
+                titledict.replace_int('s', title.value)
+                newprofile.replace_dict('title', titledict)
+            if title_gr is not None:
+                title_grdict.replace_int('s', title.value)
+                newprofile.replace_dict('title_gr', title_grdict)
+        play_stats.increment_int('cnt_m{}'.format(mode))
+
+        # Result stars
+        result_star = request.child('result_star')
+        if result_star is not None:
+            newprofile.replace_int_array(
+                'result_stars',
+                9,
+                [
+                    intish(result_star.attribute('slot1')),
+                    intish(result_star.attribute('slot2')),
+                    intish(result_star.attribute('slot3')),
+                    intish(result_star.attribute('slot4')),
+                    intish(result_star.attribute('slot5')),
+                    intish(result_star.attribute('slot6')),
+                    intish(result_star.attribute('slot7')),
+                    intish(result_star.attribute('slot8')),
+                    intish(result_star.attribute('slot9')),
+                ],
+            )
+
+        # Target stuff
+        target = request.child('target')
+        if target is not None:
+            newprofile.replace_int('target_flag', intish(target.attribute('flag')))
+            newprofile.replace_int('target_setnum', intish(target.attribute('setnum')))
+
+        # Update last attributes
+        lastdict.replace_int('rival1', intish(last.attribute('rival1')))
+        lastdict.replace_int('rival2', intish(last.attribute('rival2')))
+        lastdict.replace_int('rival3', intish(last.attribute('rival3')))
+        lastdict.replace_int('style', intish(last.attribute('style')))
+        lastdict.replace_int('mode', intish(last.attribute('mode')))
+        lastdict.replace_int('cate', intish(last.attribute('cate')))
+        lastdict.replace_int('sort', intish(last.attribute('sort')))
+        lastdict.replace_int('mid', intish(last.attribute('mid')))
+        lastdict.replace_int('mtype', intish(last.attribute('mtype')))
+        lastdict.replace_int('cid', intish(last.attribute('cid')))
+        lastdict.replace_int('ctype', intish(last.attribute('ctype')))
+        lastdict.replace_int('sid', intish(last.attribute('sid')))
+        newprofile.replace_dict('last', lastdict)
+
+        # Grab character options
+        chara = request.child('chara')
+        if chara is not None:
+            newprofile.replace_int('chara', intish(chara.attribute('my')))
+        chara_opt = request.child('chara_opt')
+        if chara_opt is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('chara_opt', 96, chara_opt.value[:96])
+
+        # Options
+        opt = request.child('opt')
+        if opt is not None:
+            # A bug in old versions of AVS returns the wrong number for set
+            newprofile.replace_int_array('opt', 16, opt.value[:16])
+
+        # Experience and stars
+        exp = request.child_value('exp')
+        if exp is not None:
+            play_stats.replace_int('exp', play_stats.get_int('exp') + exp)
+        star = request.child_value('star')
+        if star is not None:
+            newprofile.replace_int('star', newprofile.get_int('star') + star)
+        star_c = request.child_value('star_c')
+        if star_c is not None:
+            newprofile.replace_int('star_c', newprofile.get_int('star_c') + exp)
+
+        # Update game flags
+        for child in request.children:
+            if child.name != 'flag':
+                continue
+            try:
+                value = int(child.attribute('data'))
+                offset = int(child.attribute('no'))
+            except ValueError:
+                continue
+
+            flags = newprofile.get_int_array('flag', 256, [1] * 256)
+            if offset < 0 or offset >= len(flags):
+                continue
+            flags[offset] = value
+            newprofile.replace_int_array('flag', 256, flags)
+
+        # Workout mode support
+        newweight = -1
+        oldweight = newprofile.get_int('weight')
+        for child in request.children:
+            if child.name != 'weight':
+                continue
+            newweight = child.value
+        if newweight < 0:
+            newweight = oldweight
+
+        # Either update or unset the weight depending on the game
+        if newweight == 0:
+            # Weight is unset or we declined to use this feature, remove from profile
+            if 'weight' in newprofile:
+                del newprofile['weight']
+        else:
+            # Weight has been set or previously retrieved, we should save calories
+            newprofile.replace_int('weight', newweight)
+            total = 0
+            for child in request.children:
+                if child.name != 'calory':
+                    continue
+                total += child.value
+            self.data.local.user.put_time_based_achievement(
+                self.game,
+                self.version,
+                userid,
+                0,
+                'workout',
+                {
+                    'calories': total,
+                    'weight': newweight,
+                },
+            )
+
+        # Look up old friends
+        oldfriends: List[Optional[UserID]] = [None] * 10
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            if link.type[:7] != 'friend_':
+                continue
+
+            pos = int(link.type[7:])
+            oldfriends[pos] = link.other_userid
+
+        # Save any rivals that were added/removed/changed
+        newfriends = oldfriends[:]
+        for child in request.children:
+            if child.name != 'friend':
+                continue
+
+            code = int(child.attribute('code'))
+            pos = int(child.attribute('pos'))
+
+            if pos >= 0 and pos < 10:
+                if code == 0:
+                    # We cleared this friend
+                    newfriends[pos] = None
+                else:
+                    # Try looking up the userid
+                    newfriends[pos] = self.data.remote.user.from_extid(self.game, self.version, code)
+
+        # Diff the set of links to determine updates
+        for i in range(10):
+            if newfriends[i] == oldfriends[i]:
+                continue
+
+            if newfriends[i] is None:
+                # Kill the rival in this location
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+            elif oldfriends[i] is None:
+                # Add rival in this location
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+            else:
+                # Changed the rival here, kill the old one, add the new one
+                self.data.local.user.destroy_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    oldfriends[i],
+                )
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'friend_{}'.format(i),
+                    newfriends[i],
+                    {},
+                )
+
+        # Play area counter
+        shop_area = int(request.attribute('shop_area'))
+        if shop_area >= 0 and shop_area < 55:
+            areas = newprofile.get_int_array('play_area', 55)
+            areas[shop_area] = areas[shop_area] + 1
+            newprofile.replace_int_array('play_area', 55, areas)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/ddr/factory.py b/bemani/backend/ddr/factory.py
new file mode 100644
index 0000000..8ef0b02
--- /dev/null
+++ b/bemani/backend/ddr/factory.py
@@ -0,0 +1,108 @@
+from typing import Dict, Optional, Any
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.ddr.stubs import (
+    DDRX,
+    DDRSuperNova2,
+    DDRSuperNova,
+    DDRExtreme,
+    DDR7thMix,
+    DDR6thMix,
+    DDR5thMix,
+    DDR4thMix,
+    DDR3rdMix,
+    DDR2ndMix,
+    DDR1stMix,
+)
+from bemani.backend.ddr.ddrx2 import DDRX2
+from bemani.backend.ddr.ddrx3 import DDRX3
+from bemani.backend.ddr.ddr2013 import DDR2013
+from bemani.backend.ddr.ddr2014 import DDR2014
+from bemani.backend.ddr.ddrace import DDRAce
+from bemani.backend.ddr.ddra20 import DDRA20
+from bemani.common import Model, VersionConstants
+from bemani.data import Data
+
+
+class DDRFactory(Factory):
+
+    MANAGED_CLASSES = [
+        DDR1stMix,
+        DDR2ndMix,
+        DDR4thMix,
+        DDR3rdMix,
+        DDR5thMix,
+        DDR6thMix,
+        DDR7thMix,
+        DDRExtreme,
+        DDRSuperNova,
+        DDRSuperNova2,
+        DDRX,
+        DDRX2,
+        DDRX3,
+        DDR2013,
+        DDR2014,
+        DDRAce,
+        DDRA20,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['HDX', 'JDX', 'KDX', 'MDX']:
+            Base.register(game, DDRFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        def version_from_date(date: int) -> Optional[int]:
+            if date < 2014051200:
+                return VersionConstants.DDR_2013
+            elif date >= 2014051200 and date < 2016033000:
+                return VersionConstants.DDR_2014
+            elif date >= 2016033000 and date < 2019042300:
+                return VersionConstants.DDR_ACE
+            elif date >= 2019042300:
+                return VersionConstants.DDR_A20
+            return None
+
+        if model.game == 'HDX':
+            return DDRX(data, config, model)
+        if model.game == 'JDX':
+            return DDRX2(data, config, model)
+        if model.game == 'KDX':
+            return DDRX3(data, config, model)
+        if model.game == 'MDX':
+            if model.version is None:
+                if parentmodel is None:
+                    return None
+
+                # We have no way to tell apart newer versions. However, we can make
+                # an educated guess if we happen to be summoned for old profile lookup.
+                if parentmodel.game not in ['HDX', 'JDX', 'KDX', 'MDX']:
+                    return None
+
+                parentversion = version_from_date(parentmodel.version)
+                if parentversion == VersionConstants.DDR_A20:
+                    return DDRAce(data, config, model)
+                if parentversion == VersionConstants.DDR_ACE:
+                    return DDR2014(data, config, model)
+                if parentversion == VersionConstants.DDR_2014:
+                    return DDR2013(data, config, model)
+                if parentversion == VersionConstants.DDR_2013:
+                    return DDRX3(data, config, model)
+
+                # Unknown older version
+                return None
+
+            version = version_from_date(model.version)
+            if version == VersionConstants.DDR_2013:
+                return DDR2013(data, config, model)
+            if version == VersionConstants.DDR_2014:
+                return DDR2014(data, config, model)
+            if version == VersionConstants.DDR_ACE:
+                return DDRAce(data, config, model)
+            if version == VersionConstants.DDR_A20:
+                return DDRA20(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/ddr/stubs.py b/bemani/backend/ddr/stubs.py
new file mode 100644
index 0000000..c90c2f9
--- /dev/null
+++ b/bemani/backend/ddr/stubs.py
@@ -0,0 +1,101 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.ddr.base import DDRBase
+from bemani.common import VersionConstants
+
+
+class DDRX(DDRBase):
+
+    name = 'DanceDanceRevolution X'
+    version = VersionConstants.DDR_X
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRSuperNova2(self.data, self.config, self.model)
+
+
+class DDRSuperNova2(DDRBase):
+
+    name = 'DanceDanceRevolution SuperNova 2'
+    version = VersionConstants.DDR_SUPERNOVA_2
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRSuperNova(self.data, self.config, self.model)
+
+
+class DDRSuperNova(DDRBase):
+
+    name = 'DanceDanceRevolution SuperNova'
+    version = VersionConstants.DDR_SUPERNOVA
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDRExtreme(self.data, self.config, self.model)
+
+
+class DDRExtreme(DDRBase):
+
+    name = 'DanceDanceRevolution Extreme'
+    version = VersionConstants.DDR_EXTREME
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR7thMix(self.data, self.config, self.model)
+
+
+class DDR7thMix(DDRBase):
+
+    name = 'DanceDanceRevolution 7thMix'
+    version = VersionConstants.DDR_7THMIX
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR6thMix(self.data, self.config, self.model)
+
+
+class DDR6thMix(DDRBase):
+
+    name = 'DanceDanceRevolution 6thMix'
+    version = VersionConstants.DDR_6THMIX
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR5thMix(self.data, self.config, self.model)
+
+
+class DDR5thMix(DDRBase):
+
+    name = 'DanceDanceRevolution 5thMix'
+    version = VersionConstants.DDR_5THMIX
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR4thMix(self.data, self.config, self.model)
+
+
+class DDR4thMix(DDRBase):
+
+    name = 'DanceDanceRevolution 4thMix'
+    version = VersionConstants.DDR_4THMIX
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR3rdMix(self.data, self.config, self.model)
+
+
+class DDR3rdMix(DDRBase):
+
+    name = 'DanceDanceRevolution 3rdMix'
+    version = VersionConstants.DDR_3RDMIX
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR2ndMix(self.data, self.config, self.model)
+
+
+class DDR2ndMix(DDRBase):
+
+    name = 'DanceDanceRevolution 2ndMix'
+    version = VersionConstants.DDR_2NDMIX
+
+    def previous_version(self) -> Optional[DDRBase]:
+        return DDR1stMix(self.data, self.config, self.model)
+
+
+class DDR1stMix(DDRBase):
+
+    name = 'DanceDanceRevolution 1stMix'
+    version = VersionConstants.DDR_1STMIX
diff --git a/bemani/backend/dispatch.py b/bemani/backend/dispatch.py
new file mode 100644
index 0000000..41a3e8b
--- /dev/null
+++ b/bemani/backend/dispatch.py
@@ -0,0 +1,174 @@
+import copy
+from typing import Optional, Dict, Any
+
+from bemani.backend.base import Model, Base, Status
+from bemani.protocol import Node
+from bemani.data import Data
+
+
+class UnrecognizedPCBIDException(Exception):
+    def __init__(self, pcbid: str, model: str, ip: str) -> None:
+        self.pcbid = pcbid
+        self.model = model
+        self.ip = ip
+
+
+class Dispatch:
+    """
+    Dispatch object responsible for taking a decoded tree of Node objects
+    from a game, looking up config, dispatching it to the correct game
+    class and then returning a response.
+    """
+
+    def __init__(self, config: Dict[str, Any], data: Data, verbose: bool) -> None:
+        """
+        Initialize the Dispatch object.
+
+        Parameters:
+            config - A dictionary of configuration used for various settigs.
+            data - A Data singleton for DB access.
+            verbose - Whether we get chatty to stdout or not.
+        """
+        self.__verbose = verbose
+        self.__data = data
+        self.__config = config
+
+    def log(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        """
+        Given a message, format it and print it.
+
+        Note that this only prints to stdout if we were initialized with
+        verbose = True.
+
+        Parameters:
+            msg - A formatstring that should be formatted with any
+                  optional arguments or keyword arguments.
+        """
+        if self.__verbose:
+            print(msg.format(*args, **kwargs))
+
+    def handle(self, tree: Node) -> Optional[Node]:
+        """
+        Given a packet from a game, handle it and return a response.
+
+        Parameters:
+            tree - A Node representing the root of a tree. Expected to
+                   come from an external game.
+
+        Returns:
+            A Node representing the root of a response tree, or None if
+            we had a problem parsing or generating a response.
+        """
+        self.log("Received request:\n{}", tree)
+
+        if tree.name != 'call':
+            # Invalid request
+            self.log("Invalid root node {}", tree.name)
+            return None
+
+        if len(tree.children) != 1:
+            # Invalid request
+            self.log("Invalid number of children for root node")
+            return None
+
+        modelstring = tree.attribute('model')
+        model = Model.from_modelstring(modelstring)
+        pcbid = tree.attribute('srcid')
+
+        # If we are enforcing, bail out if we don't recognize thie ID
+        pcb = self.__data.local.machine.get_machine(pcbid)
+        if self.__config['server']['enforce_pcbid'] and pcb is None:
+            self.log("Unrecognized PCBID {}", pcbid)
+            raise UnrecognizedPCBIDException(pcbid, modelstring, self.__config['client']['address'])
+
+        # If we don't have a Machine, but we aren't enforcing, we must create it
+        if pcb is None:
+            pcb = self.__data.local.machine.create_machine(pcbid)
+
+        request = tree.children[0]
+
+        config = copy.copy(self.__config)
+        config['machine'] = {
+            'pcbid': pcbid,
+            'arcade': pcb.arcade,
+        }
+
+        # If the machine we looked up is in an arcade, override the global
+        # paseli settings with the arcade paseli settings.
+        if pcb.arcade is not None:
+            arcade = self.__data.local.machine.get_arcade(pcb.arcade)
+            if arcade is not None:
+                config['paseli']['enabled'] = arcade.data.get_bool('paseli_enabled')
+                config['paseli']['infinite'] = arcade.data.get_bool('paseli_infinite')
+                if arcade.data.get_bool('mask_services_url'):
+                    # Mask the address, no matter what the server settings are
+                    config['server']['uri'] = None
+        # If we don't have a server URI, we should add the default
+        if 'uri' not in config['server']:
+            config['server']['uri'] = None
+
+        game = Base.create(self.__data, config, model)
+        method = request.attribute('method')
+        response = None
+
+        # If we are enforcing, make sure the PCBID isn't specified to be
+        # game-specific
+        if self.__config['server']['enforce_pcbid'] and pcb.game is not None:
+            if pcb.game != game.game:
+                self.log("PCBID {} assigned to game {}, but connected from game {}", pcbid, pcb.game, game.game)
+                raise UnrecognizedPCBIDException(pcbid, modelstring, self.__config['client']['address'])
+            if pcb.version is not None:
+                if pcb.version > 0 and pcb.version != game.version:
+                    self.log(
+                        "PCBID {} assigned to game {} version {}, but connected from game {} version {}",
+                        pcbid,
+                        pcb.game,
+                        pcb.version,
+                        game.game,
+                        game.version,
+                    )
+                    raise UnrecognizedPCBIDException(pcbid, modelstring, self.__config['client']['address'])
+                if pcb.version < 0 and (-pcb.version) < game.version:
+                    self.log(
+                        "PCBID {} assigned to game {} maximum version {}, but connected from game {} version {}",
+                        pcbid,
+                        pcb.game,
+                        -pcb.version,
+                        game.game,
+                        game.version,
+                    )
+                    raise UnrecognizedPCBIDException(pcbid, modelstring, self.__config['client']['address'])
+
+        # First, try to handle with specific service/method function
+        try:
+            handler = getattr(game, 'handle_{}_{}_request'.format(request.name, method))
+        except AttributeError:
+            handler = None
+        if handler is not None:
+            response = handler(request)
+
+        if response is None:
+            # Now, try to pass it off to a generic service handler
+            try:
+                handler = getattr(game, 'handle_{}_request'.format(request.name))
+            except AttributeError:
+                handler = None
+            if handler is not None:
+                response = handler(request)
+
+        if response is None:
+            # Unrecognized handler
+            self.log("Unrecognized service {} method {}".format(request.name, method))
+            return None
+
+        # Make sure we have a status value if one wasn't provided
+        if 'status' not in response.attributes:
+            response.set_attribute('status', str(Status.SUCCESS))
+
+        root = Node.void('response')
+        root.add_child(response)
+        root.set_attribute('dstid', pcbid)
+
+        self.log("Sending response:\n{}", root)
+
+        return root
diff --git a/bemani/backend/ess/__init__.py b/bemani/backend/ess/__init__.py
new file mode 100644
index 0000000..1482488
--- /dev/null
+++ b/bemani/backend/ess/__init__.py
@@ -0,0 +1 @@
+from bemani.backend.ess.eventlog import EventLogHandler
diff --git a/bemani/backend/ess/eventlog.py b/bemani/backend/ess/eventlog.py
new file mode 100644
index 0000000..b8f83a0
--- /dev/null
+++ b/bemani/backend/ess/eventlog.py
@@ -0,0 +1,23 @@
+import random
+
+from bemani.backend.base import Base
+from bemani.protocol import Node
+
+
+class EventLogHandler(Base):
+    """
+    A mixin that can be used to provide ESS eventlog handling.
+    """
+
+    def handle_eventlog_write_request(self, request: Node) -> Node:
+        # Just turn off further logging
+        gamesession = request.child_value('data/gamesession')
+        if gamesession < 0:
+            gamesession = random.randint(1, 1000000)
+
+        root = Node.void('eventlog')
+        root.add_child(Node.s64('gamesession', gamesession))
+        root.add_child(Node.s32('logsendflg', 0))
+        root.add_child(Node.s32('logerrlevel', 0))
+        root.add_child(Node.s32('evtidnosendflg', 0))
+        return root
diff --git a/bemani/backend/iidx/__init__.py b/bemani/backend/iidx/__init__.py
new file mode 100644
index 0000000..73b7ff8
--- /dev/null
+++ b/bemani/backend/iidx/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.iidx.factory import IIDXFactory
+from bemani.backend.iidx.base import IIDXBase
diff --git a/bemani/backend/iidx/base.py b/bemani/backend/iidx/base.py
new file mode 100644
index 0000000..380324a
--- /dev/null
+++ b/bemani/backend/iidx/base.py
@@ -0,0 +1,818 @@
+# vim: set fileencoding=utf-8
+import struct
+from typing import Optional, Dict, Any, List, Tuple
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import ValidatedDict, Model, GameConstants, DBConstants, Parallel
+from bemani.data import Data, Score, Machine, UserID
+from bemani.protocol import Node
+
+
+class IIDXBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all Beatmania IIDX versions. Handles common functionality for
+    getting profiles based on refid, creating new profiles, looking up and saving
+    scores.
+    """
+
+    game = GameConstants.IIDX
+
+    paseli_padding = 15
+
+    CLEAR_TYPE_SINGLE = 1
+    CLEAR_TYPE_DOUBLE = 2
+
+    CLEAR_STATUS_NO_PLAY = DBConstants.IIDX_CLEAR_STATUS_NO_PLAY
+    CLEAR_STATUS_FAILED = DBConstants.IIDX_CLEAR_STATUS_FAILED
+    CLEAR_STATUS_ASSIST_CLEAR = DBConstants.IIDX_CLEAR_STATUS_ASSIST_CLEAR
+    CLEAR_STATUS_EASY_CLEAR = DBConstants.IIDX_CLEAR_STATUS_EASY_CLEAR
+    CLEAR_STATUS_CLEAR = DBConstants.IIDX_CLEAR_STATUS_CLEAR
+    CLEAR_STATUS_HARD_CLEAR = DBConstants.IIDX_CLEAR_STATUS_HARD_CLEAR
+    CLEAR_STATUS_EX_HARD_CLEAR = DBConstants.IIDX_CLEAR_STATUS_EX_HARD_CLEAR
+    CLEAR_STATUS_FULL_COMBO = DBConstants.IIDX_CLEAR_STATUS_FULL_COMBO
+
+    CHART_TYPE_N7 = 0
+    CHART_TYPE_H7 = 1
+    CHART_TYPE_A7 = 2
+    CHART_TYPE_N14 = 3
+    CHART_TYPE_H14 = 4
+    CHART_TYPE_A14 = 5
+    # Beginner charts only save status
+    CHART_TYPE_B7 = 6
+
+    DAN_RANK_7_KYU = DBConstants.IIDX_DAN_RANK_7_KYU
+    DAN_RANK_6_KYU = DBConstants.IIDX_DAN_RANK_6_KYU
+    DAN_RANK_5_KYU = DBConstants.IIDX_DAN_RANK_5_KYU
+    DAN_RANK_4_KYU = DBConstants.IIDX_DAN_RANK_4_KYU
+    DAN_RANK_3_KYU = DBConstants.IIDX_DAN_RANK_3_KYU
+    DAN_RANK_2_KYU = DBConstants.IIDX_DAN_RANK_2_KYU
+    DAN_RANK_1_KYU = DBConstants.IIDX_DAN_RANK_1_KYU
+    DAN_RANK_1_DAN = DBConstants.IIDX_DAN_RANK_1_DAN
+    DAN_RANK_2_DAN = DBConstants.IIDX_DAN_RANK_2_DAN
+    DAN_RANK_3_DAN = DBConstants.IIDX_DAN_RANK_3_DAN
+    DAN_RANK_4_DAN = DBConstants.IIDX_DAN_RANK_4_DAN
+    DAN_RANK_5_DAN = DBConstants.IIDX_DAN_RANK_5_DAN
+    DAN_RANK_6_DAN = DBConstants.IIDX_DAN_RANK_6_DAN
+    DAN_RANK_7_DAN = DBConstants.IIDX_DAN_RANK_7_DAN
+    DAN_RANK_8_DAN = DBConstants.IIDX_DAN_RANK_8_DAN
+    DAN_RANK_9_DAN = DBConstants.IIDX_DAN_RANK_9_DAN
+    DAN_RANK_10_DAN = DBConstants.IIDX_DAN_RANK_10_DAN
+    DAN_RANK_CHUDEN = DBConstants.IIDX_DAN_RANK_CHUDEN
+    DAN_RANK_KAIDEN = DBConstants.IIDX_DAN_RANK_KAIDEN
+
+    DAN_RANKING_SINGLE = 'sgrade'
+    DAN_RANKING_DOUBLE = 'dgrade'
+
+    GHOST_TYPE_NONE = 0
+    GHOST_TYPE_RIVAL = 100
+    GHOST_TYPE_GLOBAL_TOP = 200
+    GHOST_TYPE_GLOBAL_AVERAGE = 300
+    GHOST_TYPE_LOCAL_TOP = 400
+    GHOST_TYPE_LOCAL_AVERAGE = 500
+    GHOST_TYPE_DAN_TOP = 600
+    GHOST_TYPE_DAN_AVERAGE = 700
+    GHOST_TYPE_RIVAL_TOP = 800
+    GHOST_TYPE_RIVAL_AVERAGE = 900
+
+    def __init__(self, data: Data, config: Dict[str, Any], model: Model) -> None:
+        super().__init__(data, config, model)
+        if model.rev == 'X':
+            self.omnimix = True
+        else:
+            self.omnimix = False
+
+    @property
+    def music_version(self) -> int:
+        if self.omnimix:
+            return DBConstants.OMNIMIX_VERSION_BUMP + self.version
+        return self.version
+
+    def previous_version(self) -> Optional['IIDXBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def extra_services(self) -> List[str]:
+        """
+        Return the local2 service so that Copula and above will send certain packets.
+        """
+        return [
+            'local2',
+        ]
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('pc')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication.
+        """
+        if refid is None:
+            return None
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            # User doesn't exist but should at this point
+            return None
+
+        # Trying to import from current version
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+        return self.format_profile(userid, profile)
+
+    def new_profile_by_refid(self, refid: Optional[str], name: Optional[str], pid: Optional[int]) -> ValidatedDict:
+        """
+        Given a RefID and an optional name, create a profile and then return
+        that newly created profile.
+        """
+        if refid is None:
+            return None
+
+        if name is None:
+            name = 'なし'
+        if pid is None:
+            pid = 51
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        defaultprofile = ValidatedDict({
+            'name': name,
+            'pid': pid,
+            'settings': {
+                'flags': 223  # Default to turning on all optional folders
+            },
+        })
+        self.put_profile(userid, defaultprofile)
+        profile = self.get_profile(userid)
+        return profile
+
+    def put_profile_by_extid(self, extid: Optional[int], request: Node) -> None:
+        """
+        Given an ExtID and a request node, unformat the profile and save it.
+        """
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            return
+
+        oldprofile = self.get_profile(userid)
+        newprofile = self.unformat_profile(userid, request, oldprofile)
+        if newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+    def get_machine_by_id(self, shop_id: int) -> Optional[Machine]:
+        pcbid = self.data.local.machine.from_machine_id(shop_id)
+        if pcbid is not None:
+            return self.data.local.machine.get_machine(pcbid)
+        else:
+            return None
+
+    def machine_joined_arcade(self) -> bool:
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        return machine.arcade is not None
+
+    def get_clear_rates(
+        self,
+        songid: Optional[int]=None,
+        songchart: Optional[int]=None,
+    ) -> Dict[int, Dict[int, Dict[str, int]]]:
+        """
+        Returns a dictionary similar to the following:
+
+        {
+            musicid: {
+                chart: {
+                    total: total plays,
+                    clears: total clears,
+                    fcs: total full combos,
+                },
+            },
+        }
+        """
+        all_attempts, remote_attempts = Parallel.execute([
+            lambda: self.data.local.music.get_all_attempts(
+                game=self.game,
+                version=self.music_version,
+                songid=songid,
+                songchart=songchart,
+            ),
+            lambda: self.data.remote.music.get_clear_rates(
+                game=self.game,
+                version=self.music_version,
+                songid=songid,
+                songchart=songchart,
+            ),
+        ])
+
+        attempts: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for (_, attempt) in all_attempts:
+            if attempt.data.get_int('clear_status') == self.CLEAR_STATUS_NO_PLAY:
+                # This attempt was outside of the clear infra, so don't bother with it.
+                continue
+
+            # Terrible temporary structure is terrible.
+            if attempt.id not in attempts:
+                attempts[attempt.id] = {}
+            if attempt.chart not in attempts[attempt.id]:
+                attempts[attempt.id][attempt.chart] = {
+                    'total': 0,
+                    'clears': 0,
+                    'fcs': 0,
+                }
+
+            # We saw an attempt, keep the total attempts in sync.
+            attempts[attempt.id][attempt.chart]['total'] = attempts[attempt.id][attempt.chart]['total'] + 1
+
+            if attempt.data.get_int('clear_status', self.CLEAR_STATUS_FAILED) == self.CLEAR_STATUS_FAILED:
+                # This attempt was a failure, so don't count it against clears of full combos
+                continue
+
+            # It was at least a clear
+            attempts[attempt.id][attempt.chart]['clears'] = attempts[attempt.id][attempt.chart]['clears'] + 1
+
+            if attempt.data.get_int('clear_status') == self.CLEAR_STATUS_FULL_COMBO:
+                # This was a full combo clear, so it also counts here
+                attempts[attempt.id][attempt.chart]['fcs'] = attempts[attempt.id][attempt.chart]['fcs'] + 1
+
+        # Merge in remote attempts
+        for songid in remote_attempts:
+            if songid not in attempts:
+                attempts[songid] = {}
+
+            for songchart in remote_attempts[songid]:
+                if songchart not in attempts[songid]:
+                    attempts[songid][songchart] = {
+                        'total': 0,
+                        'clears': 0,
+                        'fcs': 0,
+                    }
+
+                attempts[songid][songchart]['total'] += remote_attempts[songid][songchart]['plays']
+                attempts[songid][songchart]['clears'] += remote_attempts[songid][songchart]['clears']
+                attempts[songid][songchart]['fcs'] += remote_attempts[songid][songchart]['combos']
+
+        # If requesting a specific song/chart, make sure its in the dict
+        if songid is not None:
+            if songid not in attempts:
+                attempts[songid] = {}
+
+            if songchart is not None:
+                if songchart not in attempts[songid]:
+                    attempts[songid][songchart] = {
+                        'total': 0,
+                        'clears': 0,
+                        'fcs': 0,
+                    }
+
+        return attempts
+
+    def update_score(
+        self,
+        userid: Optional[UserID],
+        songid: int,
+        chart: int,
+        clear_status: int,
+        pgreats: int,
+        greats: int,
+        miss_count: int,
+        ghost: Optional[bytes],
+        shop: Optional[int],
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in IIDX series can expect
+        the same attributes in a score. Note that the medals passed here are
+        expected to be converted from game identifier to our internal identifier,
+        so that any game in the series may convert them back. In this way, a song
+        played on Pendual that exists in Tricoro will still have scores/medals
+        going back all versions.
+        """
+        # Range check medals
+        if clear_status not in [
+            self.CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO,
+        ]:
+            raise Exception("Invalid clear status value {}".format(clear_status))
+
+        # Calculate ex score
+        ex_score = (2 * pgreats) + greats
+
+        if userid is not None:
+            if ghost is None:
+                raise Exception("Expected a ghost for user score save!")
+            oldscore = self.data.local.music.get_score(
+                self.game,
+                self.music_version,
+                userid,
+                songid,
+                chart,
+            )
+        else:
+            # Storing an anonymous attempt
+            if ghost is not None:
+                raise Exception("Expected no ghost for anonymous score save!")
+            oldscore = None
+
+        # Score history is verbatum, instead of highest score
+        history = ValidatedDict({
+            'clear_status': clear_status,
+            'miss_count': miss_count,
+        })
+        old_ex_score = ex_score
+
+        if ghost is not None:
+            history['ghost'] = ghost
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({
+                'clear_status': clear_status,
+                'miss_count': miss_count,
+                'pgreats': pgreats,
+                'greats': greats,
+            })
+            if ghost is not None:
+                scoredata['ghost'] = ghost
+            raised = True
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            raised = ex_score > oldscore.points
+            highscore = ex_score >= oldscore.points
+            ex_score = max(ex_score, oldscore.points)
+            scoredata = oldscore.data
+            scoredata.replace_int('clear_status', max(scoredata.get_int('clear_status'), clear_status))
+            if raised:
+                scoredata.replace_int('miss_count', miss_count)
+                scoredata.replace_int('pgreats', pgreats)
+                scoredata.replace_int('greats', greats)
+                if ghost is not None:
+                    scoredata.replace_bytes('ghost', ghost)
+
+        if shop is not None:
+            history.replace_int('shop', shop)
+            scoredata.replace_int('shop', shop)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        if userid is not None:
+            # Write the new score back
+            self.data.local.music.put_score(
+                self.game,
+                self.music_version,
+                userid,
+                songid,
+                chart,
+                lid,
+                ex_score,
+                scoredata,
+                highscore,
+            )
+
+        # Save the history of this score too
+        self.data.local.music.put_attempt(
+            self.game,
+            self.music_version,
+            userid,
+            songid,
+            chart,
+            lid,
+            old_ex_score,
+            history,
+            raised,
+        )
+
+    def update_rank(
+        self,
+        userid: UserID,
+        dantype: str,
+        rank: int,
+        percent: int,
+        cleared: bool,
+        stages_cleared: int,
+    ) -> None:
+        # Range check type
+        if dantype not in [
+            self.DAN_RANKING_SINGLE,
+            self.DAN_RANKING_DOUBLE,
+        ]:
+            raise Exception("Invalid dan rank type value {}".format(dantype))
+
+        # Range check rank
+        if rank not in [
+            self.DAN_RANK_7_KYU,
+            self.DAN_RANK_6_KYU,
+            self.DAN_RANK_5_KYU,
+            self.DAN_RANK_4_KYU,
+            self.DAN_RANK_3_KYU,
+            self.DAN_RANK_2_KYU,
+            self.DAN_RANK_1_KYU,
+            self.DAN_RANK_1_DAN,
+            self.DAN_RANK_2_DAN,
+            self.DAN_RANK_3_DAN,
+            self.DAN_RANK_4_DAN,
+            self.DAN_RANK_5_DAN,
+            self.DAN_RANK_6_DAN,
+            self.DAN_RANK_7_DAN,
+            self.DAN_RANK_8_DAN,
+            self.DAN_RANK_9_DAN,
+            self.DAN_RANK_10_DAN,
+            self.DAN_RANK_CHUDEN,
+            self.DAN_RANK_KAIDEN,
+        ]:
+            raise Exception("Invalid dan rank {}".format(rank))
+
+        if cleared:
+            # Update profile if needed
+            profile = self.get_profile(userid)
+            if profile is None:
+                profile = ValidatedDict()
+
+            profile.replace_int(dantype, max(rank, profile.get_int(dantype, -1)))
+            self.put_profile(userid, profile)
+
+        # Update achievement to track pass rate
+        dan_score = self.data.local.user.get_achievement(
+            self.game,
+            self.version,
+            userid,
+            rank,
+            dantype,
+        )
+        if dan_score is None:
+            dan_score = ValidatedDict()
+        dan_score.replace_int('percent', max(percent, dan_score.get_int('percent')))
+        dan_score.replace_int('stages_cleared', max(stages_cleared, dan_score.get_int('stages_cleared')))
+        self.data.local.user.put_achievement(
+            self.game,
+            self.version,
+            userid,
+            rank,
+            dantype,
+            dan_score
+        )
+
+    def db_to_game_status(self, db_status: int) -> int:
+        """
+        Given a DB status, translate to a game clear status.
+        """
+        raise Exception('Implement in specific game class!')
+
+    def game_to_db_status(self, game_status: int) -> int:
+        """
+        Given a game clear status, translate to DB status.
+        """
+        raise Exception('Implement in specific game class!')
+
+    def make_score_struct(self, scores: List[Score], cltype: int, index: int) -> List[List[int]]:
+        scorestruct: Dict[int, List[int]] = {}
+
+        for score in scores:
+            musicid = score.id
+            chart = score.chart
+
+            # Filter to only singles/doubles charts
+            if cltype == self.CLEAR_TYPE_SINGLE:
+                if chart not in [
+                    self.CHART_TYPE_N7,
+                    self.CHART_TYPE_H7,
+                    self.CHART_TYPE_A7,
+                ]:
+                    continue
+                chartindex = {
+                    self.CHART_TYPE_N7: 0,
+                    self.CHART_TYPE_H7: 1,
+                    self.CHART_TYPE_A7: 2,
+                }[chart]
+            if cltype == self.CLEAR_TYPE_DOUBLE:
+                if chart not in [
+                    self.CHART_TYPE_N14,
+                    self.CHART_TYPE_H14,
+                    self.CHART_TYPE_A14,
+                ]:
+                    continue
+                chartindex = {
+                    self.CHART_TYPE_N14: 0,
+                    self.CHART_TYPE_H14: 1,
+                    self.CHART_TYPE_A14: 2,
+                }[chart]
+
+            if musicid not in scorestruct:
+                scorestruct[musicid] = [
+                    index,  # -1 is our scores, positive is rival index
+                    musicid,  # Music ID!
+                    0,  # Normal status,
+                    0,  # Hyper status,
+                    0,  # Another status,
+                    0,  # EX score normal,
+                    0,  # EX score hyper,
+                    0,  # EX score another,
+                    -1,  # Miss count normal,
+                    -1,  # Miss count hyper,
+                    -1,  # Miss count another,
+                ]
+
+            scorestruct[musicid][chartindex + 2] = self.db_to_game_status(score.data.get_int('clear_status'))
+            scorestruct[musicid][chartindex + 5] = score.points
+            scorestruct[musicid][chartindex + 8] = score.data.get_int('miss_count', -1)
+
+        return [scorestruct[s] for s in scorestruct]
+
+    def make_beginner_struct(self, scores: List[Score]) -> List[List[int]]:
+        scorelist: List[List[int]] = []
+
+        for score in scores:
+            musicid = score.id
+            chart = score.chart
+
+            # Filter to only beginner charts
+            if chart != self.CHART_TYPE_B7:
+                continue
+
+            scorelist.append([
+                musicid,
+                self.db_to_game_status(score.data.get_int('clear_status')),
+            ])
+
+        return scorelist
+
+    def delta_score(
+        self,
+        scores: List[Score],
+        ghost_length: int,
+    ) -> Tuple[Optional[int], Optional[bytes]]:
+        if len(scores) == 0:
+            return None, None
+
+        total_ghost = [0] * ghost_length
+        count = 0
+
+        # Sum up for each bucket
+        for score in scores:
+            ghost = score.data.get_bytes('ghost')
+            for i in range(len(ghost)):
+                total_ghost[i] = total_ghost[i] + ghost[i]
+            count = count + 1
+
+        # Calculate average for each bucket
+        total_ghost = [int(b / count) for b in total_ghost]
+
+        # Grab the ex score for this new ghost, being sure to reverse the scaling rate
+        new_ex_score = sum(total_ghost)
+
+        # Spread out into even buckets so we can compute deltas
+        reference_ghost = [int(new_ex_score / ghost_length)] * ghost_length
+
+        added_bucket = 0
+        try:
+            jump = max(1, int(ghost_length / (new_ex_score - sum(reference_ghost))))
+        except ZeroDivisionError:
+            jump = 1
+        while sum(reference_ghost) != new_ex_score:
+            reference_ghost[added_bucket] = reference_ghost[added_bucket] + 1
+            added_bucket = added_bucket + jump
+
+        # Calculate delta ghost
+        delta_ghost = [total_ghost[i] - reference_ghost[i] for i in range(ghost_length)]
+
+        # Return averages
+        return new_ex_score, struct.pack('b' * ghost_length, *delta_ghost)
+
+    def user_joined_arcade(self, machine: Machine, profile: Optional[ValidatedDict]) -> bool:
+        if profile is None:
+            return False
+
+        if 'shop_location' not in profile:
+            return False
+
+        machineid = profile.get_int('shop_location')
+        if machineid == machine.id:
+            # We can short-circuit arcade lookup because their machine
+            # is the current machine.
+            return True
+
+        their_machine = self.get_machine_by_id(machineid)
+        if their_machine is None:
+            return False
+
+        # The machine they joined matches the arcade of the current machine
+        return their_machine.arcade == machine.arcade
+
+    def get_ghost(
+        self,
+        ghost_type: int,
+        parameter: str,
+        ghost_length: int,
+        musicid: int,
+        chart: int,
+        userid: UserID,
+    ) -> Optional[Dict[str, Any]]:
+        ghost_score: Dict[str, Any] = None
+
+        if ghost_type == self.GHOST_TYPE_RIVAL:
+            rival_extid = int(parameter)
+            rival_userid = self.data.remote.user.from_extid(self.game, self.version, rival_extid)
+            if rival_userid is not None:
+                rival_profile = self.get_profile(rival_userid)
+                rival_score = self.data.remote.music.get_score(self.game, self.music_version, rival_userid, musicid, chart)
+                if rival_score is not None and rival_profile is not None:
+                    ghost_score = {
+                        'score': rival_score.points,
+                        'ghost': rival_score.data.get_bytes('ghost'),
+                        'name': rival_profile.get_str('name'),
+                        'pid': rival_profile.get_int('pid'),
+                    }
+
+        if (
+            ghost_type == self.GHOST_TYPE_GLOBAL_TOP or
+            ghost_type == self.GHOST_TYPE_LOCAL_TOP or
+            ghost_type == self.GHOST_TYPE_GLOBAL_AVERAGE or
+            ghost_type == self.GHOST_TYPE_LOCAL_AVERAGE
+        ):
+            if (
+                ghost_type == self.GHOST_TYPE_LOCAL_TOP or
+                ghost_type == self.GHOST_TYPE_LOCAL_AVERAGE
+            ):
+                all_scores = sorted(
+                    self.data.local.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: s[1].points,
+                    reverse=True,
+                )
+
+                # Figure out what arcade this user joined and filter scores by
+                # other users who have also joined that arcade.
+                my_profile = self.get_profile(userid)
+                if my_profile is None:
+                    my_profile = ValidatedDict()
+
+                if 'shop_location' in my_profile:
+                    shop_id = my_profile.get_int('shop_location')
+                    machine = self.get_machine_by_id(shop_id)
+                else:
+                    machine = None
+
+                if machine is not None:
+                    all_scores = [
+                        score for score in all_scores
+                        if self.user_joined_arcade(machine, self.get_any_profile(score[0]))
+                    ]
+                else:
+                    # Not joined an arcade, so nobody matches our scores
+                    all_scores = []
+            else:
+                all_scores = sorted(
+                    self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: s[1].points,
+                    reverse=True,
+                )
+
+            if (
+                ghost_type == self.GHOST_TYPE_GLOBAL_TOP or
+                ghost_type == self.GHOST_TYPE_LOCAL_TOP
+            ):
+                for potential_top in all_scores:
+                    top_userid = potential_top[0]
+                    top_score = potential_top[1]
+                    top_profile = self.get_any_profile(top_userid)
+                    if top_profile is not None:
+                        ghost_score = {
+                            'score': top_score.points,
+                            'ghost': top_score.data.get_bytes('ghost'),
+                            'name': top_profile.get_str('name'),
+                            'pid': top_profile.get_int('pid'),
+                            'extid': top_profile.get_int('extid'),
+                        }
+                        break
+
+            if (
+                ghost_type == self.GHOST_TYPE_GLOBAL_AVERAGE or
+                ghost_type == self.GHOST_TYPE_LOCAL_AVERAGE
+            ):
+                average_score, delta_ghost = self.delta_score([score[1] for score in all_scores], ghost_length)
+                if average_score is not None and delta_ghost is not None:
+                    ghost_score = {
+                        'score': average_score,
+                        'ghost': bytes([0] * ghost_length),
+                    }
+
+        if (
+            ghost_type == self.GHOST_TYPE_DAN_TOP or
+            ghost_type == self.GHOST_TYPE_DAN_AVERAGE
+        ):
+            is_dp = chart not in [
+                self.CHART_TYPE_N7,
+                self.CHART_TYPE_H7,
+                self.CHART_TYPE_A7,
+            ]
+            my_profile = self.get_profile(userid)
+            if my_profile is None:
+                my_profile = ValidatedDict()
+            if is_dp:
+                dan_rank = my_profile.get_int(self.DAN_RANKING_DOUBLE, -1)
+            else:
+                dan_rank = my_profile.get_int(self.DAN_RANKING_SINGLE, -1)
+
+            if dan_rank != -1:
+                all_scores = sorted(
+                    self.data.local.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: s[1].points,
+                    reverse=True,
+                )
+                all_profiles = self.data.local.user.get_all_profiles(self.game, self.version)
+                relevant_userids = {
+                    profile[0] for profile in all_profiles
+                    if profile[1].get_int(self.DAN_RANKING_DOUBLE if is_dp else self.DAN_RANKING_SINGLE) == dan_rank
+                }
+                relevant_scores = [
+                    score for score in all_scores
+                    if score[0] in relevant_userids
+                ]
+                if ghost_type == self.GHOST_TYPE_DAN_TOP:
+                    for potential_top in relevant_scores:
+                        top_userid = potential_top[0]
+                        top_score = potential_top[1]
+                        top_profile = self.get_any_profile(top_userid)
+                        if top_profile is not None:
+                            ghost_score = {
+                                'score': top_score.points,
+                                'ghost': top_score.data.get_bytes('ghost'),
+                                'name': top_profile.get_str('name'),
+                                'pid': top_profile.get_int('pid'),
+                                'extid': top_profile.get_int('extid'),
+                            }
+                            break
+
+                if ghost_type == self.GHOST_TYPE_DAN_AVERAGE:
+                    average_score, delta_ghost = self.delta_score([score[1] for score in relevant_scores], ghost_length)
+                    if average_score is not None and delta_ghost is not None:
+                        ghost_score = {
+                            'score': average_score,
+                            'ghost': bytes([0] * ghost_length),
+                        }
+
+        if (
+            ghost_type == self.GHOST_TYPE_RIVAL_TOP or
+            ghost_type == self.GHOST_TYPE_RIVAL_AVERAGE
+        ):
+            rival_extids = [int(e[1:-1]) for e in parameter.split(',')]
+            rival_userids = [
+                self.data.remote.user.from_extid(self.game, self.version, rival_extid)
+                for rival_extid in rival_extids
+            ]
+
+            all_scores = sorted(
+                [
+                    score for score in
+                    self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart)
+                    if score[0] in rival_userids
+                ],
+                key=lambda s: s[1].points,
+                reverse=True,
+            )
+            if ghost_type == self.GHOST_TYPE_RIVAL_TOP:
+                for potential_top in all_scores:
+                    top_userid = potential_top[0]
+                    top_score = potential_top[1]
+                    top_profile = self.get_any_profile(top_userid)
+                    if top_profile is not None:
+                        ghost_score = {
+                            'score': top_score.points,
+                            'ghost': top_score.data.get_bytes('ghost'),
+                            'name': top_profile.get_str('name'),
+                            'pid': top_profile.get_int('pid'),
+                            'extid': top_profile.get_int('extid'),
+                        }
+                        break
+
+            if ghost_type == self.GHOST_TYPE_RIVAL_AVERAGE:
+                average_score, delta_ghost = self.delta_score([score[1] for score in all_scores], ghost_length)
+                if average_score is not None and delta_ghost is not None:
+                    ghost_score = {
+                        'score': average_score,
+                        'ghost': bytes([0] * ghost_length),
+                    }
+
+        return ghost_score
diff --git a/bemani/backend/iidx/cannonballers.py b/bemani/backend/iidx/cannonballers.py
new file mode 100644
index 0000000..f7c0151
--- /dev/null
+++ b/bemani/backend/iidx/cannonballers.py
@@ -0,0 +1,15 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.backend.iidx.sinobuz import IIDXSinobuz
+from bemani.common import VersionConstants
+
+
+class IIDXCannonBallers(IIDXBase):
+
+    name = 'Beatmania IIDX CANNON BALLERS'
+    version = VersionConstants.IIDX_CANNON_BALLERS
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXSinobuz(self.data, self.config, self.model)
diff --git a/bemani/backend/iidx/copula.py b/bemani/backend/iidx/copula.py
new file mode 100644
index 0000000..22181e2
--- /dev/null
+++ b/bemani/backend/iidx/copula.py
@@ -0,0 +1,2062 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+import struct
+from typing import Optional, Dict, Any, List, Tuple
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.backend.iidx.course import IIDXCourse
+from bemani.backend.iidx.pendual import IIDXPendual
+
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import Data, UserID
+from bemani.protocol import Node
+
+
+class IIDXCopula(IIDXCourse, IIDXBase):
+
+    name = 'Beatmania IIDX copula'
+    version = VersionConstants.IIDX_COPULA
+
+    GAME_CLTYPE_SINGLE = 0
+    GAME_CLTYPE_DOUBLE = 1
+
+    DAN_STAGES = 4
+
+    GAME_CLEAR_STATUS_NO_PLAY = 0
+    GAME_CLEAR_STATUS_FAILED = 1
+    GAME_CLEAR_STATUS_ASSIST_CLEAR = 2
+    GAME_CLEAR_STATUS_EASY_CLEAR = 3
+    GAME_CLEAR_STATUS_CLEAR = 4
+    GAME_CLEAR_STATUS_HARD_CLEAR = 5
+    GAME_CLEAR_STATUS_EX_HARD_CLEAR = 6
+    GAME_CLEAR_STATUS_FULL_COMBO = 7
+
+    GAME_GHOST_TYPE_RIVAL = 1
+    GAME_GHOST_TYPE_GLOBAL_TOP = 2
+    GAME_GHOST_TYPE_GLOBAL_AVERAGE = 3
+    GAME_GHOST_TYPE_LOCAL_TOP = 4
+    GAME_GHOST_TYPE_LOCAL_AVERAGE = 5
+    GAME_GHOST_TYPE_DAN_TOP = 6
+    GAME_GHOST_TYPE_DAN_AVERAGE = 7
+    GAME_GHOST_TYPE_RIVAL_TOP = 8
+    GAME_GHOST_TYPE_RIVAL_AVERAGE = 9
+
+    GAME_GHOST_LENGTH = 64
+
+    GAME_SP_DAN_RANK_7_KYU = 0
+    GAME_SP_DAN_RANK_6_KYU = 1
+    GAME_SP_DAN_RANK_5_KYU = 2
+    GAME_SP_DAN_RANK_4_KYU = 3
+    GAME_SP_DAN_RANK_3_KYU = 4
+    GAME_SP_DAN_RANK_2_KYU = 5
+    GAME_SP_DAN_RANK_1_KYU = 6
+    GAME_SP_DAN_RANK_1_DAN = 7
+    GAME_SP_DAN_RANK_2_DAN = 8
+    GAME_SP_DAN_RANK_3_DAN = 9
+    GAME_SP_DAN_RANK_4_DAN = 10
+    GAME_SP_DAN_RANK_5_DAN = 11
+    GAME_SP_DAN_RANK_6_DAN = 12
+    GAME_SP_DAN_RANK_7_DAN = 13
+    GAME_SP_DAN_RANK_8_DAN = 14
+    GAME_SP_DAN_RANK_9_DAN = 15
+    GAME_SP_DAN_RANK_10_DAN = 16
+    GAME_SP_DAN_RANK_CHUDEN = 17
+    GAME_SP_DAN_RANK_KAIDEN = 18
+
+    GAME_DP_DAN_RANK_7_KYU = 0
+    GAME_DP_DAN_RANK_6_KYU = 1
+    GAME_DP_DAN_RANK_5_KYU = 2
+    GAME_DP_DAN_RANK_4_KYU = 3
+    GAME_DP_DAN_RANK_3_KYU = 4
+    GAME_DP_DAN_RANK_2_KYU = 5
+    GAME_DP_DAN_RANK_1_KYU = 6
+    GAME_DP_DAN_RANK_1_DAN = 7
+    GAME_DP_DAN_RANK_2_DAN = 8
+    GAME_DP_DAN_RANK_3_DAN = 9
+    GAME_DP_DAN_RANK_4_DAN = 10
+    GAME_DP_DAN_RANK_5_DAN = 11
+    GAME_DP_DAN_RANK_6_DAN = 12
+    GAME_DP_DAN_RANK_7_DAN = 13
+    GAME_DP_DAN_RANK_8_DAN = 14
+    GAME_DP_DAN_RANK_9_DAN = 15
+    GAME_DP_DAN_RANK_10_DAN = 16
+    GAME_DP_DAN_RANK_CHUDEN = 17
+    GAME_DP_DAN_RANK_KAIDEN = 18
+
+    FAVORITE_LIST_LENGTH = 20
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXPendual(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert dailies into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'daily_charts', 'daily'):
+            # Generate a new list of three dailies.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = list(set([song.id for song in data.local.music.get_all_songs(cls.game, cls.version)]))
+            daily_songs = random.sample(all_songs, 3)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'dailies',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': daily_songs,
+                },
+            )
+            events.append((
+                'iidx_daily_charts',
+                {
+                    'version': cls.version,
+                    'music': daily_songs,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'daily_charts', 'daily')
+        return events
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Global Shop Ranking',
+                    'tip': 'Return network-wide ranking instead of shop ranking on results screen.',
+                    'category': 'game_config',
+                    'setting': 'global_shop_ranking',
+                },
+                {
+                    'name': 'Events In Omnimix',
+                    'tip': 'Allow events to be enabled at all for Omnimix.',
+                    'category': 'game_config',
+                    'setting': 'omnimix_events_enabled',
+                },
+            ],
+            'ints': [
+                {
+                    'name': 'Event Phase',
+                    'tip': 'Event phase for all players.',
+                    'category': 'game_config',
+                    'setting': 'event_phase',
+                    'values': {
+                        0: 'No Event',
+                        1: 'Tokotoko Line',
+                        2: 'Mystery Line Phase 1',
+                        3: 'Mystery Line Phase 2',
+                        4: 'Mystery Line Phase 3',
+                    }
+                },
+            ],
+        }
+
+    def db_to_game_status(self, db_status: int) -> int:
+        return {
+            self.CLEAR_STATUS_NO_PLAY: self.GAME_CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED: self.GAME_CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR: self.GAME_CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR: self.GAME_CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR: self.GAME_CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR: self.GAME_CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR: self.GAME_CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO: self.GAME_CLEAR_STATUS_FULL_COMBO,
+        }[db_status]
+
+    def game_to_db_status(self, game_status: int) -> int:
+        return {
+            self.GAME_CLEAR_STATUS_NO_PLAY: self.CLEAR_STATUS_NO_PLAY,
+            self.GAME_CLEAR_STATUS_FAILED: self.CLEAR_STATUS_FAILED,
+            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.GAME_CLEAR_STATUS_EASY_CLEAR: self.CLEAR_STATUS_EASY_CLEAR,
+            self.GAME_CLEAR_STATUS_CLEAR: self.CLEAR_STATUS_CLEAR,
+            self.GAME_CLEAR_STATUS_HARD_CLEAR: self.CLEAR_STATUS_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_FULL_COMBO: self.CLEAR_STATUS_FULL_COMBO,
+        }[game_status]
+
+    def db_to_game_rank(self, db_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if db_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_SP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_SP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_SP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_SP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_SP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_SP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_SP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_SP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_SP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_SP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_SP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_SP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_SP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_SP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_SP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_SP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_SP_DAN_RANK_10_DAN,
+                self.DAN_RANK_CHUDEN: self.GAME_SP_DAN_RANK_CHUDEN,
+                self.DAN_RANK_KAIDEN: self.GAME_SP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_DP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_DP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_DP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_DP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_DP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_DP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_DP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_DP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_DP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_DP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_DP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_DP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_DP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_DP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_DP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_DP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_DP_DAN_RANK_10_DAN,
+                self.DAN_RANK_CHUDEN: self.GAME_DP_DAN_RANK_CHUDEN,
+                self.DAN_RANK_KAIDEN: self.GAME_DP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def game_to_db_rank(self, game_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if game_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.GAME_SP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_SP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_SP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_SP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_SP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_SP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_SP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_SP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_SP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_SP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_SP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_SP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_SP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_SP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_SP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_SP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_SP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_SP_DAN_RANK_CHUDEN: self.DAN_RANK_CHUDEN,
+                self.GAME_SP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.GAME_DP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_DP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_DP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_DP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_DP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_DP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_DP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_DP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_DP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_DP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_DP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_DP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_DP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_DP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_DP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_DP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_DP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_DP_DAN_RANK_CHUDEN: self.DAN_RANK_CHUDEN,
+                self.GAME_DP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def handle_IIDX23shop_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getname':
+            root = Node.void('IIDX23shop')
+            root.set_attribute('cls_opt', '0')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            root.set_attribute('opname', machine.name)
+            root.set_attribute('pid', '51')
+            return root
+
+        if method == 'savename':
+            self.update_machine_name(request.attribute('opname'))
+            root = Node.void('IIDX23shop')
+            return root
+
+        if method == 'sentinfo':
+            root = Node.void('IIDX23shop')
+            return root
+
+        if method == 'getconvention':
+            root = Node.void('IIDX23shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            root.set_attribute('music_0', str(course.get_int('music_0', 20032)))
+            root.set_attribute('music_1', str(course.get_int('music_1', 20009)))
+            root.set_attribute('music_2', str(course.get_int('music_2', 20015)))
+            root.set_attribute('music_3', str(course.get_int('music_3', 20064)))
+            root.add_child(Node.bool('valid', course.get_bool('valid')))
+            return root
+
+        if method == 'setconvention':
+            root = Node.void('IIDX23shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = ValidatedDict()
+                course.replace_int('music_0', request.child_value('music_0'))
+                course.replace_int('music_1', request.child_value('music_1'))
+                course.replace_int('music_2', request.child_value('music_2'))
+                course.replace_int('music_3', request.child_value('music_3'))
+                course.replace_bool('valid', request.child_value('valid'))
+                self.data.local.machine.put_settings(machine.arcade, self.game, self.music_version, 'shop_course', course)
+
+            return root
+
+        if method == 'sendescapepackageinfo':
+            root = Node.void('IIDX23shop')
+            root.set_attribute('expire', str((Time.now() + 86400 * 365) * 1000))
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX23ranking_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getranker':
+            root = Node.void('IIDX23ranking')
+            chart = int(request.attribute('clid'))
+            if chart not in [
+                self.CHART_TYPE_N7,
+                self.CHART_TYPE_H7,
+                self.CHART_TYPE_A7,
+                self.CHART_TYPE_N14,
+                self.CHART_TYPE_H14,
+                self.CHART_TYPE_A14,
+            ]:
+                # Chart type 6 is presumably beginner mode, but it crashes the game
+                return root
+
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            if not course.get_bool('valid'):
+                # Shop course not enabled or not present
+                return root
+
+            convention = Node.void('convention')
+            root.add_child(convention)
+            convention.set_attribute('clid', str(chart))
+            convention.set_attribute('update_date', str(Time.now() * 1000))
+
+            # Grab all scores for each of the four songs, filter out people who haven't
+            # set us as their arcade and then return the top 20 scores (adding all 4 songs).
+            songids = [
+                course.get_int('music_0'),
+                course.get_int('music_1'),
+                course.get_int('music_2'),
+                course.get_int('music_3'),
+            ]
+
+            totalscores: Dict[UserID, int] = {}
+            profiles: Dict[UserID, ValidatedDict] = {}
+            for songid in songids:
+                scores = self.data.local.music.get_all_scores(
+                    self.game,
+                    self.music_version,
+                    songid=songid,
+                    songchart=chart,
+                )
+
+                for score in scores:
+                    if score[0] not in totalscores:
+                        totalscores[score[0]] = 0
+                        profile = self.get_any_profile(score[0])
+                        if profile is None:
+                            profile = ValidatedDict()
+                        profiles[score[0]] = profile
+
+                    totalscores[score[0]] += score[1].points
+
+            topscores = sorted(
+                [
+                    (totalscores[userid], profiles[userid])
+                    for userid in totalscores
+                    if self.user_joined_arcade(machine, profiles[userid])
+                ],
+                key=lambda tup: tup[0],
+                reverse=True,
+            )[:20]
+
+            rank = 0
+            for topscore in topscores:
+                rank = rank + 1
+
+                detail = Node.void('detail')
+                convention.add_child(detail)
+                detail.set_attribute('name', topscore[1].get_str('name'))
+                detail.set_attribute('rank', str(rank))
+                detail.set_attribute('score', str(topscore[0]))
+                detail.set_attribute('pid', str(topscore[1].get_int('pid')))
+
+                qpro = topscore[1].get_dict('qpro')
+                detail.set_attribute('head', str(qpro.get_int('head')))
+                detail.set_attribute('hair', str(qpro.get_int('hair')))
+                detail.set_attribute('face', str(qpro.get_int('face')))
+                detail.set_attribute('body', str(qpro.get_int('body')))
+                detail.set_attribute('hand', str(qpro.get_int('hand')))
+
+            return root
+
+        if method == 'entry':
+            extid = int(request.attribute('iidxid'))
+            courseid = int(request.attribute('coid'))
+            chart = int(request.attribute('clid'))
+            course_type = int(request.attribute('regist_type'))
+            clear_status = self.game_to_db_status(int(request.attribute('clr')))
+            pgreats = int(request.attribute('pgnum'))
+            greats = int(request.attribute('gnum'))
+
+            if course_type == 0:
+                index = self.COURSE_TYPE_INTERNET_RANKING
+            elif course_type == 1:
+                index = self.COURSE_TYPE_SECRET
+            else:
+                raise Exception('Unknown registration type for course entry!')
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                # Update achievement to track course statistics
+                self.update_course(
+                    userid,
+                    index,
+                    courseid,
+                    chart,
+                    clear_status,
+                    pgreats,
+                    greats,
+                )
+
+            # We should return the user's position, but its not displayed anywhere
+            # so fuck it.
+            root = Node.void('IIDX23ranking')
+            root.set_attribute('anum', '1')
+            root.set_attribute('jun', '1')
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX23music_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'crate':
+            root = Node.void('IIDX23music')
+            attempts = self.get_clear_rates()
+
+            all_songs = list(set([song.id for song in self.data.local.music.get_all_songs(self.game, self.music_version)]))
+            for song in all_songs:
+                clears = []
+                fcs = []
+
+                for chart in [0, 1, 2, 3, 4, 5]:
+                    placed = False
+                    if song in attempts and chart in attempts[song]:
+                        values = attempts[song][chart]
+                        if values['total'] > 0:
+                            clears.append(int((100 * values['clears']) / values['total']))
+                            fcs.append(int((100 * values['fcs']) / values['total']))
+                            placed = True
+                    if not placed:
+                        clears.append(101)
+                        fcs.append(101)
+
+                clearnode = Node.u8_array('c', clears + fcs)
+                clearnode.set_attribute('mid', str(song))
+                root.add_child(clearnode)
+
+            return root
+
+        if method == 'getrank':
+            cltype = int(request.attribute('cltype'))
+
+            root = Node.void('IIDX23music')
+            style = Node.void('style')
+            root.add_child(style)
+            style.set_attribute('type', str(cltype))
+
+            for rivalid in [-1, 0, 1, 2, 3, 4]:
+                if rivalid == -1:
+                    attr = 'iidxid'
+                else:
+                    attr = 'iidxid{}'.format(rivalid)
+
+                try:
+                    extid = int(request.attribute(attr))
+                except Exception:
+                    # Invalid extid
+                    continue
+                userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if userid is not None:
+                    scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+
+                    # Grab score data for user/rival
+                    scoredata = self.make_score_struct(
+                        scores,
+                        self.CLEAR_TYPE_SINGLE if cltype == self.GAME_CLTYPE_SINGLE else self.CLEAR_TYPE_DOUBLE,
+                        rivalid,
+                    )
+                    for s in scoredata:
+                        root.add_child(Node.s16_array('m', s))
+
+                    # Grab most played for user/rival
+                    most_played = [
+                        play[0] for play in
+                        self.data.local.music.get_most_played(self.game, self.music_version, userid, 20)
+                    ]
+                    if len(most_played) < 20:
+                        most_played.extend([0] * (20 - len(most_played)))
+                    best = Node.u16_array('best', most_played)
+                    best.set_attribute('rno', str(rivalid))
+                    root.add_child(best)
+
+                    if rivalid == -1:
+                        # Grab beginner statuses for user only
+                        beginnerdata = self.make_beginner_struct(scores)
+                        for b in beginnerdata:
+                            root.add_child(Node.u16_array('b', b))
+
+            return root
+
+        if method == 'reg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            # See if we need to report global or shop scores
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                global_scores = game_config.get_bool('global_shop_ranking')
+                machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            else:
+                # If we aren't in an arcade, we can only show global scores
+                global_scores = True
+                machine = None
+
+            # First, determine our current ranking before saving the new score
+            all_scores = sorted(
+                self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                key=lambda s: (s[1].points, s[1].timestamp),
+                reverse=True,
+            )
+            all_players = {
+                uid: prof for (uid, prof) in
+                self.get_any_profiles([s[0] for s in all_scores])
+            }
+
+            if not global_scores:
+                all_scores = [
+                    score for score in all_scores
+                    if (
+                        score[0] == userid or
+                        self.user_joined_arcade(machine, all_players[score[0]])
+                    )
+                ]
+
+            # Find our actual index
+            oldindex = None
+            for i in range(len(all_scores)):
+                if all_scores[i][0] == userid:
+                    oldindex = i
+                    break
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+                miss_count = int(request.attribute('mnum'))
+                ghost = request.child_value('ghost')
+                shopid = ID.parse_machine_id(request.attribute('shopconvid'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    chart,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    miss_count,
+                    ghost,
+                    shopid,
+                )
+
+            # Calculate and return statistics about this song
+            root = Node.void('IIDX23music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+            root.set_attribute('rankside', '0')
+
+            if userid is not None:
+                # Shop ranking
+                shopdata = Node.void('shopdata')
+                root.add_child(shopdata)
+                shopdata.set_attribute('rank', '-1' if oldindex is None else str(oldindex + 1))
+
+                # Grab the rank of some other players on this song
+                ranklist = Node.void('ranklist')
+                root.add_child(ranklist)
+
+                all_scores = sorted(
+                    self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: (s[1].points, s[1].timestamp),
+                    reverse=True,
+                )
+                missing_players = [
+                    uid for (uid, _) in all_scores
+                    if uid not in all_players
+                ]
+                for (uid, prof) in self.get_any_profiles(missing_players):
+                    all_players[uid] = prof
+
+                if not global_scores:
+                    all_scores = [
+                        score for score in all_scores
+                        if (
+                            score[0] == userid or
+                            self.user_joined_arcade(machine, all_players[score[0]])
+                        )
+                    ]
+
+                # Find our actual index
+                ourindex = None
+                for i in range(len(all_scores)):
+                    if all_scores[i][0] == userid:
+                        ourindex = i
+                        break
+                if ourindex is None:
+                    raise Exception('Cannot find our own score after saving to DB!')
+                start = ourindex - 4
+                end = ourindex + 4
+                if start < 0:
+                    start = 0
+                if end >= len(all_scores):
+                    end = len(all_scores) - 1
+                relevant_scores = all_scores[start:(end + 1)]
+
+                record_num = start + 1
+                for score in relevant_scores:
+                    profile = all_players[score[0]]
+
+                    data = Node.void('data')
+                    ranklist.add_child(data)
+                    data.set_attribute('iidx_id', str(profile.get_int('extid')))
+                    data.set_attribute('name', profile.get_str('name'))
+
+                    machine_name = ''
+                    if 'shop_location' in profile:
+                        shop_id = profile.get_int('shop_location')
+                        machine = self.get_machine_by_id(shop_id)
+                        if machine is not None:
+                            machine_name = machine.name
+                    data.set_attribute('opname', machine_name)
+                    data.set_attribute('rnum', str(record_num))
+                    data.set_attribute('score', str(score[1].points))
+                    data.set_attribute('clflg', str(self.db_to_game_status(score[1].data.get_int('clear_status'))))
+                    data.set_attribute('pid', str(profile.get_int('pid')))
+                    data.set_attribute('myFlg', '1' if score[0] == userid else '0')
+                    data.set_attribute('update', '0')
+
+                    data.set_attribute('sgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE),
+                    ))
+                    data.set_attribute('dgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE),
+                    ))
+
+                    qpro = profile.get_dict('qpro')
+                    data.set_attribute('head', str(qpro.get_int('head')))
+                    data.set_attribute('hair', str(qpro.get_int('hair')))
+                    data.set_attribute('face', str(qpro.get_int('face')))
+                    data.set_attribute('body', str(qpro.get_int('body')))
+                    data.set_attribute('hand', str(qpro.get_int('hand')))
+
+                    record_num = record_num + 1
+
+            return root
+
+        if method == 'breg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    self.CHART_TYPE_B7,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    -1,
+                    b'',
+                    None,
+                )
+
+            # Return nothing.
+            root = Node.void('IIDX23music')
+            return root
+
+        if method == 'play':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+
+            self.update_score(
+                None,  # No userid since its anonymous
+                musicid,
+                chart,
+                clear_status,
+                0,  # No ex score
+                0,  # No ex score
+                0,  # No miss count
+                None,  # No ghost
+                None,  # No shop for this user
+            )
+
+            # Calculate and return statistics about this song
+            root = Node.void('IIDX23music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+
+            return root
+
+        if method == 'appoint':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            ghost_type = int(request.attribute('ctype'))
+            extid = int(request.attribute('iidxid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            root = Node.void('IIDX23music')
+
+            if userid is not None:
+                # Try to look up previous ghost for user
+                my_score = self.data.remote.music.get_score(self.game, self.music_version, userid, musicid, chart)
+                if my_score is not None:
+                    mydata = Node.binary('mydata', my_score.data.get_bytes('ghost'))
+                    mydata.set_attribute('score', str(my_score.points))
+                    root.add_child(mydata)
+
+                ghost_score = self.get_ghost(
+                    {
+                        self.GAME_GHOST_TYPE_RIVAL: self.GHOST_TYPE_RIVAL,
+                        self.GAME_GHOST_TYPE_GLOBAL_TOP: self.GHOST_TYPE_GLOBAL_TOP,
+                        self.GAME_GHOST_TYPE_GLOBAL_AVERAGE: self.GHOST_TYPE_GLOBAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_LOCAL_TOP: self.GHOST_TYPE_LOCAL_TOP,
+                        self.GAME_GHOST_TYPE_LOCAL_AVERAGE: self.GHOST_TYPE_LOCAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_DAN_TOP: self.GHOST_TYPE_DAN_TOP,
+                        self.GAME_GHOST_TYPE_DAN_AVERAGE: self.GHOST_TYPE_DAN_AVERAGE,
+                        self.GAME_GHOST_TYPE_RIVAL_TOP: self.GHOST_TYPE_RIVAL_TOP,
+                        self.GAME_GHOST_TYPE_RIVAL_AVERAGE: self.GHOST_TYPE_RIVAL_AVERAGE,
+                    }.get(ghost_type, self.GHOST_TYPE_NONE),
+                    request.attribute('subtype'),
+                    self.GAME_GHOST_LENGTH,
+                    musicid,
+                    chart,
+                    userid,
+                )
+
+                # Add ghost score if we support it
+                if ghost_score is not None:
+                    sdata = Node.binary('sdata', ghost_score['ghost'])
+                    sdata.set_attribute('score', str(ghost_score['score']))
+                    if 'name' in ghost_score:
+                        sdata.set_attribute('name', ghost_score['name'])
+                    if 'pid' in ghost_score:
+                        sdata.set_attribute('pid', str(ghost_score['pid']))
+                    if 'extid' in ghost_score:
+                        sdata.set_attribute('riidxid', str(ghost_score['extid']))
+                    root.add_child(sdata)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX23grade_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'raised':
+            extid = int(request.attribute('iidxid'))
+            cltype = int(request.attribute('gtype'))
+            rank = self.game_to_db_rank(int(request.attribute('gid')), cltype)
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                percent = int(request.attribute('achi'))
+                stages_cleared = int(request.attribute('cstage'))
+                cleared = stages_cleared == self.DAN_STAGES
+
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    index = self.DAN_RANKING_SINGLE
+                else:
+                    index = self.DAN_RANKING_DOUBLE
+
+                self.update_rank(
+                    userid,
+                    index,
+                    rank,
+                    percent,
+                    cleared,
+                    stages_cleared,
+                )
+
+            # Figure out number of players that played this ranking
+            all_achievements = self.data.local.user.get_all_achievements(self.game, self.version)
+            num_players = 0
+            for [_, ach] in all_achievements:
+                if ach.type != index:
+                    continue
+                if ach.id != rank:
+                    continue
+                num_players = num_players + 1
+
+            root = Node.void('IIDX23grade')
+            root.set_attribute('pnum', str(num_players))
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX23pc_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'common':
+            root = Node.void('IIDX23pc')
+            root.set_attribute('expire', '600')
+
+            ir = Node.void('ir')
+            root.add_child(ir)
+            ir.set_attribute('beat', '2')
+
+            # See if we configured event overrides
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                event_phase = game_config.get_int('event_phase')
+                omni_events = game_config.get_bool('omnimix_events_enabled')
+            else:
+                # If we aren't in an arcade, we turn off events
+                event_phase = 0
+                omni_events = False
+
+            if event_phase == 0 or (self.omnimix and (not omni_events)):
+                boss_phase = 0
+                event1 = 0
+                event2 = 0
+            elif event_phase == 1:
+                boss_phase = 1
+                event1 = 1
+                event2 = 0
+            elif event_phase in [2, 3, 4]:
+                boss_phase = 2
+                event1 = 0
+                event2 = event_phase - 1
+
+            boss = Node.void('boss')
+            root.add_child(boss)
+            boss.set_attribute('phase', str(boss_phase))
+
+            event1_phase = Node.void('event1_phase')
+            root.add_child(event1_phase)
+            event1_phase.set_attribute('phase', str(event1))
+
+            event2_phase = Node.void('event2_phase')
+            root.add_child(event2_phase)
+            event2_phase.set_attribute('phase', str(event2))
+
+            extra_boss_event = Node.void('extra_boss_event')
+            root.add_child(extra_boss_event)
+            extra_boss_event.set_attribute('phase', '1')
+
+            bemani_summer2016 = Node.void('bemani_summer2016')
+            root.add_child(bemani_summer2016)
+            bemani_summer2016.set_attribute('phase', '1')
+
+            vip_black_pass = Node.void('vip_pass_black')
+            root.add_child(vip_black_pass)
+
+            event1_rainbow_ticket = Node.void('event1_rainbow_ticket')
+            root.add_child(event1_rainbow_ticket)
+
+            djlevel_result = Node.void('djlevel_result')
+            root.add_child(djlevel_result)
+
+            newsong_another = Node.void('newsong_another')
+            root.add_child(newsong_another)
+            newsong_another.set_attribute('open', '1')
+
+            # Course definitions
+            courses: List[Dict[str, Any]] = [
+                {
+                    'name': 'POP',
+                    'id': 1,
+                    'songs': [
+                        23034,
+                        23012,
+                        23011,
+                        23032,
+                    ],
+                },
+                {
+                    'name': 'TRANCE',
+                    'id': 2,
+                    'songs': [
+                        23014,
+                        23033,
+                        23038,
+                        23013,
+                    ],
+                },
+                {
+                    'name': 'DJ',
+                    'id': 3,
+                    'songs': [
+                        23025,
+                        23026,
+                        23024,
+                        23061,
+                    ],
+                },
+                {
+                    'name': 'HCN',
+                    'id': 4,
+                    'songs': [
+                        23016,
+                        23010,
+                        23057,
+                        23000,
+                    ],
+                },
+                {
+                    'name': 'TRAIN',
+                    'id': 5,
+                    'songs': [
+                        23023,
+                        6029,
+                        23047,
+                        7008,
+                    ],
+                },
+                {
+                    'name': 'USAO',
+                    'id': 6,
+                    'songs': [
+                        20064,
+                        21015,
+                        22044,
+                        23027,
+                    ],
+                },
+                {
+                    'name': 'New Face',
+                    'id': 7,
+                    'songs': [
+                        23054,
+                        23039,
+                        23036,
+                        23045,
+                    ],
+                },
+                {
+                    'name': 'CANDY',
+                    'id': 8,
+                    'songs': [
+                        16021,
+                        18069,
+                        19073,
+                        23008,
+                    ],
+                },
+                {
+                    'name': 'ROCK',
+                    'id': 9,
+                    'songs': [
+                        8026,
+                        23002,
+                        22072,
+                        23050,
+                    ],
+                },
+                {
+                    'name': 'JAZZ',
+                    'id': 10,
+                    'songs': [
+                        1017,
+                        20088,
+                        23035,
+                        23030,
+                    ],
+                },
+                {
+                    'name': 'TAIYO',
+                    'id': 11,
+                    'songs': [
+                        11007,
+                        23020,
+                        13029,
+                        23051,
+                    ],
+                },
+                {
+                    'name': 'RHYZE',
+                    'id': 12,
+                    'songs': [
+                        23029,
+                        21070,
+                        21071,
+                        20063,
+                    ],
+                },
+                {
+                    'name': 'COLLABORATION',
+                    'id': 13,
+                    'songs': [
+                        20094,
+                        20008,
+                        20020,
+                        21082,
+                    ],
+                },
+            ]
+
+            # Secret course definitions
+            secret_courses: List[Dict[str, Any]] = [
+                {
+                    'name': 'COLORS',
+                    'id': 1,
+                    'songs': [
+                        20038,
+                        20012,
+                        20007,
+                        22012,
+                    ],
+                },
+                {
+                    'name': 'BROKEN',
+                    'id': 2,
+                    'songs': [
+                        4003,
+                        18028,
+                        18068,
+                        22001,
+                    ],
+                },
+                {
+                    'name': 'PENDUAL',
+                    'id': 3,
+                    'songs': [
+                        22013,
+                        22008,
+                        22054,
+                        22100,
+                    ],
+                },
+                {
+                    'name': 'SYMMETRY',
+                    'id': 4,
+                    'songs': [
+                        9052,
+                        10024,
+                        12054,
+                        22017,
+                    ],
+                },
+                {
+                    'name': 'SEVEN',
+                    'id': 5,
+                    'songs': [
+                        13014,
+                        11014,
+                        17059,
+                        22011,
+                    ],
+                },
+                {
+                    'name': 'RAVE',
+                    'id': 6,
+                    'songs': [
+                        21051,
+                        22078,
+                        21083,
+                        23078,
+                    ],
+                },
+                {
+                    'name': 'P*Light',
+                    'id': 7,
+                    'songs': [
+                        22061,
+                        23031,
+                        22080,
+                        23079,
+                    ],
+                },
+                {
+                    'name': 'GRAND FINAL',
+                    'id': 8,
+                    'songs': [
+                        14021,
+                        21032,
+                        21045,
+                        23075,
+                    ],
+                },
+                {
+                    'name': 'SAY RYU',
+                    'id': 9,
+                    'songs': [
+                        13038,
+                        15026,
+                        21007,
+                        23082,
+                    ],
+                },
+                {
+                    'name': 'SUMMER',
+                    'id': 10,
+                    'songs': [
+                        15048,
+                        18005,
+                        18021,
+                        23091,
+                    ],
+                },
+                {
+                    'name': 'ART CORE',
+                    'id': 11,
+                    'songs': [
+                        10023,
+                        22051,
+                        20097,
+                        23090,
+                    ],
+                },
+                {
+                    'name': 'HAPPY',
+                    'id': 12,
+                    'songs': [
+                        11036,
+                        19070,
+                        20040,
+                        23093,
+                    ],
+                },
+                {
+                    'name': 'TAG',
+                    'id': 13,
+                    'songs': [
+                        21058,
+                        20015,
+                        18056,
+                        23095,
+                    ],
+                },
+            ]
+
+            # For some reason, copula omnimix crashes on course mode, so don't enable it
+            if not self.omnimix:
+                internet_ranking = Node.void('internet_ranking')
+                root.add_child(internet_ranking)
+
+                used_ids: List[int] = []
+                for c in courses:
+                    if c['id'] in used_ids:
+                        raise Exception('Cannot have multiple courses with the same ID!')
+                    elif c['id'] < 0 or c['id'] >= 20:
+                        raise Exception('Course ID is out of bounds!')
+                    else:
+                        used_ids.append(c['id'])
+                    course = Node.void('course')
+                    internet_ranking.add_child(course)
+                    course.set_attribute('opflg', '1')
+                    course.set_attribute('course_id', str(c['id']))
+                    course.set_attribute('mid0', str(c['songs'][0]))
+                    course.set_attribute('mid1', str(c['songs'][1]))
+                    course.set_attribute('mid2', str(c['songs'][2]))
+                    course.set_attribute('mid3', str(c['songs'][3]))
+                    course.set_attribute('name', c['name'])
+
+                secret_ex_course = Node.void('secret_ex_course')
+                root.add_child(secret_ex_course)
+
+                used_secret_ids: List[int] = []
+                for c in secret_courses:
+                    if c['id'] in used_secret_ids:
+                        raise Exception('Cannot have multiple secret courses with the same ID!')
+                    elif c['id'] < 0 or c['id'] >= 20:
+                        raise Exception('Secret course ID is out of bounds!')
+                    else:
+                        used_secret_ids.append(c['id'])
+                    course = Node.void('course')
+                    secret_ex_course.add_child(course)
+                    course.set_attribute('course_id', str(c['id']))
+                    course.set_attribute('mid0', str(c['songs'][0]))
+                    course.set_attribute('mid1', str(c['songs'][1]))
+                    course.set_attribute('mid2', str(c['songs'][2]))
+                    course.set_attribute('mid3', str(c['songs'][3]))
+                    course.set_attribute('name', c['name'])
+
+                expert = Node.void('expert')
+                root.add_child(expert)
+                expert.set_attribute('phase', '1')
+
+                expert_random_select = Node.void('expert_random_select')
+                root.add_child(expert_random_select)
+                expert_random_select.set_attribute('phase', '1')
+
+                expert_full = Node.void('expert_secret_full_open')
+                root.add_child(expert_full)
+
+            return root
+
+        if method == 'delete':
+            return Node.void('IIDX23pc')
+
+        if method == 'playstart':
+            return Node.void('IIDX23pc')
+
+        if method == 'playend':
+            return Node.void('IIDX23pc')
+
+        if method == 'oldget':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+
+            root = Node.void('IIDX23pc')
+            root.set_attribute('status', '1' if profile is None else '0')
+            return root
+
+        if method == 'getname':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+            if profile is None:
+                raise Exception(
+                    'Should not get here if we have no profile, we should ' +
+                    'have returned \'1\' in the \'oldget\' method above ' +
+                    'which should tell the game not to present a migration.'
+                )
+
+            root = Node.void('IIDX23pc')
+            root.set_attribute('name', profile.get_str('name'))
+            root.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+            root.set_attribute('pid', str(profile.get_int('pid')))
+            return root
+
+        if method == 'takeover':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            newprofile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('IIDX23pc')
+            if newprofile is not None:
+                root.set_attribute('id', str(newprofile.get_int('extid')))
+            return root
+
+        if method == 'reg':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            profile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('IIDX23pc')
+            if profile is not None:
+                root.set_attribute('id', str(profile.get_int('extid')))
+                root.set_attribute('id_str', ID.format_extid(profile.get_int('extid')))
+            return root
+
+        if method == 'get':
+            refid = request.attribute('rid')
+            root = self.get_profile_by_refid(refid)
+            if root is None:
+                root = Node.void('IIDX23pc')
+            return root
+
+        if method == 'save':
+            extid = int(request.attribute('iidxid'))
+            self.put_profile_by_extid(extid, request)
+
+            root = Node.void('IIDX23pc')
+            return root
+
+        if method == 'visit':
+            root = Node.void('IIDX23pc')
+            root.set_attribute('anum', '0')
+            root.set_attribute('pnum', '0')
+            root.set_attribute('sflg', '0')
+            root.set_attribute('pflg', '0')
+            root.set_attribute('aflg', '0')
+            root.set_attribute('snum', '0')
+            return root
+
+        if method == 'shopregister':
+            extid = int(request.child_value('iidx_id'))
+            location = ID.parse_machine_id(request.child_value('location_id'))
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                profile = self.get_profile(userid)
+                if profile is None:
+                    profile = ValidatedDict()
+                profile.replace_int('shop_location', location)
+                self.put_profile(userid, profile)
+
+            root = Node.void('IIDX23pc')
+            return root
+
+        # Invalid method
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('IIDX23pc')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Look up judge window adjustments
+        judge_dict = profile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+
+        # Profile data
+        pcdata = Node.void('pcdata')
+        root.add_child(pcdata)
+        pcdata.set_attribute('id', str(profile.get_int('extid')))
+        pcdata.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+        pcdata.set_attribute('name', profile.get_str('name'))
+        pcdata.set_attribute('pid', str(profile.get_int('pid')))
+        pcdata.set_attribute('spnum', str(play_stats.get_int('single_plays')))
+        pcdata.set_attribute('dpnum', str(play_stats.get_int('double_plays')))
+        pcdata.set_attribute('sach', str(play_stats.get_int('single_dj_points')))
+        pcdata.set_attribute('dach', str(play_stats.get_int('double_dj_points')))
+        pcdata.set_attribute('mode', str(profile.get_int('mode')))
+        pcdata.set_attribute('pmode', str(profile.get_int('pmode')))
+        pcdata.set_attribute('rtype', str(profile.get_int('rtype')))
+        pcdata.set_attribute('sp_opt', str(profile.get_int('sp_opt')))
+        pcdata.set_attribute('dp_opt', str(profile.get_int('dp_opt')))
+        pcdata.set_attribute('dp_opt2', str(profile.get_int('dp_opt2')))
+        pcdata.set_attribute('gpos', str(profile.get_int('gpos')))
+        pcdata.set_attribute('s_sorttype', str(profile.get_int('s_sorttype')))
+        pcdata.set_attribute('d_sorttype', str(profile.get_int('d_sorttype')))
+        pcdata.set_attribute('s_pace', str(profile.get_int('s_pace')))
+        pcdata.set_attribute('d_pace', str(profile.get_int('d_pace')))
+        pcdata.set_attribute('s_gno', str(profile.get_int('s_gno')))
+        pcdata.set_attribute('d_gno', str(profile.get_int('d_gno')))
+        pcdata.set_attribute('s_gtype', str(profile.get_int('s_gtype')))
+        pcdata.set_attribute('d_gtype', str(profile.get_int('d_gtype')))
+        pcdata.set_attribute('s_sdlen', str(profile.get_int('s_sdlen')))
+        pcdata.set_attribute('d_sdlen', str(profile.get_int('d_sdlen')))
+        pcdata.set_attribute('s_sdtype', str(profile.get_int('s_sdtype')))
+        pcdata.set_attribute('d_sdtype', str(profile.get_int('d_sdtype')))
+        pcdata.set_attribute('s_timing', str(profile.get_int('s_timing')))
+        pcdata.set_attribute('d_timing', str(profile.get_int('d_timing')))
+        pcdata.set_attribute('s_notes', str(profile.get_float('s_notes')))
+        pcdata.set_attribute('d_notes', str(profile.get_float('d_notes')))
+        pcdata.set_attribute('s_judge', str(profile.get_int('s_judge')))
+        pcdata.set_attribute('d_judge', str(profile.get_int('d_judge')))
+        pcdata.set_attribute('s_judgeAdj', str(machine_judge.get_int('single')))
+        pcdata.set_attribute('d_judgeAdj', str(machine_judge.get_int('double')))
+        pcdata.set_attribute('s_hispeed', str(profile.get_float('s_hispeed')))
+        pcdata.set_attribute('d_hispeed', str(profile.get_float('d_hispeed')))
+        pcdata.set_attribute('s_liflen', str(profile.get_int('s_lift')))
+        pcdata.set_attribute('d_liflen', str(profile.get_int('d_lift')))
+        pcdata.set_attribute('s_disp_judge', str(profile.get_int('s_disp_judge')))
+        pcdata.set_attribute('d_disp_judge', str(profile.get_int('d_disp_judge')))
+        pcdata.set_attribute('s_opstyle', str(profile.get_int('s_opstyle')))
+        pcdata.set_attribute('d_opstyle', str(profile.get_int('d_opstyle')))
+        pcdata.set_attribute('s_exscore', str(profile.get_int('s_exscore')))
+        pcdata.set_attribute('d_exscore', str(profile.get_int('d_exscore')))
+        pcdata.set_attribute('s_largejudge', str(profile.get_int('s_largejudge')))
+        pcdata.set_attribute('d_largejudge', str(profile.get_int('d_largejudge')))
+
+        premium_unlocks = Node.void('ea_premium_course')
+        root.add_child(premium_unlocks)
+
+        # Secret flags (shh!)
+        secret_dict = profile.get_dict('secret')
+        secret = Node.void('secret')
+        root.add_child(secret)
+        secret.add_child(Node.s64_array('flg1', secret_dict.get_int_array('flg1', 4)))
+        secret.add_child(Node.s64_array('flg2', secret_dict.get_int_array('flg2', 4)))
+        secret.add_child(Node.s64_array('flg3', secret_dict.get_int_array('flg3', 4)))
+
+        # Favorites
+        for folder in ['favorite1', 'favorite2', 'favorite3']:
+            favorite_dict = profile.get_dict(folder)
+            sp_mlist = b''
+            sp_clist = b''
+            singles_list = favorite_dict['single'] if 'single' in favorite_dict else []
+            for single in singles_list:
+                sp_mlist = sp_mlist + struct.pack('<L', single['id'])
+                sp_clist = sp_clist + struct.pack('B', single['chart'])
+            while len(sp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+                sp_mlist = sp_mlist + b'\x00\x00\x00\x00'
+            while len(sp_clist) < self.FAVORITE_LIST_LENGTH:
+                sp_clist = sp_clist + b'\x00'
+
+            dp_mlist = b''
+            dp_clist = b''
+            doubles_list = favorite_dict['double'] if 'double' in favorite_dict else []
+            for double in doubles_list:
+                dp_mlist = dp_mlist + struct.pack('<L', double['id'])
+                dp_clist = dp_clist + struct.pack('B', double['chart'])
+            while len(dp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+                dp_mlist = dp_mlist + b'\x00\x00\x00\x00'
+            while len(dp_clist) < self.FAVORITE_LIST_LENGTH:
+                dp_clist = dp_clist + b'\x00'
+
+            if folder == 'favorite1':
+                favorite = Node.void('favorite')
+            elif folder == 'favorite2':
+                favorite = Node.void('extra_favorite')
+                favorite.set_attribute('folder_id', '0')
+            elif folder == 'favorite3':
+                favorite = Node.void('extra_favorite')
+                favorite.set_attribute('folder_id', '1')
+            root.add_child(favorite)
+            favorite.add_child(Node.binary('sp_mlist', sp_mlist))
+            favorite.add_child(Node.binary('sp_clist', sp_clist))
+            favorite.add_child(Node.binary('dp_mlist', dp_mlist))
+            favorite.add_child(Node.binary('dp_clist', dp_clist))
+
+        # DAN rankings
+        grade = Node.void('grade')
+        root.add_child(grade)
+        grade.set_attribute('sgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+        grade.set_attribute('dgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+        rankings = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for rank in rankings:
+            if rank.type == self.DAN_RANKING_SINGLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_SINGLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_SINGLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+            if rank.type == self.DAN_RANKING_DOUBLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_DOUBLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_DOUBLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+
+        # User settings
+        settings_dict = profile.get_dict('settings')
+        skin = Node.s16_array(
+            'skin',
+            [
+                settings_dict.get_int('frame'),
+                settings_dict.get_int('turntable'),
+                settings_dict.get_int('burst'),
+                settings_dict.get_int('bgm'),
+                settings_dict.get_int('flags'),
+                settings_dict.get_int('towel'),
+                settings_dict.get_int('judge_pos'),
+                settings_dict.get_int('voice'),
+                settings_dict.get_int('noteskin'),
+                settings_dict.get_int('full_combo'),
+                settings_dict.get_int('beam'),
+                settings_dict.get_int('judge'),
+                0,
+                settings_dict.get_int('disable_song_preview'),
+            ],
+        )
+        root.add_child(skin)
+
+        # Qpro data
+        qpro_dict = profile.get_dict('qpro')
+        root.add_child(Node.u32_array(
+            'qprodata',
+            [
+                qpro_dict.get_int('head'),
+                qpro_dict.get_int('hair'),
+                qpro_dict.get_int('face'),
+                qpro_dict.get_int('hand'),
+                qpro_dict.get_int('body'),
+            ],
+        ))
+
+        # Rivals
+        rlist = Node.void('rlist')
+        root.add_child(rlist)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            rival_type = None
+            if link.type == 'sp_rival':
+                rival_type = '1'
+            elif link.type == 'dp_rival':
+                rival_type = '2'
+            else:
+                # No business with this link type
+                continue
+
+            other_profile = self.get_profile(link.other_userid)
+            if other_profile is None:
+                continue
+            other_play_stats = self.get_play_statistics(link.other_userid)
+
+            rival = Node.void('rival')
+            rlist.add_child(rival)
+            rival.set_attribute('spdp', rival_type)
+            rival.set_attribute('id', str(other_profile.get_int('extid')))
+            rival.set_attribute('id_str', ID.format_extid(other_profile.get_int('extid')))
+            rival.set_attribute('djname', other_profile.get_str('name'))
+            rival.set_attribute('pid', str(other_profile.get_int('pid')))
+            rival.set_attribute('sg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+            rival.set_attribute('dg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+            rival.set_attribute('sa', str(other_play_stats.get_int('single_dj_points')))
+            rival.set_attribute('da', str(other_play_stats.get_int('double_dj_points')))
+
+            # If the user joined a particular shop, let the game know.
+            if 'shop_location' in other_profile:
+                shop_id = other_profile.get_int('shop_location')
+                machine = self.get_machine_by_id(shop_id)
+                if machine is not None:
+                    shop = Node.void('shop')
+                    rival.add_child(shop)
+                    shop.set_attribute('name', machine.name)
+
+            qprodata = Node.void('qprodata')
+            rival.add_child(qprodata)
+            qpro = other_profile.get_dict('qpro')
+            qprodata.set_attribute('head', str(qpro.get_int('head')))
+            qprodata.set_attribute('hair', str(qpro.get_int('hair')))
+            qprodata.set_attribute('face', str(qpro.get_int('face')))
+            qprodata.set_attribute('body', str(qpro.get_int('body')))
+            qprodata.set_attribute('hand', str(qpro.get_int('hand')))
+
+        # Expert courses
+        ir_data = Node.void('ir_data')
+        root.add_child(ir_data)
+        for rank in rankings:
+            if rank.type == self.COURSE_TYPE_INTERNET_RANKING:
+                ir_data.add_child(Node.s32_array('e', [
+                    int(rank.id / 6),  # course ID
+                    rank.id % 6,  # course chart
+                    self.db_to_game_status(rank.data.get_int('clear_status')),  # course clear status
+                    rank.data.get_int('pgnum'),  # flashing great count
+                    rank.data.get_int('gnum'),  # great count
+                ]))
+
+        secret_course_data = Node.void('secret_course_data')
+        root.add_child(secret_course_data)
+        for rank in rankings:
+            if rank.type == self.COURSE_TYPE_SECRET:
+                secret_course_data.add_child(Node.s32_array('e', [
+                    int(rank.id / 6),  # course ID
+                    rank.id % 6,  # course chart
+                    self.db_to_game_status(rank.data.get_int('clear_status')),  # course clear status
+                    rank.data.get_int('pgnum'),  # flashing great count
+                    rank.data.get_int('gnum'),  # great count
+                ]))
+
+        # If the user joined a particular shop, let the game know.
+        if 'shop_location' in profile:
+            shop_id = profile.get_int('shop_location')
+            machine = self.get_machine_by_id(shop_id)
+            if machine is not None:
+                join_shop = Node.void('join_shop')
+                root.add_child(join_shop)
+                join_shop.set_attribute('joinflg', '1')
+                join_shop.set_attribute('join_cflg', '1')
+                join_shop.set_attribute('join_id', ID.format_machine_id(machine.id))
+                join_shop.set_attribute('join_name', machine.name)
+
+        # Step up mode
+        step_dict = profile.get_dict('step')
+        step = Node.void('step')
+        root.add_child(step)
+        step.set_attribute('friendship', str(step_dict.get_int('friendship')))
+        step.set_attribute('progress', str(step_dict.get_int('progress')))
+        step.set_attribute('station_clear', str(step_dict.get_int('station_clear')))
+        step.set_attribute('station_play', str(step_dict.get_int('station_play')))
+        step.set_attribute('sp_mission', str(step_dict.get_int('sp_mission')))
+        step.set_attribute('dp_mission', str(step_dict.get_int('dp_mission')))
+        step.set_attribute('sp_level', str(step_dict.get_int('sp_level')))
+        step.set_attribute('dp_level', str(step_dict.get_int('dp_level')))
+        step.set_attribute('sp_mplay', str(step_dict.get_int('sp_mplay')))
+        step.set_attribute('dp_mplay', str(step_dict.get_int('dp_mplay')))
+        step.set_attribute('mission_gauge', str(step_dict.get_int('mission_gauge')))
+        if 'tokimeki' in step_dict:
+            step.add_child(Node.binary('tokimeki', step_dict.get_bytes('tokimeki', b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')))
+
+        # Daily recommendations
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'dailies')
+        if entry is not None:
+            packinfo = Node.void('packinfo')
+            root.add_child(packinfo)
+
+            pack_id = int(entry['start_time'] / 86400)
+            packinfo.set_attribute('pack_id', str(pack_id))
+            packinfo.set_attribute('music_0', str(entry['music'][0]))
+            packinfo.set_attribute('music_1', str(entry['music'][1]))
+            packinfo.set_attribute('music_2', str(entry['music'][2]))
+        else:
+            # No dailies :(
+            pack_id = None
+
+        # Tran medals and shit
+        achievements = Node.void('achievements')
+        root.add_child(achievements)
+
+        # Dailies
+        if pack_id is None:
+            achievements.set_attribute('pack', '0')
+            achievements.set_attribute('pack_comp', '0')
+        else:
+            daily_played = self.data.local.user.get_achievement(self.game, self.version, userid, pack_id, 'daily')
+            if daily_played is None:
+                daily_played = ValidatedDict()
+            achievements.set_attribute('pack', str(daily_played.get_int('pack_flg')))
+            achievements.set_attribute('pack_comp', str(daily_played.get_int('pack_comp')))
+
+        # Weeklies
+        achievements.set_attribute('last_weekly', str(profile.get_int('last_weekly')))
+        achievements.set_attribute('weekly_num', str(profile.get_int('weekly_num')))
+
+        # Prefecture visit flag
+        achievements.set_attribute('visit_flg', str(profile.get_int('visit_flg')))
+
+        # Number of rivals beaten
+        achievements.set_attribute('rival_crush', str(profile.get_int('rival_crush')))
+
+        # Tran medals
+        achievements.add_child(Node.s64_array('trophy', profile.get_int_array('trophy', 10)))
+
+        # Track deller
+        deller = Node.void('deller')
+        root.add_child(deller)
+        deller.set_attribute('deller', str(profile.get_int('deller')))
+        deller.set_attribute('rate', '0')
+
+        # Orb data
+        orb_data = Node.void('orb_data')
+        root.add_child(orb_data)
+        orb_data.set_attribute('rest_orb', str(profile.get_int('orbs')))
+
+        # Expert points
+        expert_point = Node.void('expert_point')
+        root.add_child(expert_point)
+        for rank in rankings:
+            if rank.type == 'expert_point':
+                detail = Node.void('detail')
+                expert_point.add_child(detail)
+                detail.set_attribute('course_id', str(rank.id))
+                detail.set_attribute('n_point', str(rank.data.get_int('normal_points')))
+                detail.set_attribute('h_point', str(rank.data.get_int('hyper_points')))
+                detail.set_attribute('a_point', str(rank.data.get_int('another_points')))
+
+        # Tokotoko Line Event
+        if 'event1' in profile:
+            # Only provide this if we've already saved it, so the game can init it's own way.
+            event1_dict = profile.get_dict('event1')
+            event1_data = Node.void('event1_data')
+            root.add_child(event1_data)
+            event1_data.set_attribute('point_map_0', str(event1_dict.get_int('point_map_0')))
+            event1_data.set_attribute('point_map_1', str(event1_dict.get_int('point_map_1')))
+            event1_data.set_attribute('point_map_2', str(event1_dict.get_int('point_map_2')))
+            event1_data.set_attribute('point_map_3', str(event1_dict.get_int('point_map_3')))
+            event1_data.set_attribute('point_map_4', str(event1_dict.get_int('point_map_4')))
+            event1_data.set_attribute('hold_point', str(event1_dict.get_int('hold_point')))
+            event1_data.set_attribute('last_map', str(event1_dict.get_int('last_map')))
+            event1_data.set_attribute('rank_point', str(event1_dict.get_int('rank_point')))
+            event1_data.set_attribute('tips_list', str(event1_dict.get_int('tips_list')))
+            event1_data.set_attribute('gift_point', '0')
+
+        # Mystery Line Event
+        if 'event2' in profile:
+            # Only provide this if we've already saved it, so the game can init it's own way.
+            event2_dict = profile.get_dict('event2')
+            event2_data = Node.void('event2_data')
+            root.add_child(event2_data)
+            event2_data.set_attribute('play_num', str(event2_dict.get_int('play_num')))
+            event2_data.set_attribute('now_area', str(event2_dict.get_int('now_area')))
+            event2_data.set_attribute('now_note_grade', str(event2_dict.get_int('now_note_grade')))
+            event2_data.set_attribute('stop_area_time', str(event2_dict.get_int('stop_area_time')))
+
+            areas = self.data.local.user.get_achievements(self.game, self.version, userid)
+            for area in areas:
+                if area.type != 'event2_area_data':
+                    continue
+
+                event2_area_data = Node.void('event2_area_data')
+                event2_data.add_child(event2_area_data)
+                event2_area_data.set_attribute('area_no', str(area.id))
+                event2_area_data.set_attribute('area_play', str(area.data.get_int('play_num')))
+                event2_area_data.set_attribute('normal_point', str(area.data.get_int('normal_point')))
+                event2_area_data.set_attribute('hyper_point', str(area.data.get_int('hyper_point')))
+                event2_area_data.set_attribute('another_point', str(area.data.get_int('another_point')))
+
+        # One More Event
+        if 'onemore' in profile:
+            # Only provide this if we've already saved it, so the game can init it's own way.
+            onemore_dict = profile.get_dict('onemore')
+            onemore_data = Node.void('onemore_data')
+            root.add_child(onemore_data)
+            onemore_data.set_attribute('defeat_0', str(onemore_dict.get_int('defeat_0')))
+            onemore_data.set_attribute('defeat_1', str(onemore_dict.get_int('defeat_1')))
+            onemore_data.set_attribute('defeat_2', str(onemore_dict.get_int('defeat_2')))
+            onemore_data.set_attribute('defeat_3', str(onemore_dict.get_int('defeat_3')))
+            onemore_data.set_attribute('defeat_4', str(onemore_dict.get_int('defeat_4')))
+            onemore_data.set_attribute('defeat_5', str(onemore_dict.get_int('defeat_5')))
+            onemore_data.set_attribute('challenge_num_n', str(onemore_dict.get_int('challenge_num_n')))
+            onemore_data.set_attribute('challenge_num_h', str(onemore_dict.get_int('challenge_num_h')))
+            onemore_data.set_attribute('challenge_num_a', str(onemore_dict.get_int('challenge_num_a')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Track play counts
+        cltype = int(request.attribute('cltype'))
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            play_stats.increment_int('single_plays')
+        if cltype == self.GAME_CLTYPE_DOUBLE:
+            play_stats.increment_int('double_plays')
+
+        # Track DJ points
+        play_stats.replace_int('single_dj_points', int(request.attribute('s_achi')))
+        play_stats.replace_int('double_dj_points', int(request.attribute('d_achi')))
+
+        # Profile settings
+        newprofile.replace_int('mode', int(request.attribute('mode')))
+        newprofile.replace_int('pmode', int(request.attribute('pmode')))
+        newprofile.replace_int('rtype', int(request.attribute('rtype')))
+        newprofile.replace_int('s_lift', int(request.attribute('s_lift')))
+        newprofile.replace_int('d_lift', int(request.attribute('d_lift')))
+        newprofile.replace_int('sp_opt', int(request.attribute('sp_opt')))
+        newprofile.replace_int('dp_opt', int(request.attribute('dp_opt')))
+        newprofile.replace_int('dp_opt2', int(request.attribute('dp_opt2')))
+        newprofile.replace_int('gpos', int(request.attribute('gpos')))
+        newprofile.replace_int('s_sorttype', int(request.attribute('s_sorttype')))
+        newprofile.replace_int('d_sorttype', int(request.attribute('d_sorttype')))
+        newprofile.replace_int('s_pace', int(request.attribute('s_pace')))
+        newprofile.replace_int('d_pace', int(request.attribute('d_pace')))
+        newprofile.replace_int('s_gno', int(request.attribute('s_gno')))
+        newprofile.replace_int('d_gno', int(request.attribute('d_gno')))
+        newprofile.replace_int('s_gtype', int(request.attribute('s_gtype')))
+        newprofile.replace_int('d_gtype', int(request.attribute('d_gtype')))
+        newprofile.replace_int('s_sdlen', int(request.attribute('s_sdlen')))
+        newprofile.replace_int('d_sdlen', int(request.attribute('d_sdlen')))
+        newprofile.replace_int('s_sdtype', int(request.attribute('s_sdtype')))
+        newprofile.replace_int('d_sdtype', int(request.attribute('d_sdtype')))
+        newprofile.replace_int('s_timing', int(request.attribute('s_timing')))
+        newprofile.replace_int('d_timing', int(request.attribute('d_timing')))
+        newprofile.replace_float('s_notes', float(request.attribute('s_notes')))
+        newprofile.replace_float('d_notes', float(request.attribute('d_notes')))
+        newprofile.replace_int('s_judge', int(request.attribute('s_judge')))
+        newprofile.replace_int('d_judge', int(request.attribute('d_judge')))
+        newprofile.replace_float('s_hispeed', float(request.attribute('s_hispeed')))
+        newprofile.replace_float('d_hispeed', float(request.attribute('d_hispeed')))
+        newprofile.replace_int('s_disp_judge', int(request.attribute('s_disp_judge')))
+        newprofile.replace_int('d_disp_judge', int(request.attribute('d_disp_judge')))
+        newprofile.replace_int('s_opstyle', int(request.attribute('s_opstyle')))
+        newprofile.replace_int('d_opstyle', int(request.attribute('d_opstyle')))
+        newprofile.replace_int('s_exscore', int(request.attribute('s_exscore')))
+        newprofile.replace_int('d_exscore', int(request.attribute('d_exscore')))
+        newprofile.replace_int('s_largejudge', int(request.attribute('s_largejudge')))
+        newprofile.replace_int('d_largejudge', int(request.attribute('d_largejudge')))
+
+        # Update judge window adjustments per-machine
+        judge_dict = newprofile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+        machine_judge.replace_int('single', int(request.attribute('s_judgeAdj')))
+        machine_judge.replace_int('double', int(request.attribute('d_judgeAdj')))
+        judge_dict.replace_dict(self.config['machine']['pcbid'], machine_judge)
+        newprofile.replace_dict('machine_judge_adjust', judge_dict)
+
+        # Secret flags saving
+        secret = request.child('secret')
+        if secret is not None:
+            secret_dict = newprofile.get_dict('secret')
+            secret_dict.replace_int_array('flg1', 4, secret.child_value('flg1'))
+            secret_dict.replace_int_array('flg2', 4, secret.child_value('flg2'))
+            secret_dict.replace_int_array('flg3', 4, secret.child_value('flg3'))
+            newprofile.replace_dict('secret', secret_dict)
+
+        # Basic achievements
+        achievements = request.child('achievements')
+        if achievements is not None:
+            newprofile.replace_int('visit_flg', int(achievements.attribute('visit_flg')))
+            newprofile.replace_int('last_weekly', int(achievements.attribute('last_weekly')))
+            newprofile.replace_int('weekly_num', int(achievements.attribute('weekly_num')))
+
+            pack_id = int(achievements.attribute('pack_id'))
+            if pack_id > 0:
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    pack_id,
+                    'daily',
+                    {
+                        'pack_flg': int(achievements.attribute('pack_flg')),
+                        'pack_comp': int(achievements.attribute('pack_comp')),
+                    },
+                )
+
+            trophies = achievements.child('trophy')
+            if trophies is not None:
+                # We only load the first 10 in profile load.
+                newprofile.replace_int_array('trophy', 10, trophies.value[:10])
+
+        # Deller saving
+        deller = request.child('deller')
+        if deller is not None:
+            newprofile.replace_int('deller', newprofile.get_int('deller') + int(deller.attribute('deller')))
+
+        # Secret course expert point saving
+        expert_point = request.child('expert_point')
+        if expert_point is not None:
+            courseid = int(expert_point.attribute('course_id'))
+
+            # Update achievement to track expert points
+            expert_point_achievement = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                courseid,
+                'expert_point',
+            )
+            if expert_point_achievement is None:
+                expert_point_achievement = ValidatedDict()
+            expert_point_achievement.replace_int(
+                'normal_points',
+                int(expert_point.attribute('n_point')),
+            )
+            expert_point_achievement.replace_int(
+                'hyper_points',
+                int(expert_point.attribute('h_point')),
+            )
+            expert_point_achievement.replace_int(
+                'another_points',
+                int(expert_point.attribute('a_point')),
+            )
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                courseid,
+                'expert_point',
+                expert_point_achievement,
+            )
+
+        # Favorites saving
+        for favorite in request.children:
+            singles = []
+            doubles = []
+            name = None
+            if favorite.name in ['favorite', 'extra_favorite']:
+                if favorite.name == 'favorite':
+                    name = 'favorite1'
+                elif favorite.name == 'extra_favorite':
+                    folder = favorite.attribute('folder_id')
+                    if folder == '0':
+                        name = 'favorite2'
+                    if folder == '1':
+                        name = 'favorite3'
+                if name is None:
+                    continue
+
+                single_music_bin = favorite.child_value('sp_mlist')
+                single_chart_bin = favorite.child_value('sp_clist')
+                double_music_bin = favorite.child_value('dp_mlist')
+                double_chart_bin = favorite.child_value('dp_clist')
+
+                for i in range(self.FAVORITE_LIST_LENGTH):
+                    singles.append({
+                        'id': struct.unpack('<L', single_music_bin[(i * 4):((i + 1) * 4)])[0],
+                        'chart': struct.unpack('B', single_chart_bin[i:(i + 1)])[0],
+                    })
+                    doubles.append({
+                        'id': struct.unpack('<L', double_music_bin[(i * 4):((i + 1) * 4)])[0],
+                        'chart': struct.unpack('B', double_chart_bin[i:(i + 1)])[0],
+                    })
+
+            # Filter out empty charts
+            singles = [single for single in singles if single['id'] != 0]
+            doubles = [double for double in doubles if double['id'] != 0]
+
+            newprofile.replace_dict(
+                name,
+                {
+                    'single': singles,
+                    'double': doubles,
+                },
+            )
+
+        # Step-up mode
+        step = request.child('step')
+        if step is not None:
+            step_dict = newprofile.get_dict('step')
+            step_dict.replace_int('friendship', int(step.attribute('friendship')))
+            step_dict.replace_int('progress', int(step.attribute('progress')))
+            step_dict.replace_int('station_clear', int(step.attribute('station_clear')))
+            step_dict.replace_int('station_play', int(step.attribute('station_play')))
+            step_dict.replace_int('sp_mission', int(step.attribute('sp_mission')))
+            step_dict.replace_int('dp_mission', int(step.attribute('dp_mission')))
+            step_dict.replace_int('sp_level', int(step.attribute('sp_level')))
+            step_dict.replace_int('dp_level', int(step.attribute('dp_level')))
+            step_dict.replace_int('sp_mplay', int(step.attribute('sp_mplay')))
+            step_dict.replace_int('dp_mplay', int(step.attribute('dp_mplay')))
+            step_dict.replace_int('mission_gauge', int(step.attribute('mission_gauge')))
+            step_dict.replace_bytes('tokimeki', step.value)
+            newprofile.replace_dict('step', step_dict)
+
+        # Orb data saving
+        orb_data = request.child('orb_data')
+        if orb_data is not None:
+            orbs = newprofile.get_int('orbs')
+            orbs = orbs + int(orb_data.attribute('add_orb'))
+            if orb_data.child_value('use_vip_pass'):
+                orbs = 0
+            newprofile.replace_int('orbs', orbs)
+
+        # Tokotoko Line Event
+        event1_data = request.child('event1_data')
+        if event1_data is not None:
+            event1_dict = newprofile.get_dict('event1')
+            event1_dict.replace_int('hold_point', int(event1_data.attribute('hold_point')))
+            event1_dict.replace_int('last_map', int(event1_data.attribute('last_map')))
+            event1_dict.replace_int('rank_point', int(event1_data.attribute('rank_point')))
+            event1_dict.replace_int('tips_list', int(event1_data.attribute('tips_list')))
+            event1_dict.replace_int('point_map_0', int(event1_data.attribute('point_map_0')))
+            event1_dict.replace_int('point_map_1', int(event1_data.attribute('point_map_1')))
+            event1_dict.replace_int('point_map_2', int(event1_data.attribute('point_map_2')))
+            event1_dict.replace_int('point_map_3', int(event1_data.attribute('point_map_3')))
+            event1_dict.replace_int('point_map_4', int(event1_data.attribute('point_map_4')))
+            newprofile.replace_dict('event1', event1_dict)
+
+        # Mystery Line Event
+        event2_data = request.child('event2_data')
+        if event2_data is not None:
+            event2_dict = newprofile.get_dict('event2')
+            event2_dict.replace_int('now_area', int(event2_data.attribute('now_stay_area')))
+            event2_dict.replace_int('now_note_grade', int(event2_data.attribute('now_stay_note_grade')))
+            event2_dict.replace_int('play_num', int(event2_data.attribute('play_num')))
+            event2_dict.replace_int('stop_area_time', int(event2_data.attribute('stop_area_time')))
+            newprofile.replace_dict('event2', event2_dict)
+
+            for area_data in event2_data.children:
+                if area_data.name != 'event2_area_data':
+                    continue
+
+                area_id = int(area_data.attribute('area_no'))
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    area_id,
+                    'event2_area_data',
+                    {
+                        'play_num': int(area_data.attribute('area_play_num')),
+                        'normal_point': int(area_data.attribute('normal_point')),
+                        'hyper_point': int(area_data.attribute('hyper_point')),
+                        'another_point': int(area_data.attribute('another_point')),
+                    },
+                )
+
+        # Onemore Event
+        onemore_data = request.child('onemore_data')
+        if onemore_data is not None:
+            onemore_dict = newprofile.get_dict('onemore')
+            onemore_dict.replace_int('defeat_0', int(onemore_data.attribute('defeat_0')))
+            onemore_dict.replace_int('defeat_1', int(onemore_data.attribute('defeat_1')))
+            onemore_dict.replace_int('defeat_2', int(onemore_data.attribute('defeat_2')))
+            onemore_dict.replace_int('defeat_3', int(onemore_data.attribute('defeat_3')))
+            onemore_dict.replace_int('defeat_4', int(onemore_data.attribute('defeat_4')))
+            onemore_dict.replace_int('defeat_5', int(onemore_data.attribute('defeat_5')))
+            onemore_dict.replace_int('challenge_num_n', int(onemore_data.attribute('challenge_num_n')))
+            onemore_dict.replace_int('challenge_num_h', int(onemore_data.attribute('challenge_num_h')))
+            onemore_dict.replace_int('challenge_num_a', int(onemore_data.attribute('challenge_num_a')))
+            newprofile.replace_dict('onemore', onemore_dict)
+
+        # Keep track of play statistics across all mixes
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/iidx/course.py b/bemani/backend/iidx/course.py
new file mode 100644
index 0000000..fadc0b7
--- /dev/null
+++ b/bemani/backend/iidx/course.py
@@ -0,0 +1,72 @@
+# vim: set fileencoding=utf-8
+from typing import Tuple
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.common import ValidatedDict
+from bemani.data import UserID
+
+
+class IIDXCourse(IIDXBase):
+
+    COURSE_TYPE_SECRET = 'secret_course'
+    COURSE_TYPE_INTERNET_RANKING = 'ir_course'
+    COURSE_TYPE_CLASSIC = 'classic_course'
+
+    def id_and_chart_from_courseid(self, courseid: int) -> Tuple[int, int]:
+        return (int(courseid / 6), courseid % 6)
+
+    def update_course(
+        self,
+        userid: UserID,
+        coursetype: str,
+        courseid: int,
+        chart: int,
+        clear_status: int,
+        pgreats: int,
+        greats: int,
+    ) -> None:
+        # Range check course type
+        if coursetype not in [
+            self.COURSE_TYPE_SECRET,
+            self.COURSE_TYPE_INTERNET_RANKING,
+            self.COURSE_TYPE_CLASSIC,
+        ]:
+            raise Exception("Invalid course type value {}".format(coursetype))
+
+        # Range check medals
+        if clear_status not in [
+            self.CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO,
+        ]:
+            raise Exception("Invalid clear status value {}".format(clear_status))
+
+        # Update achievement to track course statistics
+        course_score = self.data.local.user.get_achievement(
+            self.game,
+            self.version,
+            userid,
+            courseid * 6 + chart,
+            coursetype,
+        )
+        if course_score is None:
+            course_score = ValidatedDict()
+        course_score.replace_int('clear_status', max(clear_status, course_score.get_int('clear_status')))
+        old_ex_score = (course_score.get_int('pgnum') * 2) + course_score.get_int('gnum')
+        if old_ex_score < ((pgreats * 2) + greats):
+            course_score.replace_int('pgnum', pgreats)
+            course_score.replace_int('gnum', greats)
+
+        self.data.local.user.put_achievement(
+            self.game,
+            self.version,
+            userid,
+            courseid * 6 + chart,
+            coursetype,
+            course_score,
+        )
diff --git a/bemani/backend/iidx/factory.py b/bemani/backend/iidx/factory.py
new file mode 100644
index 0000000..b349654
--- /dev/null
+++ b/bemani/backend/iidx/factory.py
@@ -0,0 +1,133 @@
+from typing import Dict, Optional, Any
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.iidx.stubs import (
+    IIDX1stStyle,
+    IIDX2ndStyle,
+    IIDX3rdStyle,
+    IIDX4thStyle,
+    IIDX5thStyle,
+    IIDX6thStyle,
+    IIDX7thStyle,
+    IIDX8thStyle,
+    IIDX9thStyle,
+    IIDX10thStyle,
+    IIDXRed,
+    IIDXHappySky,
+    IIDXDistorted,
+    IIDXGold,
+    IIDXDJTroopers,
+    IIDXEmpress,
+    IIDXSirius,
+    IIDXResortAnthem,
+    IIDXLincle,
+)
+from bemani.backend.iidx.tricoro import IIDXTricoro
+from bemani.backend.iidx.spada import IIDXSpada
+from bemani.backend.iidx.pendual import IIDXPendual
+from bemani.backend.iidx.copula import IIDXCopula
+from bemani.backend.iidx.sinobuz import IIDXSinobuz
+from bemani.backend.iidx.cannonballers import IIDXCannonBallers
+from bemani.common import Model, VersionConstants
+from bemani.data import Data
+
+
+class IIDXFactory(Factory):
+
+    MANAGED_CLASSES = [
+        IIDX1stStyle,
+        IIDX2ndStyle,
+        IIDX3rdStyle,
+        IIDX4thStyle,
+        IIDX5thStyle,
+        IIDX6thStyle,
+        IIDX7thStyle,
+        IIDX8thStyle,
+        IIDX9thStyle,
+        IIDX10thStyle,
+        IIDXRed,
+        IIDXHappySky,
+        IIDXDistorted,
+        IIDXGold,
+        IIDXDJTroopers,
+        IIDXEmpress,
+        IIDXSirius,
+        IIDXResortAnthem,
+        IIDXLincle,
+        IIDXTricoro,
+        IIDXSpada,
+        IIDXPendual,
+        IIDXCopula,
+        IIDXSinobuz,
+        IIDXCannonBallers,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['JDJ', 'JDZ', 'KDZ', 'LDJ']:
+            Base.register(game, IIDXFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        def version_from_date(date: int) -> Optional[int]:
+            if date < 2013100200:
+                return VersionConstants.IIDX_TRICORO
+            if date >= 2013100200 and date < 2014091700:
+                return VersionConstants.IIDX_SPADA
+            if date >= 2014091700 and date < 2015111100:
+                return VersionConstants.IIDX_PENDUAL
+            if date >= 2015111100 and date < 2016102600:
+                return VersionConstants.IIDX_COPULA
+            if date >= 2016102600 and date < 2017122100:
+                return VersionConstants.IIDX_SINOBUZ
+            if date >= 2017122100:
+                return VersionConstants.IIDX_CANNON_BALLERS
+            return None
+
+        if model.game == 'JDJ':
+            return IIDXSirius(data, config, model)
+        if model.game == 'JDZ':
+            return IIDXResortAnthem(data, config, model)
+        if model.game == 'KDZ':
+            return IIDXLincle(data, config, model)
+        if model.game == 'LDJ':
+            if model.version is None:
+                if parentmodel is None:
+                    return None
+
+                # We have no way to tell apart newer versions. However, we can make
+                # an educated guess if we happen to be summoned for old profile lookup.
+                if parentmodel.game not in ['JDJ', 'JDZ', 'KDZ', 'LDJ']:
+                    return None
+                parentversion = version_from_date(parentmodel.version)
+                if parentversion == VersionConstants.IIDX_SPADA:
+                    return IIDXTricoro(data, config, model)
+                if parentversion == VersionConstants.IIDX_PENDUAL:
+                    return IIDXSpada(data, config, model)
+                if parentversion == VersionConstants.IIDX_COPULA:
+                    return IIDXPendual(data, config, model)
+                if parentversion == VersionConstants.IIDX_SINOBUZ:
+                    return IIDXCopula(data, config, model)
+                if parentversion == VersionConstants.IIDX_CANNON_BALLERS:
+                    return IIDXSinobuz(data, config, model)
+
+                # Unknown older version
+                return None
+
+            version = version_from_date(model.version)
+            if version == VersionConstants.IIDX_TRICORO:
+                return IIDXTricoro(data, config, model)
+            if version == VersionConstants.IIDX_SPADA:
+                return IIDXSpada(data, config, model)
+            if version == VersionConstants.IIDX_PENDUAL:
+                return IIDXPendual(data, config, model)
+            if version == VersionConstants.IIDX_COPULA:
+                return IIDXCopula(data, config, model)
+            if version == VersionConstants.IIDX_SINOBUZ:
+                return IIDXSinobuz(data, config, model)
+            if version == VersionConstants.IIDX_CANNON_BALLERS:
+                return IIDXCannonBallers(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/iidx/pendual.py b/bemani/backend/iidx/pendual.py
new file mode 100644
index 0000000..4f40ef2
--- /dev/null
+++ b/bemani/backend/iidx/pendual.py
@@ -0,0 +1,1839 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+import struct
+from typing import Optional, Dict, Any, List, Tuple
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.backend.iidx.course import IIDXCourse
+from bemani.backend.iidx.spada import IIDXSpada
+
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import Data, UserID
+from bemani.protocol import Node
+
+
+class IIDXPendual(IIDXCourse, IIDXBase):
+
+    name = 'Beatmania IIDX PENDUAL'
+    version = VersionConstants.IIDX_PENDUAL
+
+    GAME_CLTYPE_SINGLE = 0
+    GAME_CLTYPE_DOUBLE = 1
+
+    DAN_STAGES_SINGLE = 4
+    DAN_STAGES_DOUBLE = 3
+
+    GAME_CLEAR_STATUS_NO_PLAY = 0
+    GAME_CLEAR_STATUS_FAILED = 1
+    GAME_CLEAR_STATUS_ASSIST_CLEAR = 2
+    GAME_CLEAR_STATUS_EASY_CLEAR = 3
+    GAME_CLEAR_STATUS_CLEAR = 4
+    GAME_CLEAR_STATUS_HARD_CLEAR = 5
+    GAME_CLEAR_STATUS_EX_HARD_CLEAR = 6
+    GAME_CLEAR_STATUS_FULL_COMBO = 7
+
+    GAME_GHOST_TYPE_RIVAL = 1
+    GAME_GHOST_TYPE_GLOBAL_TOP = 2
+    GAME_GHOST_TYPE_GLOBAL_AVERAGE = 3
+    GAME_GHOST_TYPE_LOCAL_TOP = 4
+    GAME_GHOST_TYPE_LOCAL_AVERAGE = 5
+    GAME_GHOST_TYPE_DAN_TOP = 6
+    GAME_GHOST_TYPE_DAN_AVERAGE = 7
+    GAME_GHOST_TYPE_RIVAL_TOP = 8
+    GAME_GHOST_TYPE_RIVAL_AVERAGE = 9
+
+    GAME_GHOST_LENGTH = 64
+
+    GAME_SP_DAN_RANK_7_KYU = 0
+    GAME_SP_DAN_RANK_6_KYU = 1
+    GAME_SP_DAN_RANK_5_KYU = 2
+    GAME_SP_DAN_RANK_4_KYU = 3
+    GAME_SP_DAN_RANK_3_KYU = 4
+    GAME_SP_DAN_RANK_2_KYU = 5
+    GAME_SP_DAN_RANK_1_KYU = 6
+    GAME_SP_DAN_RANK_1_DAN = 7
+    GAME_SP_DAN_RANK_2_DAN = 8
+    GAME_SP_DAN_RANK_3_DAN = 9
+    GAME_SP_DAN_RANK_4_DAN = 10
+    GAME_SP_DAN_RANK_5_DAN = 11
+    GAME_SP_DAN_RANK_6_DAN = 12
+    GAME_SP_DAN_RANK_7_DAN = 13
+    GAME_SP_DAN_RANK_8_DAN = 14
+    GAME_SP_DAN_RANK_9_DAN = 15
+    GAME_SP_DAN_RANK_10_DAN = 16
+    GAME_SP_DAN_RANK_KAIDEN = 17
+
+    GAME_DP_DAN_RANK_5_KYU = 0
+    GAME_DP_DAN_RANK_4_KYU = 1
+    GAME_DP_DAN_RANK_3_KYU = 2
+    GAME_DP_DAN_RANK_2_KYU = 3
+    GAME_DP_DAN_RANK_1_KYU = 4
+    GAME_DP_DAN_RANK_1_DAN = 5
+    GAME_DP_DAN_RANK_2_DAN = 6
+    GAME_DP_DAN_RANK_3_DAN = 7
+    GAME_DP_DAN_RANK_4_DAN = 8
+    GAME_DP_DAN_RANK_5_DAN = 9
+    GAME_DP_DAN_RANK_6_DAN = 10
+    GAME_DP_DAN_RANK_7_DAN = 11
+    GAME_DP_DAN_RANK_8_DAN = 12
+    GAME_DP_DAN_RANK_9_DAN = 13
+    GAME_DP_DAN_RANK_10_DAN = 14
+    GAME_DP_DAN_RANK_KAIDEN = 15
+
+    FAVORITE_LIST_LENGTH = 20
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXSpada(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert dailies into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'daily_charts', 'daily'):
+            # Generate a new list of three dailies.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = list(set([song.id for song in data.local.music.get_all_songs(cls.game, cls.version)]))
+            daily_songs = random.sample(all_songs, 3)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'dailies',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': daily_songs,
+                },
+            )
+            events.append((
+                'iidx_daily_charts',
+                {
+                    'version': cls.version,
+                    'music': daily_songs,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'daily_charts', 'daily')
+        return events
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Global Shop Ranking',
+                    'tip': 'Return network-wide ranking instead of shop ranking on results screen.',
+                    'category': 'game_config',
+                    'setting': 'global_shop_ranking',
+                },
+                {
+                    'name': 'Events In Omnimix',
+                    'tip': 'Allow events to be enabled at all for Omnimix.',
+                    'category': 'game_config',
+                    'setting': 'omnimix_events_enabled',
+                },
+            ],
+            'ints': [
+                {
+                    'name': 'Present/Future Cycle',
+                    'tip': 'Override server defaults for present/future cycle.',
+                    'category': 'game_config',
+                    'setting': 'cycle_config',
+                    'values': {
+                        0: 'Standard Rotation',
+                        1: 'Swap Present/Future',
+                        2: 'Force Present',
+                        3: 'Force Future',
+                    }
+                },
+            ],
+        }
+
+    def handle_IIDX22shop_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getname':
+            root = Node.void('IIDX22shop')
+            root.set_attribute('cls_opt', '0')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            root.set_attribute('opname', machine.name)
+            root.set_attribute('pid', '51')
+            return root
+
+        if method == 'savename':
+            self.update_machine_name(request.attribute('opname'))
+            root = Node.void('IIDX22shop')
+            return root
+
+        if method == 'sentinfo':
+            root = Node.void('IIDX22shop')
+            return root
+
+        if method == 'getconvention':
+            root = Node.void('IIDX22shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            root.set_attribute('music_0', str(course.get_int('music_0', 20032)))
+            root.set_attribute('music_1', str(course.get_int('music_1', 20009)))
+            root.set_attribute('music_2', str(course.get_int('music_2', 20015)))
+            root.set_attribute('music_3', str(course.get_int('music_3', 20064)))
+            root.add_child(Node.bool('valid', course.get_bool('valid')))
+            return root
+
+        if method == 'setconvention':
+            root = Node.void('IIDX22shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = ValidatedDict()
+                course.replace_int('music_0', request.child_value('music_0'))
+                course.replace_int('music_1', request.child_value('music_1'))
+                course.replace_int('music_2', request.child_value('music_2'))
+                course.replace_int('music_3', request.child_value('music_3'))
+                course.replace_bool('valid', request.child_value('valid'))
+                self.data.local.machine.put_settings(machine.arcade, self.game, self.music_version, 'shop_course', course)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX22ranking_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getranker':
+            root = Node.void('IIDX22ranking')
+            chart = int(request.attribute('clid'))
+            if chart not in [
+                self.CHART_TYPE_N7,
+                self.CHART_TYPE_H7,
+                self.CHART_TYPE_A7,
+                self.CHART_TYPE_N14,
+                self.CHART_TYPE_H14,
+                self.CHART_TYPE_A14,
+            ]:
+                # Chart type 6 is presumably beginner mode, but it crashes the game
+                return root
+
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            if not course.get_bool('valid'):
+                # Shop course not enabled or not present
+                return root
+
+            convention = Node.void('convention')
+            root.add_child(convention)
+            convention.set_attribute('clid', str(chart))
+            convention.set_attribute('update_date', str(Time.now() * 1000))
+
+            # Grab all scores for each of the four songs, filter out people who haven't
+            # set us as their arcade and then return the top 20 scores (adding all 4 songs).
+            songids = [
+                course.get_int('music_0'),
+                course.get_int('music_1'),
+                course.get_int('music_2'),
+                course.get_int('music_3'),
+            ]
+
+            totalscores: Dict[UserID, int] = {}
+            profiles: Dict[UserID, ValidatedDict] = {}
+            for songid in songids:
+                scores = self.data.local.music.get_all_scores(
+                    self.game,
+                    self.music_version,
+                    songid=songid,
+                    songchart=chart,
+                )
+
+                for score in scores:
+                    if score[0] not in totalscores:
+                        totalscores[score[0]] = 0
+                        profile = self.get_any_profile(score[0])
+                        if profile is None:
+                            profile = ValidatedDict()
+                        profiles[score[0]] = profile
+
+                    totalscores[score[0]] += score[1].points
+
+            topscores = sorted(
+                [
+                    (totalscores[userid], profiles[userid])
+                    for userid in totalscores
+                    if self.user_joined_arcade(machine, profiles[userid])
+                ],
+                key=lambda tup: tup[0],
+                reverse=True,
+            )[:20]
+
+            rank = 0
+            for topscore in topscores:
+                rank = rank + 1
+
+                detail = Node.void('detail')
+                convention.add_child(detail)
+                detail.set_attribute('name', topscore[1].get_str('name'))
+                detail.set_attribute('rank', str(rank))
+                detail.set_attribute('score', str(topscore[0]))
+                detail.set_attribute('pid', str(topscore[1].get_int('pid')))
+
+                qpro = topscore[1].get_dict('qpro')
+                detail.set_attribute('head', str(qpro.get_int('head')))
+                detail.set_attribute('hair', str(qpro.get_int('hair')))
+                detail.set_attribute('face', str(qpro.get_int('face')))
+                detail.set_attribute('body', str(qpro.get_int('body')))
+                detail.set_attribute('hand', str(qpro.get_int('hand')))
+
+            return root
+
+        if method == 'entry':
+            extid = int(request.attribute('iidxid'))
+            courseid = int(request.attribute('coid'))
+            chart = int(request.attribute('clid'))
+            course_type = int(request.attribute('regist_type'))
+            clear_status = self.game_to_db_status(int(request.attribute('clr')))
+            pgreats = int(request.attribute('pgnum'))
+            greats = int(request.attribute('gnum'))
+
+            if course_type == 0:
+                index = self.COURSE_TYPE_INTERNET_RANKING
+            elif course_type == 1:
+                index = self.COURSE_TYPE_SECRET
+            else:
+                raise Exception('Unknown registration type for course entry!')
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                # Update achievement to track course statistics
+                self.update_course(
+                    userid,
+                    index,
+                    courseid,
+                    chart,
+                    clear_status,
+                    pgreats,
+                    greats,
+                )
+
+            # We should return the user's position, but its not displayed anywhere
+            # so fuck it.
+            root = Node.void('IIDX22ranking')
+            root.set_attribute('anum', '1')
+            root.set_attribute('jun', '1')
+            return root
+
+        # Invalid method
+        return None
+
+    def db_to_game_status(self, db_status: int) -> int:
+        return {
+            self.CLEAR_STATUS_NO_PLAY: self.GAME_CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED: self.GAME_CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR: self.GAME_CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR: self.GAME_CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR: self.GAME_CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR: self.GAME_CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR: self.GAME_CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO: self.GAME_CLEAR_STATUS_FULL_COMBO,
+        }[db_status]
+
+    def game_to_db_status(self, game_status: int) -> int:
+        return {
+            self.GAME_CLEAR_STATUS_NO_PLAY: self.CLEAR_STATUS_NO_PLAY,
+            self.GAME_CLEAR_STATUS_FAILED: self.CLEAR_STATUS_FAILED,
+            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.GAME_CLEAR_STATUS_EASY_CLEAR: self.CLEAR_STATUS_EASY_CLEAR,
+            self.GAME_CLEAR_STATUS_CLEAR: self.CLEAR_STATUS_CLEAR,
+            self.GAME_CLEAR_STATUS_HARD_CLEAR: self.CLEAR_STATUS_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_FULL_COMBO: self.CLEAR_STATUS_FULL_COMBO,
+        }[game_status]
+
+    def db_to_game_rank(self, db_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if db_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_SP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_SP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_SP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_SP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_SP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_SP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_SP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_SP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_SP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_SP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_SP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_SP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_SP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_SP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_SP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_SP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_SP_DAN_RANK_10_DAN,
+                self.DAN_RANK_KAIDEN: self.GAME_SP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.DAN_RANK_5_KYU: self.GAME_DP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_DP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_DP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_DP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_DP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_DP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_DP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_DP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_DP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_DP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_DP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_DP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_DP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_DP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_DP_DAN_RANK_10_DAN,
+                self.DAN_RANK_KAIDEN: self.GAME_DP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def game_to_db_rank(self, game_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if game_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.GAME_SP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_SP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_SP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_SP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_SP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_SP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_SP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_SP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_SP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_SP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_SP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_SP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_SP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_SP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_SP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_SP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_SP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_SP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.GAME_DP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_DP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_DP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_DP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_DP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_DP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_DP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_DP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_DP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_DP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_DP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_DP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_DP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_DP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_DP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_DP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def handle_IIDX22music_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'crate':
+            root = Node.void('IIDX22music')
+            attempts = self.get_clear_rates()
+
+            all_songs = list(set([song.id for song in self.data.local.music.get_all_songs(self.game, self.music_version)]))
+            for song in all_songs:
+                clears = []
+                fcs = []
+
+                for chart in [0, 1, 2, 3, 4, 5]:
+                    placed = False
+                    if song in attempts and chart in attempts[song]:
+                        values = attempts[song][chart]
+                        if values['total'] > 0:
+                            clears.append(int((100 * values['clears']) / values['total']))
+                            fcs.append(int((100 * values['fcs']) / values['total']))
+                            placed = True
+                    if not placed:
+                        clears.append(101)
+                        fcs.append(101)
+
+                clearnode = Node.u8_array('c', clears + fcs)
+                clearnode.set_attribute('mid', str(song))
+                root.add_child(clearnode)
+
+            return root
+
+        if method == 'getrank':
+            cltype = int(request.attribute('cltype'))
+
+            root = Node.void('IIDX22music')
+            style = Node.void('style')
+            root.add_child(style)
+            style.set_attribute('type', str(cltype))
+
+            for rivalid in [-1, 0, 1, 2, 3, 4]:
+                if rivalid == -1:
+                    attr = 'iidxid'
+                else:
+                    attr = 'iidxid{}'.format(rivalid)
+
+                try:
+                    extid = int(request.attribute(attr))
+                except Exception:
+                    # Invalid extid
+                    continue
+
+                userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if userid is not None:
+                    scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+
+                    # Grab score data for user/rival
+                    scoredata = self.make_score_struct(
+                        scores,
+                        self.CLEAR_TYPE_SINGLE if cltype == self.GAME_CLTYPE_SINGLE else self.CLEAR_TYPE_DOUBLE,
+                        rivalid,
+                    )
+                    for s in scoredata:
+                        root.add_child(Node.s16_array('m', s))
+
+                    # Grab most played for user/rival
+                    most_played = [
+                        play[0] for play in
+                        self.data.local.music.get_most_played(self.game, self.music_version, userid, 20)
+                    ]
+                    if len(most_played) < 20:
+                        most_played.extend([0] * (20 - len(most_played)))
+                    best = Node.u16_array('best', most_played)
+                    best.set_attribute('rno', str(rivalid))
+                    root.add_child(best)
+
+                    if rivalid == -1:
+                        # Grab beginner statuses for user only
+                        beginnerdata = self.make_beginner_struct(scores)
+                        for b in beginnerdata:
+                            root.add_child(Node.u16_array('b', b))
+
+            return root
+
+        if method == 'reg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            # See if we need to report global or shop scores
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                global_scores = game_config.get_bool('global_shop_ranking')
+                machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            else:
+                # If we aren't in an arcade, we can only show global scores
+                global_scores = True
+                machine = None
+
+            # First, determine our current ranking before saving the new score
+            all_scores = sorted(
+                self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                key=lambda s: (s[1].points, s[1].timestamp),
+                reverse=True,
+            )
+            all_players = {
+                uid: prof for (uid, prof) in
+                self.get_any_profiles([s[0] for s in all_scores])
+            }
+
+            if not global_scores:
+                all_scores = [
+                    score for score in all_scores
+                    if (
+                        score[0] == userid or
+                        self.user_joined_arcade(machine, all_players[score[0]])
+                    )
+                ]
+
+            # Find our actual index
+            oldindex = None
+            for i in range(len(all_scores)):
+                if all_scores[i][0] == userid:
+                    oldindex = i
+                    break
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+                miss_count = int(request.attribute('mnum'))
+                ghost = request.child_value('ghost')
+                shopid = ID.parse_machine_id(request.attribute('shopconvid'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    chart,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    miss_count,
+                    ghost,
+                    shopid,
+                )
+
+            # Calculate and return statistics about this song
+            root = Node.void('IIDX22music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+            root.set_attribute('rankside', '0')
+
+            if userid is not None:
+                # Shop ranking
+                shopdata = Node.void('shopdata')
+                root.add_child(shopdata)
+                shopdata.set_attribute('rank', '-1' if oldindex is None else str(oldindex + 1))
+
+                # Grab the rank of some other players on this song
+                ranklist = Node.void('ranklist')
+                root.add_child(ranklist)
+
+                all_scores = sorted(
+                    self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: (s[1].points, s[1].timestamp),
+                    reverse=True,
+                )
+                missing_players = [
+                    uid for (uid, _) in all_scores
+                    if uid not in all_players
+                ]
+                for (uid, prof) in self.get_any_profiles(missing_players):
+                    all_players[uid] = prof
+
+                if not global_scores:
+                    all_scores = [
+                        score for score in all_scores
+                        if (
+                            score[0] == userid or
+                            self.user_joined_arcade(machine, all_players[score[0]])
+                        )
+                    ]
+
+                # Find our actual index
+                ourindex = None
+                for i in range(len(all_scores)):
+                    if all_scores[i][0] == userid:
+                        ourindex = i
+                        break
+                if ourindex is None:
+                    raise Exception('Cannot find our own score after saving to DB!')
+                start = ourindex - 4
+                end = ourindex + 4
+                if start < 0:
+                    start = 0
+                if end >= len(all_scores):
+                    end = len(all_scores) - 1
+                relevant_scores = all_scores[start:(end + 1)]
+
+                record_num = start + 1
+                for score in relevant_scores:
+                    profile = all_players[score[0]]
+
+                    data = Node.void('data')
+                    ranklist.add_child(data)
+                    data.set_attribute('iidx_id', str(profile.get_int('extid')))
+                    data.set_attribute('name', profile.get_str('name'))
+
+                    machine_name = ''
+                    if 'shop_location' in profile:
+                        shop_id = profile.get_int('shop_location')
+                        machine = self.get_machine_by_id(shop_id)
+                        if machine is not None:
+                            machine_name = machine.name
+                    data.set_attribute('opname', machine_name)
+                    data.set_attribute('rnum', str(record_num))
+                    data.set_attribute('score', str(score[1].points))
+                    data.set_attribute('clflg', str(self.db_to_game_status(score[1].data.get_int('clear_status'))))
+                    data.set_attribute('pid', str(profile.get_int('pid')))
+                    data.set_attribute('myFlg', '1' if score[0] == userid else '0')
+                    data.set_attribute('update', '0')
+
+                    data.set_attribute('sgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE),
+                    ))
+                    data.set_attribute('dgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE),
+                    ))
+
+                    qpro = profile.get_dict('qpro')
+                    data.set_attribute('head', str(qpro.get_int('head')))
+                    data.set_attribute('hair', str(qpro.get_int('hair')))
+                    data.set_attribute('face', str(qpro.get_int('face')))
+                    data.set_attribute('body', str(qpro.get_int('body')))
+                    data.set_attribute('hand', str(qpro.get_int('hand')))
+
+                    record_num = record_num + 1
+
+            return root
+
+        if method == 'breg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    self.CHART_TYPE_B7,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    -1,
+                    b'',
+                    None,
+                )
+
+            # Return nothing.
+            root = Node.void('IIDX22music')
+            return root
+
+        if method == 'play':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+
+            self.update_score(
+                None,  # No userid since its anonymous
+                musicid,
+                chart,
+                clear_status,
+                0,  # No ex score
+                0,  # No ex score
+                0,  # No miss count
+                None,  # No ghost
+                None,  # No shop for this user
+            )
+
+            # Calculate and return statistics about this song
+            root = Node.void('IIDX22music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+
+            return root
+
+        if method == 'appoint':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            ghost_type = int(request.attribute('ctype'))
+            extid = int(request.attribute('iidxid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            root = Node.void('IIDX22music')
+
+            if userid is not None:
+                # Try to look up previous ghost for user
+                my_score = self.data.remote.music.get_score(self.game, self.music_version, userid, musicid, chart)
+                if my_score is not None:
+                    mydata = Node.binary('mydata', my_score.data.get_bytes('ghost'))
+                    mydata.set_attribute('score', str(my_score.points))
+                    root.add_child(mydata)
+
+                ghost_score = self.get_ghost(
+                    {
+                        self.GAME_GHOST_TYPE_RIVAL: self.GHOST_TYPE_RIVAL,
+                        self.GAME_GHOST_TYPE_GLOBAL_TOP: self.GHOST_TYPE_GLOBAL_TOP,
+                        self.GAME_GHOST_TYPE_GLOBAL_AVERAGE: self.GHOST_TYPE_GLOBAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_LOCAL_TOP: self.GHOST_TYPE_LOCAL_TOP,
+                        self.GAME_GHOST_TYPE_LOCAL_AVERAGE: self.GHOST_TYPE_LOCAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_DAN_TOP: self.GHOST_TYPE_DAN_TOP,
+                        self.GAME_GHOST_TYPE_DAN_AVERAGE: self.GHOST_TYPE_DAN_AVERAGE,
+                        self.GAME_GHOST_TYPE_RIVAL_TOP: self.GHOST_TYPE_RIVAL_TOP,
+                        self.GAME_GHOST_TYPE_RIVAL_AVERAGE: self.GHOST_TYPE_RIVAL_AVERAGE,
+                    }.get(ghost_type, self.GHOST_TYPE_NONE),
+                    request.attribute('subtype'),
+                    self.GAME_GHOST_LENGTH,
+                    musicid,
+                    chart,
+                    userid,
+                )
+
+                # Add ghost score if we support it
+                if ghost_score is not None:
+                    sdata = Node.binary('sdata', ghost_score['ghost'])
+                    sdata.set_attribute('score', str(ghost_score['score']))
+                    if 'name' in ghost_score:
+                        sdata.set_attribute('name', ghost_score['name'])
+                    if 'pid' in ghost_score:
+                        sdata.set_attribute('pid', str(ghost_score['pid']))
+                    if 'extid' in ghost_score:
+                        sdata.set_attribute('riidxid', str(ghost_score['extid']))
+                    root.add_child(sdata)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX22grade_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'raised':
+            extid = int(request.attribute('iidxid'))
+            cltype = int(request.attribute('gtype'))
+            rank = self.game_to_db_rank(int(request.attribute('gid')), cltype)
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                percent = int(request.attribute('achi'))
+                stages_cleared = int(request.attribute('cflg'))
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    max_stages = self.DAN_STAGES_SINGLE
+                else:
+                    max_stages = self.DAN_STAGES_DOUBLE
+                cleared = stages_cleared == max_stages
+
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    index = self.DAN_RANKING_SINGLE
+                else:
+                    index = self.DAN_RANKING_DOUBLE
+
+                self.update_rank(
+                    userid,
+                    index,
+                    rank,
+                    percent,
+                    cleared,
+                    stages_cleared,
+                )
+
+            # Figure out number of players that played this ranking
+            all_achievements = self.data.local.user.get_all_achievements(self.game, self.version)
+            num_players = 0
+            for [_, ach] in all_achievements:
+                if ach.type != index:
+                    continue
+                if ach.id != rank:
+                    continue
+                num_players = num_players + 1
+
+            root = Node.void('IIDX22grade')
+            root.set_attribute('pnum', str(num_players))
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX22pc_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'common':
+            root = Node.void('IIDX22pc')
+            root.set_attribute('expire', '600')
+
+            # TODO: Hook all of these up to config options I guess?
+            ir = Node.void('ir')
+            root.add_child(ir)
+            ir.set_attribute('beat', '2')
+
+            newsong_another = Node.void('newsong_another')
+            root.add_child(newsong_another)
+            newsong_another.set_attribute('open', '1')
+
+            limit = Node.void('limit')
+            root.add_child(limit)
+            limit.set_attribute('phase', '24')
+
+            # See if we configured event overrides
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                timeshift_override = game_config.get_int('cycle_config')
+                omni_events = game_config.get_bool('omnimix_events_enabled')
+            else:
+                # If we aren't in an arcade, we turn off events
+                timeshift_override = 0
+                omni_events = False
+
+            if self.omnimix and (not omni_events):
+                boss_phase = 0
+            else:
+                # TODO: Figure out what these map to
+                boss_phase = 0
+
+            boss = Node.void('boss')
+            root.add_child(boss)
+            boss.set_attribute('phase', str(boss_phase))
+
+            chrono_diver = Node.void('chrono_diver')
+            root.add_child(chrono_diver)
+            chrono_diver.set_attribute('phase', '3')
+
+            qpronicle_chord = Node.void('qpronicle_chord')
+            root.add_child(qpronicle_chord)
+            qpronicle_chord.set_attribute('phase', '2')
+
+            common_cd_event = Node.void('common_cd_event')
+            root.add_child(common_cd_event)
+            common_cd_event.set_attribute('open_list', '3')
+
+            pre_play = Node.void('pre_play')
+            root.add_child(pre_play)
+            pre_play.set_attribute('phase', '3')
+
+            vip_black_pass = Node.void('vip_pass_black')
+            root.add_child(vip_black_pass)
+
+            # Course definitions
+            courses: List[Dict[str, Any]] = [
+                {
+                    'name': 'VOCAL',
+                    'id': 1,
+                    'songs': [
+                        22027,
+                        20037,
+                        20015,
+                        21037,
+                    ],
+                },
+                {
+                    'name': 'ELECTRO',
+                    'id': 2,
+                    'songs': [
+                        20068,
+                        20065,
+                        21051,
+                        22002,
+                    ],
+                },
+                {
+                    'name': 'CORE',
+                    'id': 3,
+                    'songs': [
+                        22040,
+                        20048,
+                        22057,
+                        21019,
+                    ],
+                },
+                {
+                    'name': 'COMPILATION',
+                    'id': 4,
+                    'songs': [
+                        22078,
+                        21070,
+                        21044,
+                        22080,
+                    ],
+                },
+                {
+                    'name': 'CHARGE',
+                    'id': 5,
+                    'songs': [
+                        20017,
+                        20053,
+                        21007,
+                        22044,
+                    ],
+                },
+                {
+                    'name': 'NEKOMATA',
+                    'id': 6,
+                    'songs': [
+                        16042,
+                        20013,
+                        22014,
+                        21004,
+                    ],
+                },
+                {
+                    'name': 'L.E.D.',
+                    'id': 7,
+                    'songs': [
+                        18008,
+                        19063,
+                        17064,
+                        19068,
+                    ],
+                },
+                {
+                    'name': 'LOW SPEED',
+                    'id': 8,
+                    'songs': [
+                        18000,
+                        18011,
+                        13026,
+                        9039,
+                    ],
+                },
+                {
+                    'name': 'HIGH SPEED',
+                    'id': 9,
+                    'songs': [
+                        19009,
+                        19022,
+                        12002,
+                        12020,
+                    ],
+                },
+                {
+                    'name': 'DRAGON',
+                    'id': 10,
+                    'songs': [
+                        22003,
+                        21007,
+                        13038,
+                        16026,
+                    ],
+                },
+                {
+                    'name': 'LEGEND',
+                    'id': 11,
+                    'songs': [
+                        18004,
+                        22054,
+                        19002,
+                        12004,
+                    ],
+                },
+            ]
+
+            # Secret course definitions
+            secret_courses: List[Dict[str, Any]] = [
+                {
+                    'name': 'KAC FINAL',
+                    'id': 1,
+                    'songs': [
+                        19037,
+                        18032,
+                        22073,
+                        22054,
+                    ],
+                },
+                {
+                    'name': 'Yossy',
+                    'id': 2,
+                    'songs': [
+                        10033,
+                        13037,
+                        15024,
+                        22056,
+                    ],
+                },
+                {
+                    'name': 'TOHO REMIX',
+                    'id': 3,
+                    'songs': [
+                        22085,
+                        22086,
+                        22084,
+                        22083,
+                    ],
+                },
+                {
+                    'name': 'VS RHYZE SIDE P',
+                    'id': 4,
+                    'songs': [
+                        14031,
+                        21077,
+                        21024,
+                        22033,
+                    ],
+                },
+                {
+                    'name': 'VS RHYZE SIDE T',
+                    'id': 5,
+                    'songs': [
+                        5021,
+                        20063,
+                        17054,
+                        22053,
+                    ],
+                },
+                {
+                    'name': 'kors k',
+                    'id': 6,
+                    'songs': [
+                        19025,
+                        16021,
+                        16023,
+                        22005,
+                    ],
+                },
+                {
+                    'name': 'Eagle',
+                    'id': 7,
+                    'songs': [
+                        21043,
+                        20035,
+                        15023,
+                        22007,
+                    ],
+                },
+            ]
+
+            # For some reason, pendual omnimix crashes on course mode, so don't enable it
+            if not self.omnimix:
+                internet_ranking = Node.void('internet_ranking')
+                root.add_child(internet_ranking)
+
+                used_ids: List[int] = []
+                for c in courses:
+                    if c['id'] in used_ids:
+                        raise Exception('Cannot have multiple courses with the same ID!')
+                    elif c['id'] < 0 or c['id'] >= 20:
+                        raise Exception('Course ID is out of bounds!')
+                    else:
+                        used_ids.append(c['id'])
+                    course = Node.void('course')
+                    internet_ranking.add_child(course)
+                    course.set_attribute('opflg', '1')
+                    course.set_attribute('course_id', str(c['id']))
+                    course.set_attribute('mid0', str(c['songs'][0]))
+                    course.set_attribute('mid1', str(c['songs'][1]))
+                    course.set_attribute('mid2', str(c['songs'][2]))
+                    course.set_attribute('mid3', str(c['songs'][3]))
+                    course.set_attribute('name', c['name'])
+
+                secret_ex_course = Node.void('secret_ex_course')
+                root.add_child(secret_ex_course)
+
+                used_secret_ids: List[int] = []
+                for c in secret_courses:
+                    if c['id'] in used_secret_ids:
+                        raise Exception('Cannot have multiple secret courses with the same ID!')
+                    elif c['id'] < 0 or c['id'] >= 10:
+                        raise Exception('Secret course ID is out of bounds!')
+                    else:
+                        used_secret_ids.append(c['id'])
+                    course = Node.void('course')
+                    secret_ex_course.add_child(course)
+                    course.set_attribute('course_id', str(c['id']))
+                    course.set_attribute('mid0', str(c['songs'][0]))
+                    course.set_attribute('mid1', str(c['songs'][1]))
+                    course.set_attribute('mid2', str(c['songs'][2]))
+                    course.set_attribute('mid3', str(c['songs'][3]))
+                    course.set_attribute('name', c['name'])
+
+                expert = Node.void('expert')
+                root.add_child(expert)
+                expert.set_attribute('phase', '1')
+
+                expert_random_select = Node.void('expert_random_select')
+                root.add_child(expert_random_select)
+                expert_random_select.set_attribute('phase', '1')
+
+                expert_full = Node.void('expert_secret_full_open')
+                root.add_child(expert_full)
+
+            day_start, _ = self.data.local.network.get_schedule_duration('daily')
+            days_since_epoch = int(day_start / 86400)
+            common_timeshift_phase = Node.void('common_timeshift_phase')
+            root.add_child(common_timeshift_phase)
+            if timeshift_override == 0:
+                common_timeshift_phase.set_attribute('phase', '1' if (days_since_epoch % 2) == 0 else '2')
+            elif timeshift_override == 1:
+                common_timeshift_phase.set_attribute('phase', '2' if (days_since_epoch % 2) == 0 else '1')
+            elif timeshift_override == 2:
+                common_timeshift_phase.set_attribute('phase', '1')
+            elif timeshift_override == 3:
+                common_timeshift_phase.set_attribute('phase', '2')
+
+            return root
+
+        if method == 'delete':
+            return Node.void('IIDX22pc')
+
+        if method == 'playstart':
+            return Node.void('IIDX22pc')
+
+        if method == 'playend':
+            return Node.void('IIDX22pc')
+
+        if method == 'oldget':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+
+            root = Node.void('IIDX22pc')
+            root.set_attribute('status', '1' if profile is None else '0')
+            return root
+
+        if method == 'getname':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+            if profile is None:
+                raise Exception(
+                    'Should not get here if we have no profile, we should ' +
+                    'have returned \'1\' in the \'oldget\' method above ' +
+                    'which should tell the game not to present a migration.'
+                )
+
+            root = Node.void('IIDX22pc')
+            root.set_attribute('name', profile.get_str('name'))
+            root.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+            root.set_attribute('pid', str(profile.get_int('pid')))
+            return root
+
+        if method == 'takeover':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            newprofile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('IIDX22pc')
+            if newprofile is not None:
+                root.set_attribute('id', str(newprofile.get_int('extid')))
+            return root
+
+        if method == 'reg':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            profile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('IIDX22pc')
+            if profile is not None:
+                root.set_attribute('id', str(profile.get_int('extid')))
+                root.set_attribute('id_str', ID.format_extid(profile.get_int('extid')))
+            return root
+
+        if method == 'get':
+            refid = request.attribute('rid')
+            root = self.get_profile_by_refid(refid)
+            if root is None:
+                root = Node.void('IIDX22pc')
+            return root
+
+        if method == 'save':
+            extid = int(request.attribute('iidxid'))
+            self.put_profile_by_extid(extid, request)
+
+            root = Node.void('IIDX22pc')
+            return root
+
+        if method == 'visit':
+            root = Node.void('IIDX22pc')
+            root.set_attribute('anum', '0')
+            root.set_attribute('pnum', '0')
+            root.set_attribute('sflg', '0')
+            root.set_attribute('pflg', '0')
+            root.set_attribute('aflg', '0')
+            root.set_attribute('snum', '0')
+            return root
+
+        if method == 'shopregister':
+            extid = int(request.child_value('iidx_id'))
+            location = ID.parse_machine_id(request.child_value('location_id'))
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                profile = self.get_profile(userid)
+                if profile is None:
+                    profile = ValidatedDict()
+                profile.replace_int('shop_location', location)
+                self.put_profile(userid, profile)
+
+            root = Node.void('IIDX22pc')
+            return root
+
+        # Invalid method
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('IIDX22pc')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Look up judge window adjustments
+        judge_dict = profile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+
+        # Profile data
+        pcdata = Node.void('pcdata')
+        root.add_child(pcdata)
+        pcdata.set_attribute('id', str(profile.get_int('extid')))
+        pcdata.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+        pcdata.set_attribute('name', profile.get_str('name'))
+        pcdata.set_attribute('pid', str(profile.get_int('pid')))
+        pcdata.set_attribute('spnum', str(play_stats.get_int('single_plays')))
+        pcdata.set_attribute('dpnum', str(play_stats.get_int('double_plays')))
+        pcdata.set_attribute('sach', str(play_stats.get_int('single_dj_points')))
+        pcdata.set_attribute('dach', str(play_stats.get_int('double_dj_points')))
+        pcdata.set_attribute('mode', str(profile.get_int('mode')))
+        pcdata.set_attribute('pmode', str(profile.get_int('pmode')))
+        pcdata.set_attribute('rtype', str(profile.get_int('rtype')))
+        pcdata.set_attribute('sp_opt', str(profile.get_int('sp_opt')))
+        pcdata.set_attribute('dp_opt', str(profile.get_int('dp_opt')))
+        pcdata.set_attribute('dp_opt2', str(profile.get_int('dp_opt2')))
+        pcdata.set_attribute('gpos', str(profile.get_int('gpos')))
+        pcdata.set_attribute('s_sorttype', str(profile.get_int('s_sorttype')))
+        pcdata.set_attribute('d_sorttype', str(profile.get_int('d_sorttype')))
+        pcdata.set_attribute('s_pace', str(profile.get_int('s_pace')))
+        pcdata.set_attribute('d_pace', str(profile.get_int('d_pace')))
+        pcdata.set_attribute('s_gno', str(profile.get_int('s_gno')))
+        pcdata.set_attribute('d_gno', str(profile.get_int('d_gno')))
+        pcdata.set_attribute('s_gtype', str(profile.get_int('s_gtype')))
+        pcdata.set_attribute('d_gtype', str(profile.get_int('d_gtype')))
+        pcdata.set_attribute('s_sdlen', str(profile.get_int('s_sdlen')))
+        pcdata.set_attribute('d_sdlen', str(profile.get_int('d_sdlen')))
+        pcdata.set_attribute('s_sdtype', str(profile.get_int('s_sdtype')))
+        pcdata.set_attribute('d_sdtype', str(profile.get_int('d_sdtype')))
+        pcdata.set_attribute('s_timing', str(profile.get_int('s_timing')))
+        pcdata.set_attribute('d_timing', str(profile.get_int('d_timing')))
+        pcdata.set_attribute('s_notes', str(profile.get_float('s_notes')))
+        pcdata.set_attribute('d_notes', str(profile.get_float('d_notes')))
+        pcdata.set_attribute('s_judge', str(profile.get_int('s_judge')))
+        pcdata.set_attribute('d_judge', str(profile.get_int('d_judge')))
+        pcdata.set_attribute('s_judgeAdj', str(machine_judge.get_int('single')))
+        pcdata.set_attribute('d_judgeAdj', str(machine_judge.get_int('double')))
+        pcdata.set_attribute('s_hispeed', str(profile.get_float('s_hispeed')))
+        pcdata.set_attribute('d_hispeed', str(profile.get_float('d_hispeed')))
+        pcdata.set_attribute('s_liflen', str(profile.get_int('s_lift')))
+        pcdata.set_attribute('d_liflen', str(profile.get_int('d_lift')))
+        pcdata.set_attribute('s_disp_judge', str(profile.get_int('s_disp_judge')))
+        pcdata.set_attribute('d_disp_judge', str(profile.get_int('d_disp_judge')))
+        pcdata.set_attribute('s_opstyle', str(profile.get_int('s_opstyle')))
+        pcdata.set_attribute('d_opstyle', str(profile.get_int('d_opstyle')))
+        pcdata.set_attribute('s_exscore', str(profile.get_int('s_exscore')))
+        pcdata.set_attribute('d_exscore', str(profile.get_int('d_exscore')))
+        pcdata.set_attribute('s_largejudge', str(profile.get_int('s_largejudge')))
+        pcdata.set_attribute('d_largejudge', str(profile.get_int('d_largejudge')))
+
+        # If the user joined a particular shop, let the game know.
+        if 'shop_location' in profile:
+            shop_id = profile.get_int('shop_location')
+            machine = self.get_machine_by_id(shop_id)
+            if machine is not None:
+                join_shop = Node.void('join_shop')
+                root.add_child(join_shop)
+                join_shop.set_attribute('joinflg', '1')
+                join_shop.set_attribute('join_cflg', '1')
+                join_shop.set_attribute('join_id', ID.format_machine_id(machine.id))
+                join_shop.set_attribute('join_name', machine.name)
+
+        # Daily recommendations
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'dailies')
+        if entry is not None:
+            packinfo = Node.void('packinfo')
+            root.add_child(packinfo)
+
+            pack_id = int(entry['start_time'] / 86400)
+            packinfo.set_attribute('pack_id', str(pack_id))
+            packinfo.set_attribute('music_0', str(entry['music'][0]))
+            packinfo.set_attribute('music_1', str(entry['music'][1]))
+            packinfo.set_attribute('music_2', str(entry['music'][2]))
+        else:
+            # No dailies :(
+            pack_id = None
+
+        # Track deller
+        deller = Node.void('deller')
+        root.add_child(deller)
+        deller.set_attribute('deller', str(profile.get_int('deller')))
+        deller.set_attribute('rate', '0')
+
+        # Secret flags (shh!)
+        secret_dict = profile.get_dict('secret')
+        secret = Node.void('secret')
+        root.add_child(secret)
+        secret.add_child(Node.s64_array('flg1', secret_dict.get_int_array('flg1', 3)))
+        secret.add_child(Node.s64_array('flg2', secret_dict.get_int_array('flg2', 3)))
+        secret.add_child(Node.s64_array('flg3', secret_dict.get_int_array('flg3', 3)))
+
+        # Tran medals and shit
+        achievements = Node.void('achievements')
+        root.add_child(achievements)
+
+        # Dailies
+        if pack_id is None:
+            achievements.set_attribute('pack', '0')
+            achievements.set_attribute('pack_comp', '0')
+        else:
+            daily_played = self.data.local.user.get_achievement(self.game, self.version, userid, pack_id, 'daily')
+            if daily_played is None:
+                daily_played = ValidatedDict()
+            achievements.set_attribute('pack', str(daily_played.get_int('pack_flg')))
+            achievements.set_attribute('pack_comp', str(daily_played.get_int('pack_comp')))
+
+        # Weeklies
+        achievements.set_attribute('last_weekly', str(profile.get_int('last_weekly')))
+        achievements.set_attribute('weekly_num', str(profile.get_int('weekly_num')))
+
+        # Prefecture visit flag
+        achievements.set_attribute('visit_flg', str(profile.get_int('visit_flg')))
+
+        # Number of rivals beaten
+        achievements.set_attribute('rival_crush', str(profile.get_int('rival_crush')))
+
+        # Tran medals
+        achievements.add_child(Node.s64_array('trophy', profile.get_int_array('trophy', 10)))
+
+        # User settings
+        settings_dict = profile.get_dict('settings')
+        skin = Node.s16_array(
+            'skin',
+            [
+                settings_dict.get_int('frame'),
+                settings_dict.get_int('turntable'),
+                settings_dict.get_int('burst'),
+                settings_dict.get_int('bgm'),
+                settings_dict.get_int('flags'),
+                settings_dict.get_int('towel'),
+                settings_dict.get_int('judge_pos'),
+                settings_dict.get_int('voice'),
+                settings_dict.get_int('noteskin'),
+                settings_dict.get_int('full_combo'),
+                settings_dict.get_int('beam'),
+                settings_dict.get_int('judge'),
+                0,
+                settings_dict.get_int('disable_song_preview'),
+            ],
+        )
+        root.add_child(skin)
+
+        # DAN rankings
+        grade = Node.void('grade')
+        root.add_child(grade)
+        grade.set_attribute('sgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+        grade.set_attribute('dgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+        rankings = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for rank in rankings:
+            if rank.type == self.DAN_RANKING_SINGLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_SINGLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_SINGLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+            if rank.type == self.DAN_RANKING_DOUBLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_DOUBLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_DOUBLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+
+        # Expert courses
+        ir_data = Node.void('ir_data')
+        root.add_child(ir_data)
+        for rank in rankings:
+            if rank.type == self.COURSE_TYPE_INTERNET_RANKING:
+                ir_data.add_child(Node.s32_array('e', [
+                    int(rank.id / 6),  # course ID
+                    rank.id % 6,  # course chart
+                    self.db_to_game_status(rank.data.get_int('clear_status')),  # course clear status
+                    rank.data.get_int('pgnum'),  # flashing great count
+                    rank.data.get_int('gnum'),  # great count
+                ]))
+
+        secret_course_data = Node.void('secret_course_data')
+        root.add_child(secret_course_data)
+        for rank in rankings:
+            if rank.type == self.COURSE_TYPE_SECRET:
+                secret_course_data.add_child(Node.s32_array('e', [
+                    int(rank.id / 6),  # course ID
+                    rank.id % 6,  # course chart
+                    self.db_to_game_status(rank.data.get_int('clear_status')),  # course clear status
+                    rank.data.get_int('pgnum'),  # flashing great count
+                    rank.data.get_int('gnum'),  # great count
+                ]))
+
+        expert_point = Node.void('expert_point')
+        root.add_child(expert_point)
+        for rank in rankings:
+            if rank.type == 'expert_point':
+                detail = Node.void('detail')
+                expert_point.add_child(detail)
+                detail.set_attribute('course_id', str(rank.id))
+                detail.set_attribute('n_point', str(rank.data.get_int('normal_points')))
+                detail.set_attribute('h_point', str(rank.data.get_int('hyper_points')))
+                detail.set_attribute('a_point', str(rank.data.get_int('another_points')))
+
+        # Qpro data
+        qpro_dict = profile.get_dict('qpro')
+        root.add_child(Node.u32_array(
+            'qprodata',
+            [
+                qpro_dict.get_int('head'),
+                qpro_dict.get_int('hair'),
+                qpro_dict.get_int('face'),
+                qpro_dict.get_int('hand'),
+                qpro_dict.get_int('body'),
+            ],
+        ))
+
+        # Rivals
+        rlist = Node.void('rlist')
+        root.add_child(rlist)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            rival_type = None
+            if link.type == 'sp_rival':
+                rival_type = '1'
+            elif link.type == 'dp_rival':
+                rival_type = '2'
+            else:
+                # No business with this link type
+                continue
+
+            other_profile = self.get_profile(link.other_userid)
+            if other_profile is None:
+                continue
+            other_play_stats = self.get_play_statistics(link.other_userid)
+
+            rival = Node.void('rival')
+            rlist.add_child(rival)
+            rival.set_attribute('spdp', rival_type)
+            rival.set_attribute('id', str(other_profile.get_int('extid')))
+            rival.set_attribute('id_str', ID.format_extid(other_profile.get_int('extid')))
+            rival.set_attribute('djname', other_profile.get_str('name'))
+            rival.set_attribute('pid', str(other_profile.get_int('pid')))
+            rival.set_attribute('sg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+            rival.set_attribute('dg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+            rival.set_attribute('sa', str(other_play_stats.get_int('single_dj_points')))
+            rival.set_attribute('da', str(other_play_stats.get_int('double_dj_points')))
+
+            # If the user joined a particular shop, let the game know.
+            if 'shop_location' in other_profile:
+                shop_id = other_profile.get_int('shop_location')
+                machine = self.get_machine_by_id(shop_id)
+                if machine is not None:
+                    shop = Node.void('shop')
+                    rival.add_child(shop)
+                    shop.set_attribute('name', machine.name)
+
+            qprodata = Node.void('qprodata')
+            rival.add_child(qprodata)
+            qpro = other_profile.get_dict('qpro')
+            qprodata.set_attribute('head', str(qpro.get_int('head')))
+            qprodata.set_attribute('hair', str(qpro.get_int('hair')))
+            qprodata.set_attribute('face', str(qpro.get_int('face')))
+            qprodata.set_attribute('body', str(qpro.get_int('body')))
+            qprodata.set_attribute('hand', str(qpro.get_int('hand')))
+
+        # Step up mode
+        step_dict = profile.get_dict('step')
+        step = Node.void('step')
+        root.add_child(step)
+        step.set_attribute('damage', str(step_dict.get_int('damage')))
+        step.set_attribute('defeat', str(step_dict.get_int('defeat')))
+        step.set_attribute('progress', str(step_dict.get_int('progress')))
+        step.set_attribute('sp_mission', str(step_dict.get_int('sp_mission')))
+        step.set_attribute('dp_mission', str(step_dict.get_int('dp_mission')))
+        step.set_attribute('sp_level', str(step_dict.get_int('sp_level')))
+        step.set_attribute('dp_level', str(step_dict.get_int('dp_level')))
+        step.set_attribute('sp_mplay', str(step_dict.get_int('sp_mplay')))
+        step.set_attribute('dp_mplay', str(step_dict.get_int('dp_mplay')))
+        step.set_attribute('age_list', str(step_dict.get_int('age_list')))
+        step.set_attribute('is_secret', str(step_dict.get_int('is_secret')))
+        step.set_attribute('is_present', str(step_dict.get_int('is_present')))
+        step.set_attribute('is_future', str(step_dict.get_int('is_future')))
+        step.add_child(Node.binary('album', step_dict.get_bytes('album', b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')))
+
+        # Favorites
+        favorite = Node.void('favorite')
+        root.add_child(favorite)
+        favorite_dict = profile.get_dict('favorite')
+
+        sp_mlist = b''
+        sp_clist = b''
+        singles_list = favorite_dict['single'] if 'single' in favorite_dict else []
+        for single in singles_list:
+            sp_mlist = sp_mlist + struct.pack('<L', single['id'])
+            sp_clist = sp_clist + struct.pack('B', single['chart'])
+        while len(sp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+            sp_mlist = sp_mlist + b'\x00\x00\x00\x00'
+        while len(sp_clist) < self.FAVORITE_LIST_LENGTH:
+            sp_clist = sp_clist + b'\x00'
+
+        dp_mlist = b''
+        dp_clist = b''
+        doubles_list = favorite_dict['double'] if 'double' in favorite_dict else []
+        for double in doubles_list:
+            dp_mlist = dp_mlist + struct.pack('<L', double['id'])
+            dp_clist = dp_clist + struct.pack('B', double['chart'])
+        while len(dp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+            dp_mlist = dp_mlist + b'\x00\x00\x00\x00'
+        while len(dp_clist) < self.FAVORITE_LIST_LENGTH:
+            dp_clist = dp_clist + b'\x00'
+
+        favorite.add_child(Node.binary('sp_mlist', sp_mlist))
+        favorite.add_child(Node.binary('sp_clist', sp_clist))
+        favorite.add_child(Node.binary('dp_mlist', dp_mlist))
+        favorite.add_child(Node.binary('dp_clist', dp_clist))
+
+        # Orb data
+        orb_data = Node.void('orb_data')
+        root.add_child(orb_data)
+        orb_data.set_attribute('rest_orb', str(profile.get_int('orbs')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Track play counts
+        cltype = int(request.attribute('cltype'))
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            play_stats.increment_int('single_plays')
+        if cltype == self.GAME_CLTYPE_DOUBLE:
+            play_stats.increment_int('double_plays')
+
+        # Track DJ points
+        play_stats.replace_int('single_dj_points', int(request.attribute('s_achi')))
+        play_stats.replace_int('double_dj_points', int(request.attribute('d_achi')))
+
+        # Profile settings
+        newprofile.replace_int('mode', int(request.attribute('mode')))
+        newprofile.replace_int('pmode', int(request.attribute('pmode')))
+        newprofile.replace_int('rtype', int(request.attribute('rtype')))
+        newprofile.replace_int('s_lift', int(request.attribute('s_lift')))
+        newprofile.replace_int('d_lift', int(request.attribute('d_lift')))
+        newprofile.replace_int('sp_opt', int(request.attribute('sp_opt')))
+        newprofile.replace_int('dp_opt', int(request.attribute('dp_opt')))
+        newprofile.replace_int('dp_opt2', int(request.attribute('dp_opt2')))
+        newprofile.replace_int('gpos', int(request.attribute('gpos')))
+        newprofile.replace_int('s_sorttype', int(request.attribute('s_sorttype')))
+        newprofile.replace_int('d_sorttype', int(request.attribute('d_sorttype')))
+        newprofile.replace_int('s_pace', int(request.attribute('s_pace')))
+        newprofile.replace_int('d_pace', int(request.attribute('d_pace')))
+        newprofile.replace_int('s_gno', int(request.attribute('s_gno')))
+        newprofile.replace_int('d_gno', int(request.attribute('d_gno')))
+        newprofile.replace_int('s_gtype', int(request.attribute('s_gtype')))
+        newprofile.replace_int('d_gtype', int(request.attribute('d_gtype')))
+        newprofile.replace_int('s_sdlen', int(request.attribute('s_sdlen')))
+        newprofile.replace_int('d_sdlen', int(request.attribute('d_sdlen')))
+        newprofile.replace_int('s_sdtype', int(request.attribute('s_sdtype')))
+        newprofile.replace_int('d_sdtype', int(request.attribute('d_sdtype')))
+        newprofile.replace_int('s_timing', int(request.attribute('s_timing')))
+        newprofile.replace_int('d_timing', int(request.attribute('d_timing')))
+        newprofile.replace_float('s_notes', float(request.attribute('s_notes')))
+        newprofile.replace_float('d_notes', float(request.attribute('d_notes')))
+        newprofile.replace_int('s_judge', int(request.attribute('s_judge')))
+        newprofile.replace_int('d_judge', int(request.attribute('d_judge')))
+        newprofile.replace_float('s_hispeed', float(request.attribute('s_hispeed')))
+        newprofile.replace_float('d_hispeed', float(request.attribute('d_hispeed')))
+        newprofile.replace_int('s_disp_judge', int(request.attribute('s_disp_judge')))
+        newprofile.replace_int('d_disp_judge', int(request.attribute('d_disp_judge')))
+        newprofile.replace_int('s_opstyle', int(request.attribute('s_opstyle')))
+        newprofile.replace_int('d_opstyle', int(request.attribute('d_opstyle')))
+        newprofile.replace_int('s_exscore', int(request.attribute('s_exscore')))
+        newprofile.replace_int('d_exscore', int(request.attribute('d_exscore')))
+        newprofile.replace_int('s_largejudge', int(request.attribute('s_largejudge')))
+        newprofile.replace_int('d_largejudge', int(request.attribute('d_largejudge')))
+
+        # Update judge window adjustments per-machine
+        judge_dict = newprofile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+        machine_judge.replace_int('single', int(request.attribute('s_judgeAdj')))
+        machine_judge.replace_int('double', int(request.attribute('d_judgeAdj')))
+        judge_dict.replace_dict(self.config['machine']['pcbid'], machine_judge)
+        newprofile.replace_dict('machine_judge_adjust', judge_dict)
+
+        # Secret flags saving
+        secret = request.child('secret')
+        if secret is not None:
+            secret_dict = newprofile.get_dict('secret')
+            secret_dict.replace_int_array('flg1', 3, secret.child_value('flg1'))
+            secret_dict.replace_int_array('flg2', 3, secret.child_value('flg2'))
+            secret_dict.replace_int_array('flg3', 3, secret.child_value('flg3'))
+            newprofile.replace_dict('secret', secret_dict)
+
+        # Basic achievements
+        achievements = request.child('achievements')
+        if achievements is not None:
+            newprofile.replace_int('visit_flg', int(achievements.attribute('visit_flg')))
+            newprofile.replace_int('last_weekly', int(achievements.attribute('last_weekly')))
+            newprofile.replace_int('weekly_num', int(achievements.attribute('weekly_num')))
+
+            pack_id = int(achievements.attribute('pack_id'))
+            if pack_id > 0:
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    pack_id,
+                    'daily',
+                    {
+                        'pack_flg': int(achievements.attribute('pack_flg')),
+                        'pack_comp': int(achievements.attribute('pack_comp')),
+                    },
+                )
+
+            trophies = achievements.child('trophy')
+            if trophies is not None:
+                # We only load the first 10 in profile load.
+                newprofile.replace_int_array('trophy', 10, trophies.value[:10])
+
+        # Deller saving
+        deller = request.child('deller')
+        if deller is not None:
+            newprofile.replace_int('deller', newprofile.get_int('deller') + int(deller.attribute('deller')))
+
+        # Secret course expert point saving
+        expert_point = request.child('expert_point')
+        if expert_point is not None:
+            courseid = int(expert_point.attribute('course_id'))
+
+            # Update achievement to track expert points
+            expert_point_achievement = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                courseid,
+                'expert_point',
+            )
+            if expert_point_achievement is None:
+                expert_point_achievement = ValidatedDict()
+            expert_point_achievement.replace_int(
+                'normal_points',
+                int(expert_point.attribute('n_point')),
+            )
+            expert_point_achievement.replace_int(
+                'hyper_points',
+                int(expert_point.attribute('h_point')),
+            )
+            expert_point_achievement.replace_int(
+                'another_points',
+                int(expert_point.attribute('a_point')),
+            )
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                courseid,
+                'expert_point',
+                expert_point_achievement,
+            )
+
+        # Favorites saving
+        favorite = request.child('favorite')
+        if favorite is not None:
+            single_music_bin = favorite.child_value('sp_mlist')
+            single_chart_bin = favorite.child_value('sp_clist')
+            double_music_bin = favorite.child_value('dp_mlist')
+            double_chart_bin = favorite.child_value('dp_clist')
+
+            singles = []
+            doubles = []
+            for i in range(self.FAVORITE_LIST_LENGTH):
+                singles.append({
+                    'id': struct.unpack('<L', single_music_bin[(i * 4):((i + 1) * 4)])[0],
+                    'chart': struct.unpack('B', single_chart_bin[i:(i + 1)])[0],
+                })
+                doubles.append({
+                    'id': struct.unpack('<L', double_music_bin[(i * 4):((i + 1) * 4)])[0],
+                    'chart': struct.unpack('B', double_chart_bin[i:(i + 1)])[0],
+                })
+
+            # Filter out empty charts
+            singles = [single for single in singles if single['id'] != 0]
+            doubles = [double for double in doubles if double['id'] != 0]
+
+            newprofile.replace_dict(
+                'favorite',
+                {
+                    'single': singles,
+                    'double': doubles,
+                },
+            )
+
+        # Step-up mode
+        step = request.child('step')
+        if step is not None:
+            step_dict = newprofile.get_dict('step')
+            step_dict.replace_int('age_list', int(step.attribute('age_list')))
+            step_dict.replace_int('damage', int(step.attribute('damage')))
+            step_dict.replace_int('defeat', int(step.attribute('defeat')))
+            step_dict.replace_int('dp_level', int(step.attribute('dp_level')))
+            step_dict.replace_int('dp_mission', int(step.attribute('dp_mission')))
+            step_dict.replace_int('dp_mplay', int(step.attribute('dp_mplay')))
+            step_dict.replace_int('is_future', int(step.attribute('is_future')))
+            step_dict.replace_int('is_present', int(step.attribute('is_present')))
+            step_dict.replace_int('is_secret', int(step.attribute('is_secret')))
+            step_dict.replace_int('progress', int(step.attribute('progress')))
+            step_dict.replace_int('sp_level', int(step.attribute('sp_level')))
+            step_dict.replace_int('sp_mission', int(step.attribute('sp_mission')))
+            step_dict.replace_int('sp_mplay', int(step.attribute('sp_mplay')))
+            step_dict.replace_bytes('album', step.value)
+            newprofile.replace_dict('step', step_dict)
+
+        # Orb data saving
+        orb_data = request.child('orb_data')
+        if orb_data is not None:
+            orbs = newprofile.get_int('orbs')
+            orbs = orbs + int(orb_data.attribute('add_orb'))
+            if orb_data.child_value('use_vip_pass'):
+                orbs = 0
+            newprofile.replace_int('orbs', orbs)
+
+        # Keep track of play statistics across all mixes
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/iidx/sinobuz.py b/bemani/backend/iidx/sinobuz.py
new file mode 100644
index 0000000..09cc77f
--- /dev/null
+++ b/bemani/backend/iidx/sinobuz.py
@@ -0,0 +1,2129 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+import struct
+from typing import Optional, Dict, Any, List, Tuple
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.backend.iidx.course import IIDXCourse
+from bemani.backend.iidx.copula import IIDXCopula
+
+from bemani.common import ValidatedDict, VersionConstants, Time, ID, intish
+from bemani.data import Data, UserID
+from bemani.protocol import Node
+
+
+class IIDXSinobuz(IIDXCourse, IIDXBase):
+
+    name = 'Beatmania IIDX SINOBUZ'
+    version = VersionConstants.IIDX_SINOBUZ
+
+    GAME_CLTYPE_SINGLE = 0
+    GAME_CLTYPE_DOUBLE = 1
+
+    DAN_STAGES = 4
+
+    GAME_CLEAR_STATUS_NO_PLAY = 0
+    GAME_CLEAR_STATUS_FAILED = 1
+    GAME_CLEAR_STATUS_ASSIST_CLEAR = 2
+    GAME_CLEAR_STATUS_EASY_CLEAR = 3
+    GAME_CLEAR_STATUS_CLEAR = 4
+    GAME_CLEAR_STATUS_HARD_CLEAR = 5
+    GAME_CLEAR_STATUS_EX_HARD_CLEAR = 6
+    GAME_CLEAR_STATUS_FULL_COMBO = 7
+
+    GAME_GHOST_TYPE_RIVAL = 1
+    GAME_GHOST_TYPE_GLOBAL_TOP = 2
+    GAME_GHOST_TYPE_GLOBAL_AVERAGE = 3
+    GAME_GHOST_TYPE_LOCAL_TOP = 4
+    GAME_GHOST_TYPE_LOCAL_AVERAGE = 5
+    GAME_GHOST_TYPE_DAN_TOP = 6
+    GAME_GHOST_TYPE_DAN_AVERAGE = 7
+    GAME_GHOST_TYPE_RIVAL_TOP = 8
+    GAME_GHOST_TYPE_RIVAL_AVERAGE = 9
+
+    GAME_GHOST_LENGTH = 64
+
+    GAME_SP_DAN_RANK_7_KYU = 0
+    GAME_SP_DAN_RANK_6_KYU = 1
+    GAME_SP_DAN_RANK_5_KYU = 2
+    GAME_SP_DAN_RANK_4_KYU = 3
+    GAME_SP_DAN_RANK_3_KYU = 4
+    GAME_SP_DAN_RANK_2_KYU = 5
+    GAME_SP_DAN_RANK_1_KYU = 6
+    GAME_SP_DAN_RANK_1_DAN = 7
+    GAME_SP_DAN_RANK_2_DAN = 8
+    GAME_SP_DAN_RANK_3_DAN = 9
+    GAME_SP_DAN_RANK_4_DAN = 10
+    GAME_SP_DAN_RANK_5_DAN = 11
+    GAME_SP_DAN_RANK_6_DAN = 12
+    GAME_SP_DAN_RANK_7_DAN = 13
+    GAME_SP_DAN_RANK_8_DAN = 14
+    GAME_SP_DAN_RANK_9_DAN = 15
+    GAME_SP_DAN_RANK_10_DAN = 16
+    GAME_SP_DAN_RANK_CHUDEN = 17
+    GAME_SP_DAN_RANK_KAIDEN = 18
+
+    GAME_DP_DAN_RANK_7_KYU = 0
+    GAME_DP_DAN_RANK_6_KYU = 1
+    GAME_DP_DAN_RANK_5_KYU = 2
+    GAME_DP_DAN_RANK_4_KYU = 3
+    GAME_DP_DAN_RANK_3_KYU = 4
+    GAME_DP_DAN_RANK_2_KYU = 5
+    GAME_DP_DAN_RANK_1_KYU = 6
+    GAME_DP_DAN_RANK_1_DAN = 7
+    GAME_DP_DAN_RANK_2_DAN = 8
+    GAME_DP_DAN_RANK_3_DAN = 9
+    GAME_DP_DAN_RANK_4_DAN = 10
+    GAME_DP_DAN_RANK_5_DAN = 11
+    GAME_DP_DAN_RANK_6_DAN = 12
+    GAME_DP_DAN_RANK_7_DAN = 13
+    GAME_DP_DAN_RANK_8_DAN = 14
+    GAME_DP_DAN_RANK_9_DAN = 15
+    GAME_DP_DAN_RANK_10_DAN = 16
+    GAME_DP_DAN_RANK_CHUDEN = 17
+    GAME_DP_DAN_RANK_KAIDEN = 18
+
+    FAVORITE_LIST_LENGTH = 20
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXCopula(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert dailies into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'daily_charts', 'daily'):
+            # Generate a new list of three dailies.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = list(set([song.id for song in data.local.music.get_all_songs(cls.game, cls.version)]))
+            daily_songs = random.sample(all_songs, 3)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'dailies',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': daily_songs,
+                },
+            )
+            events.append((
+                'iidx_daily_charts',
+                {
+                    'version': cls.version,
+                    'music': daily_songs,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'daily_charts', 'daily')
+        return events
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Global Shop Ranking',
+                    'tip': 'Return network-wide ranking instead of shop ranking on results screen.',
+                    'category': 'game_config',
+                    'setting': 'global_shop_ranking',
+                },
+                {
+                    'name': 'Events In Omnimix',
+                    'tip': 'Allow events to be enabled at all for Omnimix.',
+                    'category': 'game_config',
+                    'setting': 'omnimix_events_enabled',
+                },
+            ],
+            'ints': [
+                {
+                    'name': 'Event Phase',
+                    'tip': 'Event phase for all players.',
+                    'category': 'game_config',
+                    'setting': 'event_phase',
+                    'values': {
+                        0: 'No Event',
+                        1: 'Koujyo SINOBUZ Den Phase 1',
+                        2: 'Koujyo SINOBUZ Den Phase 2',
+                        3: 'Koujyo SINOBUZ Den Phase 3',
+                        4: 'Ninnin Shichikenden',
+                    }
+                },
+            ],
+        }
+
+    def db_to_game_status(self, db_status: int) -> int:
+        return {
+            self.CLEAR_STATUS_NO_PLAY: self.GAME_CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED: self.GAME_CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR: self.GAME_CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR: self.GAME_CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR: self.GAME_CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR: self.GAME_CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR: self.GAME_CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO: self.GAME_CLEAR_STATUS_FULL_COMBO,
+        }[db_status]
+
+    def game_to_db_status(self, game_status: int) -> int:
+        return {
+            self.GAME_CLEAR_STATUS_NO_PLAY: self.CLEAR_STATUS_NO_PLAY,
+            self.GAME_CLEAR_STATUS_FAILED: self.CLEAR_STATUS_FAILED,
+            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.GAME_CLEAR_STATUS_EASY_CLEAR: self.CLEAR_STATUS_EASY_CLEAR,
+            self.GAME_CLEAR_STATUS_CLEAR: self.CLEAR_STATUS_CLEAR,
+            self.GAME_CLEAR_STATUS_HARD_CLEAR: self.CLEAR_STATUS_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_FULL_COMBO: self.CLEAR_STATUS_FULL_COMBO,
+        }[game_status]
+
+    def db_to_game_rank(self, db_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if db_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_SP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_SP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_SP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_SP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_SP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_SP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_SP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_SP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_SP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_SP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_SP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_SP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_SP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_SP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_SP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_SP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_SP_DAN_RANK_10_DAN,
+                self.DAN_RANK_CHUDEN: self.GAME_SP_DAN_RANK_CHUDEN,
+                self.DAN_RANK_KAIDEN: self.GAME_SP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_DP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_DP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_DP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_DP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_DP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_DP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_DP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_DP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_DP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_DP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_DP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_DP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_DP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_DP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_DP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_DP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_DP_DAN_RANK_10_DAN,
+                self.DAN_RANK_CHUDEN: self.GAME_DP_DAN_RANK_CHUDEN,
+                self.DAN_RANK_KAIDEN: self.GAME_DP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def game_to_db_rank(self, game_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if game_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.GAME_SP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_SP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_SP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_SP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_SP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_SP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_SP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_SP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_SP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_SP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_SP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_SP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_SP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_SP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_SP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_SP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_SP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_SP_DAN_RANK_CHUDEN: self.DAN_RANK_CHUDEN,
+                self.GAME_SP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.GAME_DP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_DP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_DP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_DP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_DP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_DP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_DP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_DP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_DP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_DP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_DP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_DP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_DP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_DP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_DP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_DP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_DP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_DP_DAN_RANK_CHUDEN: self.DAN_RANK_CHUDEN,
+                self.GAME_DP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def handle_IIDX24shop_getname_request(self, request: Node) -> Node:
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine is not None:
+            machine_name = machine.name
+            close = machine.data.get_bool('close')
+            hour = machine.data.get_int('hour')
+            minute = machine.data.get_int('minute')
+        else:
+            machine_name = ''
+            close = False
+            hour = 0
+            minute = 0
+
+        root = Node.void('IIDX24shop')
+        root.set_attribute('opname', machine_name)
+        root.set_attribute('pid', '51')
+        root.set_attribute('cls_opt', '1' if close else '0')
+        root.set_attribute('hr', str(hour))
+        root.set_attribute('mi', str(minute))
+        return root
+
+    def handle_IIDX24shop_savename_request(self, request: Node) -> Node:
+        self.update_machine_name(request.attribute('opname'))
+
+        shop_close = intish(request.attribute('cls_opt')) or 0
+        minutes = intish(request.attribute('mnt')) or 0
+        hours = intish(request.attribute('hr')) or 0
+
+        self.update_machine_data({
+            'close': shop_close != 0,
+            'minutes': minutes,
+            'hours': hours,
+        })
+
+        return Node.void('IIDX24shop')
+
+    def handle_IIDX24shop_sentinfo_request(self, request: Node) -> Node:
+        return Node.void('IIDX24shop')
+
+    def handle_IIDX24shop_sendescapepackageinfo_request(self, request: Node) -> Node:
+        root = Node.void('IIDX24shop')
+        root.set_attribute('expire', str((Time.now() + 86400 * 365) * 1000))
+        return root
+
+    def handle_IIDX24shop_getconvention_request(self, request: Node) -> Node:
+        root = Node.void('IIDX24shop')
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine.arcade is not None:
+            course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+        else:
+            course = None
+
+        if course is None:
+            course = ValidatedDict()
+
+        root.set_attribute('music_0', str(course.get_int('music_0', 20032)))
+        root.set_attribute('music_1', str(course.get_int('music_1', 20009)))
+        root.set_attribute('music_2', str(course.get_int('music_2', 20015)))
+        root.set_attribute('music_3', str(course.get_int('music_3', 20064)))
+        root.add_child(Node.bool('valid', course.get_bool('valid')))
+        return root
+
+    def handle_IIDX24shop_setconvention_request(self, request: Node) -> Node:
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine.arcade is not None:
+            course = ValidatedDict()
+            course.replace_int('music_0', request.child_value('music_0'))
+            course.replace_int('music_1', request.child_value('music_1'))
+            course.replace_int('music_2', request.child_value('music_2'))
+            course.replace_int('music_3', request.child_value('music_3'))
+            course.replace_bool('valid', request.child_value('valid'))
+            self.data.local.machine.put_settings(machine.arcade, self.game, self.music_version, 'shop_course', course)
+
+        return Node.void('IIDX24shop')
+
+    def handle_IIDX24ranking_getranker_request(self, request: Node) -> Node:
+        root = Node.void('IIDX24ranking')
+        chart = int(request.attribute('clid'))
+        if chart not in [
+            self.CHART_TYPE_N7,
+            self.CHART_TYPE_H7,
+            self.CHART_TYPE_A7,
+            self.CHART_TYPE_N14,
+            self.CHART_TYPE_H14,
+            self.CHART_TYPE_A14,
+        ]:
+            # Chart type 6 is presumably beginner mode, but it crashes the game
+            return root
+
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine.arcade is not None:
+            course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+        else:
+            course = None
+
+        if course is None:
+            course = ValidatedDict()
+
+        if not course.get_bool('valid'):
+            # Shop course not enabled or not present
+            return root
+
+        convention = Node.void('convention')
+        root.add_child(convention)
+        convention.set_attribute('clid', str(chart))
+        convention.set_attribute('update_date', str(Time.now() * 1000))
+
+        # Grab all scores for each of the four songs, filter out people who haven't
+        # set us as their arcade and then return the top 20 scores (adding all 4 songs).
+        songids = [
+            course.get_int('music_0'),
+            course.get_int('music_1'),
+            course.get_int('music_2'),
+            course.get_int('music_3'),
+        ]
+
+        totalscores: Dict[UserID, int] = {}
+        profiles: Dict[UserID, ValidatedDict] = {}
+        for songid in songids:
+            scores = self.data.local.music.get_all_scores(
+                self.game,
+                self.music_version,
+                songid=songid,
+                songchart=chart,
+            )
+
+            for score in scores:
+                if score[0] not in totalscores:
+                    totalscores[score[0]] = 0
+                    profile = self.get_any_profile(score[0])
+                    if profile is None:
+                        profile = ValidatedDict()
+                    profiles[score[0]] = profile
+
+                totalscores[score[0]] += score[1].points
+
+        topscores = sorted(
+            [
+                (totalscores[userid], profiles[userid])
+                for userid in totalscores
+                if self.user_joined_arcade(machine, profiles[userid])
+            ],
+            key=lambda tup: tup[0],
+            reverse=True,
+        )[:20]
+
+        rank = 0
+        for topscore in topscores:
+            rank = rank + 1
+
+            detail = Node.void('detail')
+            convention.add_child(detail)
+            detail.set_attribute('name', topscore[1].get_str('name'))
+            detail.set_attribute('rank', str(rank))
+            detail.set_attribute('score', str(topscore[0]))
+            detail.set_attribute('pid', str(topscore[1].get_int('pid')))
+
+            qpro = topscore[1].get_dict('qpro')
+            detail.set_attribute('head', str(qpro.get_int('head')))
+            detail.set_attribute('hair', str(qpro.get_int('hair')))
+            detail.set_attribute('face', str(qpro.get_int('face')))
+            detail.set_attribute('body', str(qpro.get_int('body')))
+            detail.set_attribute('hand', str(qpro.get_int('hand')))
+
+        return root
+
+    def handle_IIDX24ranking_entry_request(self, request: Node) -> Node:
+        extid = int(request.attribute('iidxid'))
+        courseid = int(request.attribute('coid'))
+        chart = int(request.attribute('clid'))
+        course_type = int(request.attribute('regist_type'))
+        clear_status = self.game_to_db_status(int(request.attribute('clr')))
+        pgreats = int(request.attribute('pgnum'))
+        greats = int(request.attribute('gnum'))
+
+        if course_type == 0:
+            index = self.COURSE_TYPE_INTERNET_RANKING
+        elif course_type == 1:
+            index = self.COURSE_TYPE_SECRET
+        else:
+            raise Exception('Unknown registration type for course entry!')
+
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            # Update achievement to track course statistics
+            self.update_course(
+                userid,
+                index,
+                courseid,
+                chart,
+                clear_status,
+                pgreats,
+                greats,
+            )
+
+        # We should return the user's position, but its not displayed anywhere
+        # so fuck it.
+        root = Node.void('IIDX24ranking')
+        root.set_attribute('anum', '1')
+        root.set_attribute('jun', '1')
+        return root
+
+    def handle_IIDX24ranking_classicentry_request(self, request: Node) -> Node:
+        extid = int(request.attribute('iidx_id'))
+        courseid = int(request.attribute('course_id'))
+        coursestyle = int(request.attribute('play_style'))
+        clear_status = self.game_to_db_status(int(request.attribute('clear_flg')))
+        pgreats = int(request.attribute('pgnum'))
+        greats = int(request.attribute('gnum'))
+
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            # Update achievement to track course statistics
+            self.update_course(
+                userid,
+                self.COURSE_TYPE_CLASSIC,
+                courseid,
+                coursestyle,
+                clear_status,
+                pgreats,
+                greats,
+            )
+
+        return Node.void('IIDX24ranking')
+
+    def handle_IIDX24music_crate_request(self, request: Node) -> Node:
+        root = Node.void('IIDX24music')
+        attempts = self.get_clear_rates()
+
+        all_songs = list(set([song.id for song in self.data.local.music.get_all_songs(self.game, self.music_version)]))
+        for song in all_songs:
+            clears = []
+            fcs = []
+
+            for chart in [0, 1, 2, 3, 4, 5]:
+                placed = False
+                if song in attempts and chart in attempts[song]:
+                    values = attempts[song][chart]
+                    if values['total'] > 0:
+                        clears.append(int((1000 * values['clears']) / values['total']))
+                        fcs.append(int((1000 * values['fcs']) / values['total']))
+                        placed = True
+                if not placed:
+                    clears.append(1001)
+                    fcs.append(1001)
+
+            clearnode = Node.s32_array('c', clears + fcs)
+            clearnode.set_attribute('mid', str(song))
+            root.add_child(clearnode)
+
+        return root
+
+    def handle_IIDX24music_getrank_request(self, request: Node) -> Node:
+        cltype = int(request.attribute('cltype'))
+
+        root = Node.void('IIDX24music')
+        style = Node.void('style')
+        root.add_child(style)
+        style.set_attribute('type', str(cltype))
+
+        for rivalid in [-1, 0, 1, 2, 3, 4]:
+            if rivalid == -1:
+                attr = 'iidxid'
+            else:
+                attr = 'iidxid{}'.format(rivalid)
+
+            try:
+                extid = int(request.attribute(attr))
+            except Exception:
+                # Invalid extid
+                continue
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+
+                # Grab score data for user/rival
+                scoredata = self.make_score_struct(
+                    scores,
+                    self.CLEAR_TYPE_SINGLE if cltype == self.GAME_CLTYPE_SINGLE else self.CLEAR_TYPE_DOUBLE,
+                    rivalid,
+                )
+                for s in scoredata:
+                    root.add_child(Node.s16_array('m', s))
+
+                # Grab most played for user/rival
+                most_played = [
+                    play[0] for play in
+                    self.data.local.music.get_most_played(self.game, self.music_version, userid, 20)
+                ]
+                if len(most_played) < 20:
+                    most_played.extend([0] * (20 - len(most_played)))
+                best = Node.u16_array('best', most_played)
+                best.set_attribute('rno', str(rivalid))
+                root.add_child(best)
+
+                if rivalid == -1:
+                    # Grab beginner statuses for user only
+                    beginnerdata = self.make_beginner_struct(scores)
+                    for b in beginnerdata:
+                        root.add_child(Node.u16_array('b', b))
+
+        return root
+
+    def handle_IIDX24music_appoint_request(self, request: Node) -> Node:
+        musicid = int(request.attribute('mid'))
+        chart = int(request.attribute('clid'))
+        ghost_type = int(request.attribute('ctype'))
+        extid = int(request.attribute('iidxid'))
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        root = Node.void('IIDX24music')
+
+        if userid is not None:
+            # Try to look up previous ghost for user
+            my_score = self.data.remote.music.get_score(self.game, self.music_version, userid, musicid, chart)
+            if my_score is not None:
+                mydata = Node.binary('mydata', my_score.data.get_bytes('ghost'))
+                mydata.set_attribute('score', str(my_score.points))
+                root.add_child(mydata)
+
+            ghost_score = self.get_ghost(
+                {
+                    self.GAME_GHOST_TYPE_RIVAL: self.GHOST_TYPE_RIVAL,
+                    self.GAME_GHOST_TYPE_GLOBAL_TOP: self.GHOST_TYPE_GLOBAL_TOP,
+                    self.GAME_GHOST_TYPE_GLOBAL_AVERAGE: self.GHOST_TYPE_GLOBAL_AVERAGE,
+                    self.GAME_GHOST_TYPE_LOCAL_TOP: self.GHOST_TYPE_LOCAL_TOP,
+                    self.GAME_GHOST_TYPE_LOCAL_AVERAGE: self.GHOST_TYPE_LOCAL_AVERAGE,
+                    self.GAME_GHOST_TYPE_DAN_TOP: self.GHOST_TYPE_DAN_TOP,
+                    self.GAME_GHOST_TYPE_DAN_AVERAGE: self.GHOST_TYPE_DAN_AVERAGE,
+                    self.GAME_GHOST_TYPE_RIVAL_TOP: self.GHOST_TYPE_RIVAL_TOP,
+                    self.GAME_GHOST_TYPE_RIVAL_AVERAGE: self.GHOST_TYPE_RIVAL_AVERAGE,
+                }.get(ghost_type, self.GHOST_TYPE_NONE),
+                request.attribute('subtype'),
+                self.GAME_GHOST_LENGTH,
+                musicid,
+                chart,
+                userid,
+            )
+
+            # Add ghost score if we support it
+            if ghost_score is not None:
+                sdata = Node.binary('sdata', ghost_score['ghost'])
+                sdata.set_attribute('score', str(ghost_score['score']))
+                if 'name' in ghost_score:
+                    sdata.set_attribute('name', ghost_score['name'])
+                if 'pid' in ghost_score:
+                    sdata.set_attribute('pid', str(ghost_score['pid']))
+                if 'extid' in ghost_score:
+                    sdata.set_attribute('riidxid', str(ghost_score['extid']))
+                root.add_child(sdata)
+
+        return root
+
+    def handle_IIDX24music_breg_request(self, request: Node) -> Node:
+        extid = int(request.attribute('iidxid'))
+        musicid = int(request.attribute('mid'))
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        if userid is not None:
+            clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+            pgreats = int(request.attribute('pgnum'))
+            greats = int(request.attribute('gnum'))
+
+        self.update_score(
+            userid,
+            musicid,
+            self.CHART_TYPE_B7,
+            clear_status,
+            pgreats,
+            greats,
+            -1,
+            b'',
+            None,
+        )
+
+        # Return nothing.
+        return Node.void('IIDX24music')
+
+    def handle_IIDX24music_reg_request(self, request: Node) -> Node:
+        extid = int(request.attribute('iidxid'))
+        musicid = int(request.attribute('mid'))
+        chart = int(request.attribute('clid'))
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        # See if we need to report global or shop scores
+        if self.machine_joined_arcade():
+            game_config = self.get_game_config()
+            global_scores = game_config.get_bool('global_shop_ranking')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        else:
+            # If we aren't in an arcade, we can only show global scores
+            global_scores = True
+            machine = None
+
+        # First, determine our current ranking before saving the new score
+        all_scores = sorted(
+            self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+            key=lambda s: (s[1].points, s[1].timestamp),
+            reverse=True,
+        )
+        all_players = {
+            uid: prof for (uid, prof) in
+            self.get_any_profiles([s[0] for s in all_scores])
+        }
+
+        if not global_scores:
+            all_scores = [
+                score for score in all_scores
+                if (
+                    score[0] == userid or
+                    self.user_joined_arcade(machine, all_players[score[0]])
+                )
+            ]
+
+        # Find our actual index
+        oldindex = None
+        for i in range(len(all_scores)):
+            if all_scores[i][0] == userid:
+                oldindex = i
+                break
+
+        if userid is not None:
+            clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+            pgreats = int(request.attribute('pgnum'))
+            greats = int(request.attribute('gnum'))
+            miss_count = int(request.attribute('mnum'))
+            ghost = request.child_value('ghost')
+            shopid = ID.parse_machine_id(request.attribute('shopconvid'))
+
+            self.update_score(
+                userid,
+                musicid,
+                chart,
+                clear_status,
+                pgreats,
+                greats,
+                miss_count,
+                ghost,
+                shopid,
+            )
+
+        # Calculate and return statistics about this song
+        root = Node.void('IIDX24music')
+        root.set_attribute('clid', request.attribute('clid'))
+        root.set_attribute('mid', request.attribute('mid'))
+
+        attempts = self.get_clear_rates(musicid, chart)
+        count = attempts[musicid][chart]['total']
+        clear = attempts[musicid][chart]['clears']
+        full_combo = attempts[musicid][chart]['fcs']
+
+        if count > 0:
+            root.set_attribute('crate', str(int((1000 * clear) / count)))
+            root.set_attribute('frate', str(int((1000 * full_combo) / count)))
+        else:
+            root.set_attribute('crate', '0')
+            root.set_attribute('frate', '0')
+        root.set_attribute('rankside', '0')
+
+        if userid is not None:
+            # Shop ranking
+            shopdata = Node.void('shopdata')
+            root.add_child(shopdata)
+            shopdata.set_attribute('rank', '-1' if oldindex is None else str(oldindex + 1))
+
+            # Grab the rank of some other players on this song
+            ranklist = Node.void('ranklist')
+            root.add_child(ranklist)
+
+            all_scores = sorted(
+                self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                key=lambda s: (s[1].points, s[1].timestamp),
+                reverse=True,
+            )
+            missing_players = [
+                uid for (uid, _) in all_scores
+                if uid not in all_players
+            ]
+            for (uid, prof) in self.get_any_profiles(missing_players):
+                all_players[uid] = prof
+
+            if not global_scores:
+                all_scores = [
+                    score for score in all_scores
+                    if (
+                        score[0] == userid or
+                        self.user_joined_arcade(machine, all_players[score[0]])
+                    )
+                ]
+
+            # Find our actual index
+            ourindex = None
+            for i in range(len(all_scores)):
+                if all_scores[i][0] == userid:
+                    ourindex = i
+                    break
+            if ourindex is None:
+                raise Exception('Cannot find our own score after saving to DB!')
+            start = ourindex - 4
+            end = ourindex + 4
+            if start < 0:
+                start = 0
+            if end >= len(all_scores):
+                end = len(all_scores) - 1
+            relevant_scores = all_scores[start:(end + 1)]
+
+            record_num = start + 1
+            for score in relevant_scores:
+                profile = all_players[score[0]]
+
+                data = Node.void('data')
+                ranklist.add_child(data)
+                data.set_attribute('iidx_id', str(profile.get_int('extid')))
+                data.set_attribute('name', profile.get_str('name'))
+
+                machine_name = ''
+                if 'shop_location' in profile:
+                    shop_id = profile.get_int('shop_location')
+                    machine = self.get_machine_by_id(shop_id)
+                    if machine is not None:
+                        machine_name = machine.name
+                data.set_attribute('opname', machine_name)
+                data.set_attribute('rnum', str(record_num))
+                data.set_attribute('score', str(score[1].points))
+                data.set_attribute('clflg', str(self.db_to_game_status(score[1].data.get_int('clear_status'))))
+                data.set_attribute('pid', str(profile.get_int('pid')))
+                data.set_attribute('myFlg', '1' if score[0] == userid else '0')
+                data.set_attribute('update', '0')
+
+                data.set_attribute('sgrade', str(
+                    self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE),
+                ))
+                data.set_attribute('dgrade', str(
+                    self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE),
+                ))
+
+                qpro = profile.get_dict('qpro')
+                data.set_attribute('head', str(qpro.get_int('head')))
+                data.set_attribute('hair', str(qpro.get_int('hair')))
+                data.set_attribute('face', str(qpro.get_int('face')))
+                data.set_attribute('body', str(qpro.get_int('body')))
+                data.set_attribute('hand', str(qpro.get_int('hand')))
+
+                record_num = record_num + 1
+
+        return root
+
+    def handle_IIDX24music_play_request(self, request: Node) -> Node:
+        musicid = int(request.attribute('mid'))
+        chart = int(request.attribute('clid'))
+        clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+
+        self.update_score(
+            None,  # No userid since its anonymous
+            musicid,
+            chart,
+            clear_status,
+            0,  # No ex score
+            0,  # No ex score
+            0,  # No miss count
+            None,  # No ghost
+            None,  # No shop for this user
+        )
+
+        # Calculate and return statistics about this song
+        root = Node.void('IIDX24music')
+        root.set_attribute('clid', request.attribute('clid'))
+        root.set_attribute('mid', request.attribute('mid'))
+
+        attempts = self.get_clear_rates(musicid, chart)
+        count = attempts[musicid][chart]['total']
+        clear = attempts[musicid][chart]['clears']
+        full_combo = attempts[musicid][chart]['fcs']
+
+        if count > 0:
+            root.set_attribute('crate', str(int((1000 * clear) / count)))
+            root.set_attribute('frate', str(int((1000 * full_combo) / count)))
+        else:
+            root.set_attribute('crate', '0')
+            root.set_attribute('frate', '0')
+
+        return root
+
+    def handle_IIDX24grade_raised_request(self, request: Node) -> Node:
+        extid = int(request.attribute('iidxid'))
+        cltype = int(request.attribute('gtype'))
+        rank = self.game_to_db_rank(int(request.attribute('gid')), cltype)
+
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            percent = int(request.attribute('achi'))
+            stages_cleared = int(request.attribute('cstage'))
+            cleared = stages_cleared == self.DAN_STAGES
+
+            if cltype == self.GAME_CLTYPE_SINGLE:
+                index = self.DAN_RANKING_SINGLE
+            else:
+                index = self.DAN_RANKING_DOUBLE
+
+            self.update_rank(
+                userid,
+                index,
+                rank,
+                percent,
+                cleared,
+                stages_cleared,
+            )
+
+        # Figure out number of players that played this ranking
+        all_achievements = self.data.local.user.get_all_achievements(self.game, self.version)
+        num_players = 0
+        for [_, ach] in all_achievements:
+            if ach.type != index:
+                continue
+            if ach.id != rank:
+                continue
+            num_players = num_players + 1
+
+        root = Node.void('IIDX24grade')
+        root.set_attribute('pnum', str(num_players))
+        return root
+
+    def handle_IIDX24pc_common_request(self, request: Node) -> Node:
+        root = Node.void('IIDX24pc')
+        root.set_attribute('expire', '600')
+
+        ir = Node.void('ir')
+        root.add_child(ir)
+        ir.set_attribute('beat', '2')
+
+        # See if we configured event overrides
+        if self.machine_joined_arcade():
+            game_config = self.get_game_config()
+            event_phase = game_config.get_int('event_phase')
+            omni_events = game_config.get_bool('omnimix_events_enabled')
+        else:
+            # If we aren't in an arcade, we turn off events
+            event_phase = 0
+            omni_events = False
+
+        if event_phase == 0 or (self.omnimix and (not omni_events)):
+            boss_phase = 0
+            event1 = 0
+            event2 = 0
+        elif event_phase in [1, 2, 3]:
+            boss_phase = 1
+            event1 = event_phase - 1
+            event2 = 0
+        elif event_phase == 4:
+            boss_phase = 2
+            event1 = 0
+            event2 = 2
+
+        boss = Node.void('boss')
+        root.add_child(boss)
+        boss.set_attribute('phase', str(boss_phase))
+
+        event1_phase = Node.void('event1_phase')
+        root.add_child(event1_phase)
+        event1_phase.set_attribute('phase', str(event1))
+
+        event2_phase = Node.void('event2_phase')
+        root.add_child(event2_phase)
+        event2_phase.set_attribute('phase', str(event2))
+
+        extra_boss_event = Node.void('extra_boss_event')
+        root.add_child(extra_boss_event)
+        extra_boss_event.set_attribute('phase', '1')
+
+        vip_black_pass = Node.void('vip_pass_black')
+        root.add_child(vip_black_pass)
+
+        newsong_another = Node.void('newsong_another')
+        root.add_child(newsong_another)
+        newsong_another.set_attribute('open', '1')
+
+        deller_bonus = Node.void('deller_bonus')
+        root.add_child(deller_bonus)
+        deller_bonus.set_attribute('open', '1')
+
+        common_evnet = Node.void('common_evnet')  # Yes, this is misspelled in the game
+        root.add_child(common_evnet)
+        common_evnet.set_attribute('flg', '0')
+
+        # Course definitions
+        courses: List[Dict[str, Any]] = [
+            {
+                'name': 'NINJA',
+                'id': 1,
+                'songs': [
+                    24068,
+                    24011,
+                    24031,
+                    24041,
+                ],
+            },
+            {
+                'name': '24A12',
+                'id': 2,
+                'songs': [
+                    24024,
+                    24023,
+                    24005,
+                    24012,
+                ],
+            },
+            {
+                'name': '80\'S',
+                'id': 3,
+                'songs': [
+                    20033,
+                    15029,
+                    24056,
+                    20068,
+                ],
+            },
+            {
+                'name': 'DJ TECHNORCH',
+                'id': 4,
+                'songs': [
+                    21029,
+                    22035,
+                    22049,
+                    21063,
+                ],
+            },
+            {
+                'name': 'COLORS',
+                'id': 5,
+                'songs': [
+                    11032,
+                    15022,
+                    15004,
+                    22089,
+                ],
+            },
+            {
+                'name': 'OHANA',
+                'id': 6,
+                'songs': [
+                    16050,
+                    13000,
+                    22087,
+                    10022,
+                ],
+            },
+            {
+                'name': 'DPER',
+                'id': 7,
+                'songs': [
+                    18004,
+                    19063,
+                    20047,
+                    17059,
+                ],
+            },
+            {
+                'name': 'DA',
+                'id': 8,
+                'songs': [
+                    23058,
+                    17021,
+                    18025,
+                    22006,
+                ],
+            },
+            {
+                'name': 'SOF-LAN',
+                'id': 9,
+                'songs': [
+                    23079,
+                    15005,
+                    7002,
+                    15023,
+                ],
+            },
+            {
+                'name': 'TEMPEST',
+                'id': 10,
+                'songs': [
+                    19008,
+                    20038,
+                    16020,
+                    23051,
+                ],
+            },
+            {
+                'name': 'STAR LIGHT',
+                'id': 11,
+                'songs': [
+                    23082,
+                    24027,
+                    20066,
+                    23031,
+                ],
+            },
+            {
+                'name': 'SCRATCH',
+                'id': 12,
+                'songs': [
+                    11025,
+                    16053,
+                    16031,
+                    22067,
+                ],
+            },
+            {
+                'name': 'L.E.D.-G',
+                'id': 13,
+                'songs': [
+                    15007,
+                    24000,
+                    22011,
+                    17009,
+                ],
+            },
+            {
+                'name': 'QQQ',
+                'id': 14,
+                'songs': [
+                    18062,
+                    18019,
+                    12011,
+                    16045,
+                ],
+            },
+            {
+                'name': 'BMK 2017',
+                'id': 15,
+                'songs': [
+                    24084,
+                    24017,
+                    24022,
+                    24043,
+                ],
+            },
+        ]
+
+        # Secret course definitions
+        secret_courses: List[Dict[str, Any]] = [
+            {
+                'name': 'L.E.D.-K',
+                'id': 1,
+                'songs': [
+                    13034,
+                    21068,
+                    17060,
+                    24089,
+                ],
+            },
+            {
+                'name': 'SOTA K',
+                'id': 2,
+                'songs': [
+                    16010,
+                    14038,
+                    20016,
+                    24090,
+                ],
+            },
+            {
+                'name': 'POP',
+                'id': 3,
+                'songs': [
+                    22042,
+                    14056,
+                    15003,
+                    24091,
+                ],
+            },
+            {
+                'name': 'REMO-CON',
+                'id': 4,
+                'songs': [
+                    15030,
+                    12031,
+                    22078,
+                    24092,
+                ],
+            },
+            {
+                'name': 'NUMBER',
+                'id': 5,
+                'songs': [
+                    1003,
+                    17051,
+                    17041,
+                    24093,
+                ],
+            },
+            {
+                'name': 'FANTASY',
+                'id': 6,
+                'songs': [
+                    20102,
+                    24013,
+                    23092,
+                    24094,
+                ],
+            },
+            {
+                'name': 'DRUM\'N\'BASS',
+                'id': 7,
+                'songs': [
+                    6013,
+                    22016,
+                    20073,
+                    24095,
+                ],
+            },
+        ]
+
+        # For some reason, omnimix crashes on course mode, so don't enable it
+        if not self.omnimix:
+            internet_ranking = Node.void('internet_ranking')
+            root.add_child(internet_ranking)
+
+            used_ids: List[int] = []
+            for c in courses:
+                if c['id'] in used_ids:
+                    raise Exception('Cannot have multiple courses with the same ID!')
+                elif c['id'] < 0 or c['id'] >= 20:
+                    raise Exception('Course ID is out of bounds!')
+                else:
+                    used_ids.append(c['id'])
+
+                course = Node.void('course')
+                internet_ranking.add_child(course)
+                course.set_attribute('course_id', str(c['id']))
+                course.set_attribute('name', c['name'])
+                course.set_attribute('mid0', str(c['songs'][0]))
+                course.set_attribute('mid1', str(c['songs'][1]))
+                course.set_attribute('mid2', str(c['songs'][2]))
+                course.set_attribute('mid3', str(c['songs'][3]))
+                course.set_attribute('opflg', '1')
+
+            secret_ex_course = Node.void('secret_ex_course')
+            root.add_child(secret_ex_course)
+
+            used_secret_ids: List[int] = []
+            for c in secret_courses:
+                if c['id'] in used_secret_ids:
+                    raise Exception('Cannot have multiple secret courses with the same ID!')
+                elif c['id'] < 0 or c['id'] >= 20:
+                    raise Exception('Secret course ID is out of bounds!')
+                else:
+                    used_secret_ids.append(c['id'])
+
+                course = Node.void('course')
+                secret_ex_course.add_child(course)
+                course.set_attribute('course_id', str(c['id']))
+                course.set_attribute('name', c['name'])
+                course.set_attribute('mid0', str(c['songs'][0]))
+                course.set_attribute('mid1', str(c['songs'][1]))
+                course.set_attribute('mid2', str(c['songs'][2]))
+                course.set_attribute('mid3', str(c['songs'][3]))
+
+            expert = Node.void('expert')
+            root.add_child(expert)
+            expert.set_attribute('phase', '1')
+
+            expert_random_select = Node.void('expert_random_select')
+            root.add_child(expert_random_select)
+            expert_random_select.set_attribute('phase', '1')
+
+            expert_full = Node.void('expert_secret_full_open')
+            root.add_child(expert_full)
+
+        return root
+
+    def handle_IIDX24pc_delete_request(self, request: Node) -> Node:
+        return Node.void('IIDX24pc')
+
+    def handle_IIDX24pc_playstart_request(self, request: Node) -> Node:
+        return Node.void('IIDX24pc')
+
+    def handle_IIDX24pc_playend_request(self, request: Node) -> Node:
+        return Node.void('IIDX24pc')
+
+    def handle_IIDX24pc_visit_request(self, request: Node) -> Node:
+        root = Node.void('IIDX24pc')
+        root.set_attribute('anum', '0')
+        root.set_attribute('snum', '0')
+        root.set_attribute('pnum', '0')
+        root.set_attribute('aflg', '0')
+        root.set_attribute('sflg', '0')
+        root.set_attribute('pflg', '0')
+        return root
+
+    def handle_IIDX24pc_shopregister_request(self, request: Node) -> Node:
+        extid = int(request.child_value('iidx_id'))
+        location = ID.parse_machine_id(request.child_value('location_id'))
+
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            if profile is None:
+                profile = ValidatedDict()
+            profile.replace_int('shop_location', location)
+            self.put_profile(userid, profile)
+
+        root = Node.void('IIDX24pc')
+        return root
+
+    def handle_IIDX24pc_oldget_request(self, request: Node) -> Node:
+        refid = request.attribute('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            oldversion = self.previous_version()
+            profile = oldversion.get_profile(userid)
+        else:
+            profile = None
+
+        root = Node.void('IIDX24pc')
+        root.set_attribute('status', '1' if profile is None else '0')
+        return root
+
+    def handle_IIDX24pc_getname_request(self, request: Node) -> Node:
+        refid = request.attribute('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            oldversion = self.previous_version()
+            profile = oldversion.get_profile(userid)
+        else:
+            profile = None
+        if profile is None:
+            raise Exception(
+                'Should not get here if we have no profile, we should ' +
+                'have returned \'1\' in the \'oldget\' method above ' +
+                'which should tell the game not to present a migration.'
+            )
+
+        root = Node.void('IIDX24pc')
+        root.set_attribute('name', profile.get_str('name'))
+        root.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+        root.set_attribute('pid', str(profile.get_int('pid')))
+        return root
+
+    def handle_IIDX24pc_takeover_request(self, request: Node) -> Node:
+        refid = request.attribute('rid')
+        name = request.attribute('name')
+        pid = int(request.attribute('pid'))
+        newprofile = self.new_profile_by_refid(refid, name, pid)
+
+        root = Node.void('IIDX24pc')
+        if newprofile is not None:
+            root.set_attribute('id', str(newprofile.get_int('extid')))
+        return root
+
+    def handle_IIDX24pc_reg_request(self, request: Node) -> Node:
+        refid = request.attribute('rid')
+        name = request.attribute('name')
+        pid = int(request.attribute('pid'))
+        profile = self.new_profile_by_refid(refid, name, pid)
+
+        root = Node.void('IIDX24pc')
+        if profile is not None:
+            root.set_attribute('id', str(profile.get_int('extid')))
+            root.set_attribute('id_str', ID.format_extid(profile.get_int('extid')))
+        return root
+
+    def handle_IIDX24pc_get_request(self, request: Node) -> Node:
+        refid = request.attribute('rid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('IIDX24pc')
+        return root
+
+    def handle_IIDX24pc_save_request(self, request: Node) -> Node:
+        extid = int(request.attribute('iidxid'))
+        self.put_profile_by_extid(extid, request)
+
+        return Node.void('IIDX24pc')
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('IIDX24pc')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Look up judge window adjustments
+        judge_dict = profile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+
+        # Profile data
+        pcdata = Node.void('pcdata')
+        root.add_child(pcdata)
+        pcdata.set_attribute('id', str(profile.get_int('extid')))
+        pcdata.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+        pcdata.set_attribute('name', profile.get_str('name'))
+        pcdata.set_attribute('pid', str(profile.get_int('pid')))
+        pcdata.set_attribute('spnum', str(play_stats.get_int('single_plays')))
+        pcdata.set_attribute('dpnum', str(play_stats.get_int('double_plays')))
+        pcdata.set_attribute('sach', str(play_stats.get_int('single_dj_points')))
+        pcdata.set_attribute('dach', str(play_stats.get_int('double_dj_points')))
+        pcdata.set_attribute('mode', str(profile.get_int('mode')))
+        pcdata.set_attribute('pmode', str(profile.get_int('pmode')))
+        pcdata.set_attribute('rtype', str(profile.get_int('rtype')))
+        pcdata.set_attribute('sp_opt', str(profile.get_int('sp_opt')))
+        pcdata.set_attribute('dp_opt', str(profile.get_int('dp_opt')))
+        pcdata.set_attribute('dp_opt2', str(profile.get_int('dp_opt2')))
+        pcdata.set_attribute('gpos', str(profile.get_int('gpos')))
+        pcdata.set_attribute('s_sorttype', str(profile.get_int('s_sorttype')))
+        pcdata.set_attribute('d_sorttype', str(profile.get_int('d_sorttype')))
+        pcdata.set_attribute('s_pace', str(profile.get_int('s_pace')))
+        pcdata.set_attribute('d_pace', str(profile.get_int('d_pace')))
+        pcdata.set_attribute('s_gno', str(profile.get_int('s_gno')))
+        pcdata.set_attribute('d_gno', str(profile.get_int('d_gno')))
+        pcdata.set_attribute('s_gtype', str(profile.get_int('s_gtype')))
+        pcdata.set_attribute('d_gtype', str(profile.get_int('d_gtype')))
+        pcdata.set_attribute('s_sdlen', str(profile.get_int('s_sdlen')))
+        pcdata.set_attribute('d_sdlen', str(profile.get_int('d_sdlen')))
+        pcdata.set_attribute('s_sdtype', str(profile.get_int('s_sdtype')))
+        pcdata.set_attribute('d_sdtype', str(profile.get_int('d_sdtype')))
+        pcdata.set_attribute('s_timing', str(profile.get_int('s_timing')))
+        pcdata.set_attribute('d_timing', str(profile.get_int('d_timing')))
+        pcdata.set_attribute('s_notes', str(profile.get_float('s_notes')))
+        pcdata.set_attribute('d_notes', str(profile.get_float('d_notes')))
+        pcdata.set_attribute('s_judge', str(profile.get_int('s_judge')))
+        pcdata.set_attribute('d_judge', str(profile.get_int('d_judge')))
+        pcdata.set_attribute('s_judgeAdj', str(machine_judge.get_int('single')))
+        pcdata.set_attribute('d_judgeAdj', str(machine_judge.get_int('double')))
+        pcdata.set_attribute('s_hispeed', str(profile.get_float('s_hispeed')))
+        pcdata.set_attribute('d_hispeed', str(profile.get_float('d_hispeed')))
+        pcdata.set_attribute('s_liflen', str(profile.get_int('s_lift')))
+        pcdata.set_attribute('d_liflen', str(profile.get_int('d_lift')))
+        pcdata.set_attribute('s_disp_judge', str(profile.get_int('s_disp_judge')))
+        pcdata.set_attribute('d_disp_judge', str(profile.get_int('d_disp_judge')))
+        pcdata.set_attribute('s_opstyle', str(profile.get_int('s_opstyle')))
+        pcdata.set_attribute('d_opstyle', str(profile.get_int('d_opstyle')))
+        pcdata.set_attribute('s_exscore', str(profile.get_int('s_exscore')))
+        pcdata.set_attribute('d_exscore', str(profile.get_int('d_exscore')))
+        pcdata.set_attribute('s_graph_score', str(profile.get_int('s_graph_score')))
+        pcdata.set_attribute('d_graph_score', str(profile.get_int('d_graph_score')))
+
+        spdp_rival = Node.void('spdp_rival')
+        root.add_child(spdp_rival)
+        spdp_rival.set_attribute('flg', str(profile.get_int('spdp_rival_flag')))
+
+        premium_unlocks = Node.void('ea_premium_course')
+        root.add_child(premium_unlocks)
+
+        legendarias = Node.void('leggendaria_open')
+        root.add_child(legendarias)
+
+        # Song unlock flags
+        secret_dict = profile.get_dict('secret')
+        secret = Node.void('secret')
+        root.add_child(secret)
+        secret.add_child(Node.s64_array('flg1', secret_dict.get_int_array('flg1', 3)))
+        secret.add_child(Node.s64_array('flg2', secret_dict.get_int_array('flg2', 3)))
+        secret.add_child(Node.s64_array('flg3', secret_dict.get_int_array('flg3', 3)))
+
+        # Favorites
+        for folder in ['favorite1', 'favorite2', 'favorite3']:
+            favorite_dict = profile.get_dict(folder)
+            sp_mlist = b''
+            sp_clist = b''
+            singles_list = favorite_dict['single'] if 'single' in favorite_dict else []
+            for single in singles_list:
+                sp_mlist = sp_mlist + struct.pack('<L', single['id'])
+                sp_clist = sp_clist + struct.pack('B', single['chart'])
+            while len(sp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+                sp_mlist = sp_mlist + b'\x00\x00\x00\x00'
+            while len(sp_clist) < self.FAVORITE_LIST_LENGTH:
+                sp_clist = sp_clist + b'\x00'
+
+            dp_mlist = b''
+            dp_clist = b''
+            doubles_list = favorite_dict['double'] if 'double' in favorite_dict else []
+            for double in doubles_list:
+                dp_mlist = dp_mlist + struct.pack('<L', double['id'])
+                dp_clist = dp_clist + struct.pack('B', double['chart'])
+            while len(dp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+                dp_mlist = dp_mlist + b'\x00\x00\x00\x00'
+            while len(dp_clist) < self.FAVORITE_LIST_LENGTH:
+                dp_clist = dp_clist + b'\x00'
+
+            if folder == 'favorite1':
+                favorite = Node.void('favorite')
+            elif folder == 'favorite2':
+                favorite = Node.void('extra_favorite')
+                favorite.set_attribute('folder_id', '0')
+            elif folder == 'favorite3':
+                favorite = Node.void('extra_favorite')
+                favorite.set_attribute('folder_id', '1')
+            root.add_child(favorite)
+            favorite.add_child(Node.binary('sp_mlist', sp_mlist))
+            favorite.add_child(Node.binary('sp_clist', sp_clist))
+            favorite.add_child(Node.binary('dp_mlist', dp_mlist))
+            favorite.add_child(Node.binary('dp_clist', dp_clist))
+
+        # DAN rankings
+        grade = Node.void('grade')
+        root.add_child(grade)
+        grade.set_attribute('sgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+        grade.set_attribute('dgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for rank in achievements:
+            if rank.type == self.DAN_RANKING_SINGLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_SINGLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_SINGLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+            if rank.type == self.DAN_RANKING_DOUBLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_DOUBLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_DOUBLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+
+        # User settings
+        settings_dict = profile.get_dict('settings')
+        skin = Node.s16_array(
+            'skin',
+            [
+                settings_dict.get_int('frame'),
+                settings_dict.get_int('turntable'),
+                settings_dict.get_int('burst'),
+                settings_dict.get_int('bgm'),
+                settings_dict.get_int('flags'),
+                settings_dict.get_int('towel'),
+                settings_dict.get_int('judge_pos'),
+                settings_dict.get_int('voice'),
+                settings_dict.get_int('noteskin'),
+                settings_dict.get_int('full_combo'),
+                settings_dict.get_int('beam'),
+                settings_dict.get_int('judge'),
+                0,
+                settings_dict.get_int('disable_song_preview'),
+                settings_dict.get_int('pacemaker'),
+                settings_dict.get_int('effector_lock'),
+                settings_dict.get_int('effector_preset'),
+            ],
+        )
+        root.add_child(skin)
+
+        # Qpro data
+        qpro_dict = profile.get_dict('qpro')
+        root.add_child(Node.u32_array(
+            'qprodata',
+            [
+                qpro_dict.get_int('head'),
+                qpro_dict.get_int('hair'),
+                qpro_dict.get_int('face'),
+                qpro_dict.get_int('hand'),
+                qpro_dict.get_int('body'),
+            ],
+        ))
+
+        # Qpro secret data from step-up mode
+        qpro_secrete_dict = profile.get_dict('qpro_secret')
+        qpro_secret = Node.void('qpro_secret')
+        root.add_child(qpro_secret)
+        qpro_secret.add_child(Node.s64_array('head', qpro_secrete_dict.get_int_array('head', 5)))
+        qpro_secret.add_child(Node.s64_array('hair', qpro_secrete_dict.get_int_array('hair', 5)))
+        qpro_secret.add_child(Node.s64_array('face', qpro_secrete_dict.get_int_array('face', 5)))
+        qpro_secret.add_child(Node.s64_array('body', qpro_secrete_dict.get_int_array('body', 5)))
+        qpro_secret.add_child(Node.s64_array('hand', qpro_secrete_dict.get_int_array('hand', 5)))
+
+        # Rivals
+        rlist = Node.void('rlist')
+        root.add_child(rlist)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            rival_type = None
+            if link.type == 'sp_rival':
+                rival_type = '1'
+            elif link.type == 'dp_rival':
+                rival_type = '2'
+            else:
+                # No business with this link type
+                continue
+
+            other_profile = self.get_profile(link.other_userid)
+            if other_profile is None:
+                continue
+            other_play_stats = self.get_play_statistics(link.other_userid)
+
+            rival = Node.void('rival')
+            rlist.add_child(rival)
+            rival.set_attribute('spdp', rival_type)
+            rival.set_attribute('id', str(other_profile.get_int('extid')))
+            rival.set_attribute('id_str', ID.format_extid(other_profile.get_int('extid')))
+            rival.set_attribute('djname', other_profile.get_str('name'))
+            rival.set_attribute('pid', str(other_profile.get_int('pid')))
+            rival.set_attribute('sg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+            rival.set_attribute('dg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+            rival.set_attribute('sa', str(other_play_stats.get_int('single_dj_points')))
+            rival.set_attribute('da', str(other_play_stats.get_int('double_dj_points')))
+
+            rival.add_child(Node.bool('is_robo', False))
+
+            # If the user joined a particular shop, let the game know.
+            if 'shop_location' in other_profile:
+                shop_id = other_profile.get_int('shop_location')
+                machine = self.get_machine_by_id(shop_id)
+                if machine is not None:
+                    shop = Node.void('shop')
+                    rival.add_child(shop)
+                    shop.set_attribute('name', machine.name)
+
+            qprodata = Node.void('qprodata')
+            rival.add_child(qprodata)
+            qpro = other_profile.get_dict('qpro')
+            qprodata.set_attribute('head', str(qpro.get_int('head')))
+            qprodata.set_attribute('hair', str(qpro.get_int('hair')))
+            qprodata.set_attribute('face', str(qpro.get_int('face')))
+            qprodata.set_attribute('body', str(qpro.get_int('body')))
+            qprodata.set_attribute('hand', str(qpro.get_int('hand')))
+
+        # Expert courses
+        ir_data = Node.void('ir_data')
+        root.add_child(ir_data)
+        for course in achievements:
+            if course.type == self.COURSE_TYPE_INTERNET_RANKING:
+                courseid, coursechart = self.id_and_chart_from_courseid(course.id)
+                ir_data.add_child(Node.s32_array('e', [
+                    courseid,  # course ID
+                    coursechart,  # course chart
+                    self.db_to_game_status(course.data.get_int('clear_status')),  # course clear status
+                    course.data.get_int('pgnum'),  # flashing great count
+                    course.data.get_int('gnum'),  # great count
+                ]))
+
+        secret_course_data = Node.void('secret_course_data')
+        root.add_child(secret_course_data)
+        for course in achievements:
+            if course.type == self.COURSE_TYPE_SECRET:
+                courseid, coursechart = self.id_and_chart_from_courseid(course.id)
+                secret_course_data.add_child(Node.s32_array('e', [
+                    courseid,  # course ID
+                    coursechart,  # course chart
+                    self.db_to_game_status(course.data.get_int('clear_status')),  # course clear status
+                    course.data.get_int('pgnum'),  # flashing great count
+                    course.data.get_int('gnum'),  # great count
+                ]))
+
+        classic_course_data = Node.void('classic_course_data')
+        root.add_child(classic_course_data)
+        for course in achievements:
+            if course.type == self.COURSE_TYPE_CLASSIC:
+                courseid, playstyle = self.id_and_chart_from_courseid(course.id)
+                score_data = Node.void('score_data')
+                classic_course_data.add_child(score_data)
+                score_data.set_attribute('play_style', str(playstyle))
+                score_data.set_attribute('course_id', str(courseid))
+                score_data.set_attribute('score', str(course.data.get_int('pgnum') * 2 + course.data.get_int('gnum')))
+                score_data.set_attribute('pgnum', str(course.data.get_int('pgnum')))
+                score_data.set_attribute('gnum', str(course.data.get_int('gnum')))
+                score_data.set_attribute('cflg', str(self.db_to_game_status(course.data.get_int('clear_status'))))
+
+        # Ninja ranking
+        for ninja_rank in achievements:
+            if ninja_rank.type != 'ninja_rank':
+                continue
+
+            ninja_rank_node = Node.void('ninja_rank')
+            root.add_child(ninja_rank_node)
+            ninja_rank_node.set_attribute('style', str(ninja_rank.id))
+            ninja_rank_node.add_child(Node.s32_array('rank', ninja_rank.data.get_int_array('rank', 13)))
+            ninja_rank_node.add_child(Node.s32_array('point', ninja_rank.data.get_int_array('point', 13)))
+
+        # SINOBUZ Den event
+        event1_dict = profile.get_dict('event1')
+        event1 = Node.void('event1')
+        root.add_child(event1)
+        event1.set_attribute('last_select_map', str(event1_dict.get_int('last_select_map')))
+        event1.set_attribute('hold_rice', str(event1_dict.get_int('hold_rice')))
+        event1.set_attribute('tax_rice', str(event1_dict.get_int('tax_rice')))
+        event1.set_attribute('tips_list', str(event1_dict.get_int('tips_list')))
+
+        for map_data in achievements:
+            if map_data.type != 'map_data':
+                continue
+
+            map_data_node = Node.void('map_data')
+            event1.add_child(map_data_node)
+            map_data_node.set_attribute('map_id', str(map_data.id))
+            map_data_node.set_attribute('play_num', str(map_data.data.get_int('play_num')))
+            map_data_node.set_attribute('progress', str(map_data.data.get_int('progress')))
+            map_data_node.set_attribute('battle_point', str(map_data.data.get_int('battle_point')))
+            map_data_node.set_attribute('rice_point', str(map_data.data.get_int('rice_point')))
+            map_data_node.set_attribute('is_clear', '1' if map_data.data.get_bool('is_clear') else '0')
+            map_data_node.add_child(Node.binary('ninjyutsu', map_data.data.get_bytes('ninjyutsu')))
+            map_data_node.add_child(Node.binary('map_card_damage', map_data.data.get_bytes('map_card_damage')))
+            map_data_node.add_child(Node.binary('map_card_clear', map_data.data.get_bytes('map_card_clear')))
+
+        # Shichikenden event
+        event2_dict = profile.get_dict('event2')
+        event2 = Node.void('event2')
+        root.add_child(event2)
+        event2.set_attribute('play_num', str(event2_dict.get_int('play_num')))
+        event2.set_attribute('chakra_point', str(event2_dict.get_int('chakra_point')))
+        event2.set_attribute('last_select_ryuha', str(event2_dict.get_int('last_select_ryuha')))
+        event2.add_child(Node.binary('last_select_dojo', event2_dict.get_bytes('last_select_dojo', b'\0' * 12)))
+        event2.add_child(Node.binary('enemy_damage', event2_dict.get_bytes('enemy_damage', b'\0' * 532)))
+
+        # OMES Data
+        omes_dict = profile.get_dict('omes')
+        onemore_data = Node.void('onemore_data')
+        root.add_child(onemore_data)
+        onemore_data.set_attribute('defeat_0', str(omes_dict.get_int('defeat_0')))
+        onemore_data.set_attribute('defeat_1', str(omes_dict.get_int('defeat_1')))
+        onemore_data.set_attribute('defeat_2', str(omes_dict.get_int('defeat_2')))
+        onemore_data.set_attribute('defeat_3', str(omes_dict.get_int('defeat_3')))
+        onemore_data.set_attribute('defeat_4', str(omes_dict.get_int('defeat_4')))
+        onemore_data.set_attribute('defeat_5', str(omes_dict.get_int('defeat_5')))
+        onemore_data.set_attribute('defeat_6', str(omes_dict.get_int('defeat_6')))
+        onemore_data.set_attribute('challenge_num_n', str(omes_dict.get_int('challenge_num_n')))
+        onemore_data.set_attribute('challenge_num_h', str(omes_dict.get_int('challenge_num_h')))
+        onemore_data.set_attribute('challenge_num_a', str(omes_dict.get_int('challenge_num_a')))
+
+        # If the user joined a particular shop, let the game know.
+        if 'shop_location' in profile:
+            shop_id = profile.get_int('shop_location')
+            machine = self.get_machine_by_id(shop_id)
+            if machine is not None:
+                join_shop = Node.void('join_shop')
+                root.add_child(join_shop)
+                join_shop.set_attribute('joinflg', '1')
+                join_shop.set_attribute('join_cflg', '1')
+                join_shop.set_attribute('join_id', ID.format_machine_id(machine.id))
+                join_shop.set_attribute('join_name', machine.name)
+
+        # Step up mode
+        step_dict = profile.get_dict('step')
+        step = Node.void('step')
+        root.add_child(step)
+        step.set_attribute('enemy_damage', str(step_dict.get_int('enemy_damage')))
+        step.set_attribute('progress', str(step_dict.get_int('progress')))
+        step.set_attribute('enemy_defeat_flg', str(step_dict.get_int('enemy_defeat_flg')))
+        step.set_attribute('sp_level', str(step_dict.get_int('sp_level')))
+        step.set_attribute('dp_level', str(step_dict.get_int('dp_level')))
+        step.set_attribute('sp_mplay', str(step_dict.get_int('sp_mplay')))
+        step.set_attribute('dp_mplay', str(step_dict.get_int('dp_mplay')))
+
+        # Daily recommendations
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'dailies')
+        if entry is not None:
+            packinfo = Node.void('packinfo')
+            root.add_child(packinfo)
+
+            pack_id = int(entry['start_time'] / 86400)
+            packinfo.set_attribute('pack_id', str(pack_id))
+            packinfo.set_attribute('music_0', str(entry['music'][0]))
+            packinfo.set_attribute('music_1', str(entry['music'][1]))
+            packinfo.set_attribute('music_2', str(entry['music'][2]))
+        else:
+            # No dailies :(
+            pack_id = None
+
+        # Tran medals and shit
+        achievement_node = Node.void('achievements')
+        root.add_child(achievement_node)
+
+        # Dailies
+        if pack_id is None:
+            achievement_node.set_attribute('pack', '0')
+            achievement_node.set_attribute('pack_comp', '0')
+        else:
+            daily_played = self.data.local.user.get_achievement(self.game, self.version, userid, pack_id, 'daily')
+            if daily_played is None:
+                daily_played = ValidatedDict()
+            achievement_node.set_attribute('pack', str(daily_played.get_int('pack_flg')))
+            achievement_node.set_attribute('pack_comp', str(daily_played.get_int('pack_comp')))
+
+        # Weeklies
+        achievement_node.set_attribute('last_weekly', str(profile.get_int('last_weekly')))
+        achievement_node.set_attribute('weekly_num', str(profile.get_int('weekly_num')))
+
+        # Prefecture visit flag
+        achievement_node.set_attribute('visit_flg', str(profile.get_int('visit_flg')))
+
+        # Number of rivals beaten
+        achievement_node.set_attribute('rival_crush', str(profile.get_int('rival_crush')))
+
+        # Tran medals
+        achievement_node.add_child(Node.s64_array('trophy', profile.get_int_array('trophy', 10)))
+
+        # Track deller
+        deller = Node.void('deller')
+        root.add_child(deller)
+        deller.set_attribute('deller', str(profile.get_int('deller')))
+        deller.set_attribute('rate', '0')
+
+        # Orb data
+        orb_data = Node.void('orb_data')
+        root.add_child(orb_data)
+        orb_data.set_attribute('rest_orb', str(profile.get_int('orbs')))
+
+        # Expert points
+        expert_point = Node.void('expert_point')
+        root.add_child(expert_point)
+        for rank in achievements:
+            if rank.type == 'expert_point':
+                detail = Node.void('detail')
+                expert_point.add_child(detail)
+                detail.set_attribute('course_id', str(rank.id))
+                detail.set_attribute('n_point', str(rank.data.get_int('normal_points')))
+                detail.set_attribute('h_point', str(rank.data.get_int('hyper_points')))
+                detail.set_attribute('a_point', str(rank.data.get_int('another_points')))
+
+        nostalgia = Node.void('nostalgia_open')
+        root.add_child(nostalgia)
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Track play counts
+        cltype = int(request.attribute('cltype'))
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            play_stats.increment_int('single_plays')
+        if cltype == self.GAME_CLTYPE_DOUBLE:
+            play_stats.increment_int('double_plays')
+
+        # Track DJ points
+        play_stats.replace_int('single_dj_points', int(request.attribute('s_achi')))
+        play_stats.replace_int('double_dj_points', int(request.attribute('d_achi')))
+
+        # Profile settings
+        newprofile.replace_int('mode', int(request.attribute('mode')))
+        newprofile.replace_int('pmode', int(request.attribute('pmode')))
+        newprofile.replace_int('rtype', int(request.attribute('rtype')))
+        newprofile.replace_int('s_lift', int(request.attribute('s_lift')))
+        newprofile.replace_int('d_lift', int(request.attribute('d_lift')))
+        newprofile.replace_int('sp_opt', int(request.attribute('sp_opt')))
+        newprofile.replace_int('dp_opt', int(request.attribute('dp_opt')))
+        newprofile.replace_int('dp_opt2', int(request.attribute('dp_opt2')))
+        newprofile.replace_int('gpos', int(request.attribute('gpos')))
+        newprofile.replace_int('s_sorttype', int(request.attribute('s_sorttype')))
+        newprofile.replace_int('d_sorttype', int(request.attribute('d_sorttype')))
+        newprofile.replace_int('s_pace', int(request.attribute('s_pace')))
+        newprofile.replace_int('d_pace', int(request.attribute('d_pace')))
+        newprofile.replace_int('s_gno', int(request.attribute('s_gno')))
+        newprofile.replace_int('d_gno', int(request.attribute('d_gno')))
+        newprofile.replace_int('s_gtype', int(request.attribute('s_gtype')))
+        newprofile.replace_int('d_gtype', int(request.attribute('d_gtype')))
+        newprofile.replace_int('s_sdlen', int(request.attribute('s_sdlen')))
+        newprofile.replace_int('d_sdlen', int(request.attribute('d_sdlen')))
+        newprofile.replace_int('s_sdtype', int(request.attribute('s_sdtype')))
+        newprofile.replace_int('d_sdtype', int(request.attribute('d_sdtype')))
+        newprofile.replace_int('s_timing', int(request.attribute('s_timing')))
+        newprofile.replace_int('d_timing', int(request.attribute('d_timing')))
+        newprofile.replace_float('s_notes', float(request.attribute('s_notes')))
+        newprofile.replace_float('d_notes', float(request.attribute('d_notes')))
+        newprofile.replace_int('s_judge', int(request.attribute('s_judge')))
+        newprofile.replace_int('d_judge', int(request.attribute('d_judge')))
+        newprofile.replace_float('s_hispeed', float(request.attribute('s_hispeed')))
+        newprofile.replace_float('d_hispeed', float(request.attribute('d_hispeed')))
+        newprofile.replace_int('s_disp_judge', int(request.attribute('s_disp_judge')))
+        newprofile.replace_int('d_disp_judge', int(request.attribute('d_disp_judge')))
+        newprofile.replace_int('s_opstyle', int(request.attribute('s_opstyle')))
+        newprofile.replace_int('d_opstyle', int(request.attribute('d_opstyle')))
+        newprofile.replace_int('s_exscore', int(request.attribute('s_exscore')))
+        newprofile.replace_int('d_exscore', int(request.attribute('d_exscore')))
+        newprofile.replace_int('s_graph_score', int(request.attribute('s_graph_score')))
+        newprofile.replace_int('d_graph_score', int(request.attribute('d_graph_score')))
+
+        # Update judge window adjustments per-machine
+        judge_dict = newprofile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+        machine_judge.replace_int('single', int(request.attribute('s_judgeAdj')))
+        machine_judge.replace_int('double', int(request.attribute('d_judgeAdj')))
+        judge_dict.replace_dict(self.config['machine']['pcbid'], machine_judge)
+        newprofile.replace_dict('machine_judge_adjust', judge_dict)
+
+        # Secret flags saving
+        secret = request.child('secret')
+        if secret is not None:
+            secret_dict = newprofile.get_dict('secret')
+            secret_dict.replace_int_array('flg1', 3, secret.child_value('flg1'))
+            secret_dict.replace_int_array('flg2', 3, secret.child_value('flg2'))
+            secret_dict.replace_int_array('flg3', 3, secret.child_value('flg3'))
+            newprofile.replace_dict('secret', secret_dict)
+
+        # Basic achievements
+        achievements = request.child('achievements')
+        if achievements is not None:
+            newprofile.replace_int('visit_flg', int(achievements.attribute('visit_flg')))
+            newprofile.replace_int('last_weekly', int(achievements.attribute('last_weekly')))
+            newprofile.replace_int('weekly_num', int(achievements.attribute('weekly_num')))
+
+            pack_id = int(achievements.attribute('pack_id'))
+            if pack_id > 0:
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    pack_id,
+                    'daily',
+                    {
+                        'pack_flg': int(achievements.attribute('pack_flg')),
+                        'pack_comp': int(achievements.attribute('pack_comp')),
+                    },
+                )
+
+            trophies = achievements.child('trophy')
+            if trophies is not None:
+                # We only load the first 10 in profile load.
+                newprofile.replace_int_array('trophy', 10, trophies.value[:10])
+
+        # Deller saving
+        deller = request.child('deller')
+        if deller is not None:
+            newprofile.replace_int('deller', newprofile.get_int('deller') + int(deller.attribute('deller')))
+
+        # Secret course expert point saving
+        expert_point = request.child('expert_point')
+        if expert_point is not None:
+            courseid = int(expert_point.attribute('course_id'))
+
+            # Update achievement to track expert points
+            expert_point_achievement = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                courseid,
+                'expert_point',
+            )
+            if expert_point_achievement is None:
+                expert_point_achievement = ValidatedDict()
+            expert_point_achievement.replace_int(
+                'normal_points',
+                int(expert_point.attribute('n_point')),
+            )
+            expert_point_achievement.replace_int(
+                'hyper_points',
+                int(expert_point.attribute('h_point')),
+            )
+            expert_point_achievement.replace_int(
+                'another_points',
+                int(expert_point.attribute('a_point')),
+            )
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                courseid,
+                'expert_point',
+                expert_point_achievement,
+            )
+
+        # Favorites saving
+        for favorite in request.children:
+            singles = []
+            doubles = []
+            name = None
+            if favorite.name in ['favorite', 'extra_favorite']:
+                if favorite.name == 'favorite':
+                    name = 'favorite1'
+                elif favorite.name == 'extra_favorite':
+                    folder = favorite.attribute('folder_id')
+                    if folder == '0':
+                        name = 'favorite2'
+                    if folder == '1':
+                        name = 'favorite3'
+                if name is None:
+                    continue
+
+                single_music_bin = favorite.child_value('sp_mlist')
+                single_chart_bin = favorite.child_value('sp_clist')
+                double_music_bin = favorite.child_value('dp_mlist')
+                double_chart_bin = favorite.child_value('dp_clist')
+
+                for i in range(self.FAVORITE_LIST_LENGTH):
+                    singles.append({
+                        'id': struct.unpack('<L', single_music_bin[(i * 4):((i + 1) * 4)])[0],
+                        'chart': struct.unpack('B', single_chart_bin[i:(i + 1)])[0],
+                    })
+                    doubles.append({
+                        'id': struct.unpack('<L', double_music_bin[(i * 4):((i + 1) * 4)])[0],
+                        'chart': struct.unpack('B', double_chart_bin[i:(i + 1)])[0],
+                    })
+
+            # Filter out empty charts
+            singles = [single for single in singles if single['id'] != 0]
+            doubles = [double for double in doubles if double['id'] != 0]
+
+            newprofile.replace_dict(
+                name,
+                {
+                    'single': singles,
+                    'double': doubles,
+                },
+            )
+
+        # Ninja rank saving
+        for ninja_rank in request.children:
+            if ninja_rank.name != 'ninja_rank':
+                continue
+
+            rankid = int(ninja_rank.attribute('style'))
+            rank = ninja_rank.child_value('rank')
+            point = ninja_rank.child_value('point')
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                rankid,
+                'ninja_rank',
+                {
+                    'rank': rank,
+                    'point': point,
+                }
+            )
+
+        # SINOBUZ Den Event Saving
+        event1 = request.child('event1')
+        if event1 is not None:
+            event1_dict = newprofile.get_dict('event1')
+            last_select_map = int(event1.attribute('last_select_map'))
+            event1_dict.replace_int('hold_rice', int(event1.attribute('hold_rice')))
+            event1_dict.replace_int('tax_rice', int(event1.attribute('tax_rice')))
+            event1_dict.replace_int('tips_list', int(event1.attribute('tipls_read')))
+
+            # Save any map data, also see if we need to update last_select_map
+            for map_data in event1.children:
+                if map_data.name != 'map_data':
+                    continue
+
+                # Update the map's progress in the DB
+                mapid = int(map_data.attribute('map_id'))
+                play_num = int(map_data.attribute('play_num'))
+                progress = int(map_data.attribute('progress'))
+                battle_point = int(map_data.attribute('battle_point'))
+                rice_point = int(map_data.attribute('rice_point'))
+                is_clear = map_data.child_value('is_clear') or False
+                ninjyutsu = map_data.child_value('ninjyutsu')
+                card_damage = map_data.child_value('card_damage')
+                card_clear = map_data.child_value('card_clear')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    mapid,
+                    'map_data',
+                    {
+                        'play_num': play_num,
+                        'progress': progress,
+                        'battle_point': battle_point,
+                        'rice_point': rice_point,
+                        'is_clear': is_clear,
+                        'ninjyutsu': ninjyutsu,
+                        'map_card_damage': card_damage,
+                        'map_card_clear': card_clear,
+                    }
+                )
+
+                # If they cleared this map, then we should be at least onto the next one.
+                if is_clear:
+                    last_select_map = max(last_select_map, mapid + 1)
+
+            event1_dict.replace_int('last_select_map', last_select_map)
+            newprofile.replace_dict('event1', event1_dict)
+
+        # Shichikenden Event Saving
+        event2 = request.child('event2')
+        if event2 is not None:
+            event2_dict = newprofile.get_dict('event2')
+            event2_dict.replace_int('play_num', int(event2.attribute('play_num')))
+            event2_dict.replace_int('last_select_ryuha', int(event2.attribute('last_select_ryuha')))
+            event2_dict.replace_int('chakra_point', int(event2.attribute('chakra_point')))
+            event2_dict.replace_bytes('last_select_dojo', event2.child_value('last_select_dojo'))
+            event2_dict.replace_bytes('enemy_damage', event2.child_value('enemy_damage'))
+            newprofile.replace_dict('event2', event2_dict)
+
+        # Step-up mode
+        step = request.child('step')
+        if step is not None:
+            step_dict = newprofile.get_dict('step')
+            step_dict.replace_int('enemy_damage', int(step.attribute('enemy_damage')))
+            step_dict.replace_int('progress', int(step.attribute('progress')))
+            step_dict.replace_int('enemy_defeat_flg', int(step.attribute('enemy_defeat_flg')))
+            step_dict.replace_int('sp_level', int(step.attribute('sp_level')))
+            step_dict.replace_int('dp_level', int(step.attribute('dp_level')))
+            step_dict.replace_int('sp_mplay', int(step.attribute('sp_mplay')))
+            step_dict.replace_int('dp_mplay', int(step.attribute('dp_mplay')))
+            newprofile.replace_dict('step', step_dict)
+
+        # QPro equip in step-up mode
+        qpro_equip = request.child('qpro_equip')
+        if qpro_equip is not None:
+            qpro_dict = newprofile.get_dict('qpro')
+            qpro_dict.replace_int('head', int(qpro_equip.attribute('head')))
+            qpro_dict.replace_int('hair', int(qpro_equip.attribute('hair')))
+            qpro_dict.replace_int('face', int(qpro_equip.attribute('face')))
+            qpro_dict.replace_int('hand', int(qpro_equip.attribute('hand')))
+            qpro_dict.replace_int('body', int(qpro_equip.attribute('body')))
+            newprofile.replace_dict('qpro', qpro_dict)
+
+        # Qpro secret unlocks in step-up mode
+        qpro_secret = request.child('qpro_secret')
+        if qpro_secret is not None:
+            qpro_secret_dict = newprofile.get_dict('qpro_secret')
+            qpro_secret_dict.replace_int_array('head', 5, qpro_secret.child_value('head'))
+            qpro_secret_dict.replace_int_array('hair', 5, qpro_secret.child_value('hair'))
+            qpro_secret_dict.replace_int_array('face', 5, qpro_secret.child_value('face'))
+            qpro_secret_dict.replace_int_array('body', 5, qpro_secret.child_value('body'))
+            qpro_secret_dict.replace_int_array('hand', 5, qpro_secret.child_value('hand'))
+            newprofile.replace_dict('qpro_secret', qpro_secret_dict)
+
+        # Orb data saving
+        orb_data = request.child('orb_data')
+        if orb_data is not None:
+            orbs = newprofile.get_int('orbs')
+            orbs = orbs + int(orb_data.attribute('add_orb'))
+            if orb_data.child_value('use_vip_pass'):
+                orbs = 0
+            newprofile.replace_int('orbs', orbs)
+
+        # OMES Tracking
+        onemore_data = request.child('onemore_data')
+        if onemore_data is not None:
+            omes_dict = newprofile.get_dict('omes')
+            omes_dict.replace_int('defeat_0', int(onemore_data.attribute('defeat_0')))
+            omes_dict.replace_int('defeat_1', int(onemore_data.attribute('defeat_1')))
+            omes_dict.replace_int('defeat_2', int(onemore_data.attribute('defeat_2')))
+            omes_dict.replace_int('defeat_3', int(onemore_data.attribute('defeat_3')))
+            omes_dict.replace_int('defeat_4', int(onemore_data.attribute('defeat_4')))
+            omes_dict.replace_int('defeat_5', int(onemore_data.attribute('defeat_5')))
+            omes_dict.replace_int('defeat_6', int(onemore_data.attribute('defeat_6')))
+            omes_dict.replace_int('challenge_num_n', int(onemore_data.attribute('challenge_num_n')))
+            omes_dict.replace_int('challenge_num_h', int(onemore_data.attribute('challenge_num_h')))
+            omes_dict.replace_int('challenge_num_a', int(onemore_data.attribute('challenge_num_a')))
+            newprofile.replace_dict('omes', omes_dict)
+
+        # Keep track of play statistics across all mixes
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/iidx/spada.py b/bemani/backend/iidx/spada.py
new file mode 100644
index 0000000..03ad84c
--- /dev/null
+++ b/bemani/backend/iidx/spada.py
@@ -0,0 +1,1629 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+import struct
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.backend.iidx.tricoro import IIDXTricoro
+
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import Data, UserID
+from bemani.protocol import Node
+
+
+class IIDXSpada(IIDXBase):
+
+    name = 'Beatmania IIDX SPADA'
+    version = VersionConstants.IIDX_SPADA
+
+    GAME_CLTYPE_SINGLE = 0
+    GAME_CLTYPE_DOUBLE = 1
+
+    DAN_STAGES_SINGLE = 4
+    DAN_STAGES_DOUBLE = 3
+
+    GAME_CLEAR_STATUS_NO_PLAY = 0
+    GAME_CLEAR_STATUS_FAILED = 1
+    GAME_CLEAR_STATUS_ASSIST_CLEAR = 2
+    GAME_CLEAR_STATUS_EASY_CLEAR = 3
+    GAME_CLEAR_STATUS_CLEAR = 4
+    GAME_CLEAR_STATUS_HARD_CLEAR = 5
+    GAME_CLEAR_STATUS_EX_HARD_CLEAR = 6
+    GAME_CLEAR_STATUS_FULL_COMBO = 7
+
+    GAME_GHOST_TYPE_RIVAL = 1
+    GAME_GHOST_TYPE_GLOBAL_TOP = 2
+    GAME_GHOST_TYPE_GLOBAL_AVERAGE = 3
+    GAME_GHOST_TYPE_LOCAL_TOP = 4
+    GAME_GHOST_TYPE_LOCAL_AVERAGE = 5
+    GAME_GHOST_TYPE_DAN_TOP = 6
+    GAME_GHOST_TYPE_DAN_AVERAGE = 7
+    GAME_GHOST_TYPE_RIVAL_TOP = 8
+    GAME_GHOST_TYPE_RIVAL_AVERAGE = 9
+
+    GAME_GHOST_LENGTH = 64
+
+    GAME_SP_DAN_RANK_7_KYU = 0
+    GAME_SP_DAN_RANK_6_KYU = 1
+    GAME_SP_DAN_RANK_5_KYU = 2
+    GAME_SP_DAN_RANK_4_KYU = 3
+    GAME_SP_DAN_RANK_3_KYU = 4
+    GAME_SP_DAN_RANK_2_KYU = 5
+    GAME_SP_DAN_RANK_1_KYU = 6
+    GAME_SP_DAN_RANK_1_DAN = 7
+    GAME_SP_DAN_RANK_2_DAN = 8
+    GAME_SP_DAN_RANK_3_DAN = 9
+    GAME_SP_DAN_RANK_4_DAN = 10
+    GAME_SP_DAN_RANK_5_DAN = 11
+    GAME_SP_DAN_RANK_6_DAN = 12
+    GAME_SP_DAN_RANK_7_DAN = 13
+    GAME_SP_DAN_RANK_8_DAN = 14
+    GAME_SP_DAN_RANK_9_DAN = 15
+    GAME_SP_DAN_RANK_10_DAN = 16
+    GAME_SP_DAN_RANK_KAIDEN = 17
+
+    GAME_DP_DAN_RANK_5_KYU = 0
+    GAME_DP_DAN_RANK_4_KYU = 1
+    GAME_DP_DAN_RANK_3_KYU = 2
+    GAME_DP_DAN_RANK_2_KYU = 3
+    GAME_DP_DAN_RANK_1_KYU = 4
+    GAME_DP_DAN_RANK_1_DAN = 5
+    GAME_DP_DAN_RANK_2_DAN = 6
+    GAME_DP_DAN_RANK_3_DAN = 7
+    GAME_DP_DAN_RANK_4_DAN = 8
+    GAME_DP_DAN_RANK_5_DAN = 9
+    GAME_DP_DAN_RANK_6_DAN = 10
+    GAME_DP_DAN_RANK_7_DAN = 11
+    GAME_DP_DAN_RANK_8_DAN = 12
+    GAME_DP_DAN_RANK_9_DAN = 13
+    GAME_DP_DAN_RANK_10_DAN = 14
+    GAME_DP_DAN_RANK_KAIDEN = 15
+
+    FAVORITE_LIST_LENGTH = 20
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXTricoro(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert dailies into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'daily_charts', 'daily'):
+            # Generate a new list of three dailies.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = list(set([song.id for song in data.local.music.get_all_songs(cls.game, cls.version)]))
+            daily_songs = random.sample(all_songs, 3)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'dailies',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': daily_songs,
+                },
+            )
+            events.append((
+                'iidx_daily_charts',
+                {
+                    'version': cls.version,
+                    'music': daily_songs,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'daily_charts', 'daily')
+        return events
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Global Shop Ranking',
+                    'tip': 'Return network-wide ranking instead of shop ranking on results screen.',
+                    'category': 'game_config',
+                    'setting': 'global_shop_ranking',
+                },
+                {
+                    'name': 'Events In Omnimix',
+                    'tip': 'Allow events to be enabled at all for Omnimix.',
+                    'category': 'game_config',
+                    'setting': 'omnimix_events_enabled',
+                },
+            ],
+        }
+
+    def db_to_game_status(self, db_status: int) -> int:
+        return {
+            self.CLEAR_STATUS_NO_PLAY: self.GAME_CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED: self.GAME_CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR: self.GAME_CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR: self.GAME_CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR: self.GAME_CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR: self.GAME_CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR: self.GAME_CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO: self.GAME_CLEAR_STATUS_FULL_COMBO,
+        }[db_status]
+
+    def game_to_db_status(self, game_status: int) -> int:
+        return {
+            self.GAME_CLEAR_STATUS_NO_PLAY: self.CLEAR_STATUS_NO_PLAY,
+            self.GAME_CLEAR_STATUS_FAILED: self.CLEAR_STATUS_FAILED,
+            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.GAME_CLEAR_STATUS_EASY_CLEAR: self.CLEAR_STATUS_EASY_CLEAR,
+            self.GAME_CLEAR_STATUS_CLEAR: self.CLEAR_STATUS_CLEAR,
+            self.GAME_CLEAR_STATUS_HARD_CLEAR: self.CLEAR_STATUS_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_FULL_COMBO: self.CLEAR_STATUS_FULL_COMBO,
+        }[game_status]
+
+    def db_to_game_rank(self, db_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if db_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_SP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_SP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_SP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_SP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_SP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_SP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_SP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_SP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_SP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_SP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_SP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_SP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_SP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_SP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_SP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_SP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_SP_DAN_RANK_10_DAN,
+                self.DAN_RANK_KAIDEN: self.GAME_SP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.DAN_RANK_5_KYU: self.GAME_DP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_DP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_DP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_DP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_DP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_DP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_DP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_DP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_DP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_DP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_DP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_DP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_DP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_DP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_DP_DAN_RANK_10_DAN,
+                self.DAN_RANK_KAIDEN: self.GAME_DP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def game_to_db_rank(self, game_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if game_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.GAME_SP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_SP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_SP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_SP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_SP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_SP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_SP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_SP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_SP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_SP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_SP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_SP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_SP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_SP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_SP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_SP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_SP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_SP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.GAME_DP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_DP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_DP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_DP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_DP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_DP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_DP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_DP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_DP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_DP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_DP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_DP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_DP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_DP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_DP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_DP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def handle_IIDX21shop_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getname':
+            root = Node.void('IIDX21shop')
+            root.set_attribute('cls_opt', '0')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            root.set_attribute('opname', machine.name)
+            root.set_attribute('pid', '51')
+            return root
+
+        if method == 'savename':
+            self.update_machine_name(request.attribute('opname'))
+            root = Node.void('IIDX21shop')
+            return root
+
+        if method == 'sentinfo':
+            root = Node.void('IIDX21shop')
+            return root
+
+        if method == 'getconvention':
+            root = Node.void('IIDX21shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            root.set_attribute('music_0', str(course.get_int('music_0', 20032)))
+            root.set_attribute('music_1', str(course.get_int('music_1', 20009)))
+            root.set_attribute('music_2', str(course.get_int('music_2', 20015)))
+            root.set_attribute('music_3', str(course.get_int('music_3', 20064)))
+            root.add_child(Node.bool('valid', course.get_bool('valid')))
+            return root
+
+        if method == 'setconvention':
+            root = Node.void('IIDX21shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = ValidatedDict()
+                course.replace_int('music_0', request.child_value('music_0'))
+                course.replace_int('music_1', request.child_value('music_1'))
+                course.replace_int('music_2', request.child_value('music_2'))
+                course.replace_int('music_3', request.child_value('music_3'))
+                course.replace_bool('valid', request.child_value('valid'))
+                self.data.local.machine.put_settings(machine.arcade, self.game, self.music_version, 'shop_course', course)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX21ranking_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getranker':
+            root = Node.void('IIDX21ranking')
+            chart = int(request.attribute('clid'))
+            if chart not in [
+                self.CHART_TYPE_N7,
+                self.CHART_TYPE_H7,
+                self.CHART_TYPE_A7,
+                self.CHART_TYPE_N14,
+                self.CHART_TYPE_H14,
+                self.CHART_TYPE_A14,
+            ]:
+                # Chart type 6 is presumably beginner mode, but it crashes the game
+                return root
+
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            if not course.get_bool('valid'):
+                # Shop course not enabled or not present
+                return root
+
+            convention = Node.void('convention')
+            root.add_child(convention)
+            convention.set_attribute('clid', str(chart))
+            convention.set_attribute('update_date', str(Time.now() * 1000))
+
+            # Grab all scores for each of the four songs, filter out people who haven't
+            # set us as their arcade and then return the top 20 scores (adding all 4 songs).
+            songids = [
+                course.get_int('music_0'),
+                course.get_int('music_1'),
+                course.get_int('music_2'),
+                course.get_int('music_3'),
+            ]
+
+            totalscores: Dict[UserID, int] = {}
+            profiles: Dict[UserID, ValidatedDict] = {}
+            for songid in songids:
+                scores = self.data.local.music.get_all_scores(
+                    self.game,
+                    self.music_version,
+                    songid=songid,
+                    songchart=chart,
+                )
+
+                for score in scores:
+                    if score[0] not in totalscores:
+                        totalscores[score[0]] = 0
+                        profile = self.get_any_profile(score[0])
+                        if profile is None:
+                            profile = ValidatedDict()
+                        profiles[score[0]] = profile
+
+                    totalscores[score[0]] += score[1].points
+
+            topscores = sorted(
+                [
+                    (totalscores[userid], profiles[userid])
+                    for userid in totalscores
+                    if self.user_joined_arcade(machine, profiles[userid])
+                ],
+                key=lambda tup: tup[0],
+                reverse=True,
+            )[:20]
+
+            rank = 0
+            for topscore in topscores:
+                rank = rank + 1
+
+                detail = Node.void('detail')
+                convention.add_child(detail)
+                detail.set_attribute('name', topscore[1].get_str('name'))
+                detail.set_attribute('rank', str(rank))
+                detail.set_attribute('score', str(topscore[0]))
+                detail.set_attribute('pid', str(topscore[1].get_int('pid')))
+
+                qpro = topscore[1].get_dict('qpro')
+                detail.set_attribute('head', str(qpro.get_int('head')))
+                detail.set_attribute('hair', str(qpro.get_int('hair')))
+                detail.set_attribute('face', str(qpro.get_int('face')))
+                detail.set_attribute('body', str(qpro.get_int('body')))
+                detail.set_attribute('hand', str(qpro.get_int('hand')))
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX21music_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'crate':
+            root = Node.void('IIDX21music')
+            attempts = self.get_clear_rates()
+
+            all_songs = list(set([song.id for song in self.data.local.music.get_all_songs(self.game, self.music_version)]))
+            for song in all_songs:
+                clears = []
+                fcs = []
+
+                for chart in [0, 1, 2, 3, 4, 5]:
+                    placed = False
+                    if song in attempts and chart in attempts[song]:
+                        values = attempts[song][chart]
+                        if values['total'] > 0:
+                            clears.append(int((100 * values['clears']) / values['total']))
+                            fcs.append(int((100 * values['fcs']) / values['total']))
+                            placed = True
+                    if not placed:
+                        clears.append(101)
+                        fcs.append(101)
+
+                clearnode = Node.u8_array('c', clears + fcs)
+                clearnode.set_attribute('mid', str(song))
+                root.add_child(clearnode)
+
+            return root
+
+        if method == 'getrank':
+            cltype = int(request.attribute('cltype'))
+
+            root = Node.void('IIDX21music')
+            style = Node.void('style')
+            root.add_child(style)
+            style.set_attribute('type', str(cltype))
+
+            for rivalid in [-1, 0, 1, 2, 3, 4]:
+                if rivalid == -1:
+                    attr = 'iidxid'
+                else:
+                    attr = 'iidxid{}'.format(rivalid)
+
+                try:
+                    extid = int(request.attribute(attr))
+                except Exception:
+                    # Invalid extid
+                    continue
+                userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if userid is not None:
+                    scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+
+                    # Grab score data for user/rival
+                    scoredata = self.make_score_struct(
+                        scores,
+                        self.CLEAR_TYPE_SINGLE if cltype == self.GAME_CLTYPE_SINGLE else self.CLEAR_TYPE_DOUBLE,
+                        rivalid,
+                    )
+                    for s in scoredata:
+                        root.add_child(Node.s16_array('m', s))
+
+                    # Grab most played for user/rival
+                    most_played = [
+                        play[0] for play in
+                        self.data.local.music.get_most_played(self.game, self.music_version, userid, 20)
+                    ]
+                    if len(most_played) < 20:
+                        most_played.extend([0] * (20 - len(most_played)))
+                    best = Node.u16_array('best', most_played)
+                    best.set_attribute('rno', str(rivalid))
+                    root.add_child(best)
+
+                    if rivalid == -1:
+                        # Grab beginner statuses for user only
+                        beginnerdata = self.make_beginner_struct(scores)
+                        for b in beginnerdata:
+                            root.add_child(Node.u16_array('b', b))
+
+            return root
+
+        if method == 'reg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            # See if we need to report global or shop scores
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                global_scores = game_config.get_bool('global_shop_ranking')
+                machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            else:
+                # If we aren't in an arcade, we can only show global scores
+                global_scores = True
+                machine = None
+
+            # First, determine our current ranking before saving the new score
+            all_scores = sorted(
+                self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                key=lambda s: (s[1].points, s[1].timestamp),
+                reverse=True,
+            )
+            all_players = {
+                uid: prof for (uid, prof) in
+                self.get_any_profiles([s[0] for s in all_scores])
+            }
+
+            if not global_scores:
+                all_scores = [
+                    score for score in all_scores
+                    if (
+                        score[0] == userid or
+                        self.user_joined_arcade(machine, all_players[score[0]])
+                    )
+                ]
+
+            # Find our actual index
+            oldindex = None
+            for i in range(len(all_scores)):
+                if all_scores[i][0] == userid:
+                    oldindex = i
+                    break
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+                miss_count = int(request.attribute('mnum'))
+                ghost = request.child_value('ghost')
+                shopid = ID.parse_machine_id(request.attribute('shopconvid'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    chart,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    miss_count,
+                    ghost,
+                    shopid,
+                )
+
+            # Calculate and return statistics about this song
+            root = Node.void('IIDX21music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+            root.set_attribute('rankside', '0')
+
+            if userid is not None:
+                # Shop ranking
+                shopdata = Node.void('shopdata')
+                root.add_child(shopdata)
+                shopdata.set_attribute('rank', '-1' if oldindex is None else str(oldindex + 1))
+
+                # Grab the rank of some other players on this song
+                ranklist = Node.void('ranklist')
+                root.add_child(ranklist)
+
+                all_scores = sorted(
+                    self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: (s[1].points, s[1].timestamp),
+                    reverse=True,
+                )
+                missing_players = [
+                    uid for (uid, _) in all_scores
+                    if uid not in all_players
+                ]
+                for (uid, prof) in self.get_any_profiles(missing_players):
+                    all_players[uid] = prof
+
+                if not global_scores:
+                    all_scores = [
+                        score for score in all_scores
+                        if (
+                            score[0] == userid or
+                            self.user_joined_arcade(machine, all_players[score[0]])
+                        )
+                    ]
+
+                # Find our actual index
+                ourindex = None
+                for i in range(len(all_scores)):
+                    if all_scores[i][0] == userid:
+                        ourindex = i
+                        break
+                if ourindex is None:
+                    raise Exception('Cannot find our own score after saving to DB!')
+                start = ourindex - 4
+                end = ourindex + 4
+                if start < 0:
+                    start = 0
+                if end >= len(all_scores):
+                    end = len(all_scores) - 1
+                relevant_scores = all_scores[start:(end + 1)]
+
+                record_num = start + 1
+                for score in relevant_scores:
+                    profile = all_players[score[0]]
+
+                    data = Node.void('data')
+                    ranklist.add_child(data)
+                    data.set_attribute('iidx_id', str(profile.get_int('extid')))
+                    data.set_attribute('name', profile.get_str('name'))
+
+                    machine_name = ''
+                    if 'shop_location' in profile:
+                        shop_id = profile.get_int('shop_location')
+                        machine = self.get_machine_by_id(shop_id)
+                        if machine is not None:
+                            machine_name = machine.name
+                    data.set_attribute('opname', machine_name)
+                    data.set_attribute('rnum', str(record_num))
+                    data.set_attribute('score', str(score[1].points))
+                    data.set_attribute('clflg', str(self.db_to_game_status(score[1].data.get_int('clear_status'))))
+                    data.set_attribute('pid', str(profile.get_int('pid')))
+                    data.set_attribute('myFlg', '1' if score[0] == userid else '0')
+                    data.set_attribute('update', '0')
+
+                    data.set_attribute('sgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE),
+                    ))
+                    data.set_attribute('dgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE),
+                    ))
+
+                    qpro = profile.get_dict('qpro')
+                    data.set_attribute('head', str(qpro.get_int('head')))
+                    data.set_attribute('hair', str(qpro.get_int('hair')))
+                    data.set_attribute('face', str(qpro.get_int('face')))
+                    data.set_attribute('body', str(qpro.get_int('body')))
+                    data.set_attribute('hand', str(qpro.get_int('hand')))
+
+                    record_num = record_num + 1
+
+            return root
+
+        if method == 'breg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    self.CHART_TYPE_B7,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    -1,
+                    b'',
+                    None,
+                )
+
+            # Return nothing.
+            root = Node.void('IIDX21music')
+            return root
+
+        if method == 'play':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+
+            self.update_score(
+                None,  # No userid since its anonymous
+                musicid,
+                chart,
+                clear_status,
+                0,  # No ex score
+                0,  # No ex score
+                0,  # No miss count
+                None,  # No ghost
+                None,  # No shop for this user
+            )
+
+            # Calculate and return statistics about this song
+            root = Node.void('IIDX21music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+
+            return root
+
+        if method == 'appoint':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            ghost_type = int(request.attribute('ctype'))
+            extid = int(request.attribute('iidxid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            root = Node.void('IIDX21music')
+
+            if userid is not None:
+                # Try to look up previous ghost for user
+                my_score = self.data.remote.music.get_score(self.game, self.music_version, userid, musicid, chart)
+                if my_score is not None:
+                    mydata = Node.binary('mydata', my_score.data.get_bytes('ghost'))
+                    mydata.set_attribute('score', str(my_score.points))
+                    root.add_child(mydata)
+
+                ghost_score = self.get_ghost(
+                    {
+                        self.GAME_GHOST_TYPE_RIVAL: self.GHOST_TYPE_RIVAL,
+                        self.GAME_GHOST_TYPE_GLOBAL_TOP: self.GHOST_TYPE_GLOBAL_TOP,
+                        self.GAME_GHOST_TYPE_GLOBAL_AVERAGE: self.GHOST_TYPE_GLOBAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_LOCAL_TOP: self.GHOST_TYPE_LOCAL_TOP,
+                        self.GAME_GHOST_TYPE_LOCAL_AVERAGE: self.GHOST_TYPE_LOCAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_DAN_TOP: self.GHOST_TYPE_DAN_TOP,
+                        self.GAME_GHOST_TYPE_DAN_AVERAGE: self.GHOST_TYPE_DAN_AVERAGE,
+                        self.GAME_GHOST_TYPE_RIVAL_TOP: self.GHOST_TYPE_RIVAL_TOP,
+                        self.GAME_GHOST_TYPE_RIVAL_AVERAGE: self.GHOST_TYPE_RIVAL_AVERAGE,
+                    }.get(ghost_type, self.GHOST_TYPE_NONE),
+                    request.attribute('subtype'),
+                    self.GAME_GHOST_LENGTH,
+                    musicid,
+                    chart,
+                    userid,
+                )
+
+                # Add ghost score if we support it
+                if ghost_score is not None:
+                    sdata = Node.binary('sdata', ghost_score['ghost'])
+                    sdata.set_attribute('score', str(ghost_score['score']))
+                    if 'name' in ghost_score:
+                        sdata.set_attribute('name', ghost_score['name'])
+                    if 'pid' in ghost_score:
+                        sdata.set_attribute('pid', str(ghost_score['pid']))
+                    if 'extid' in ghost_score:
+                        sdata.set_attribute('riidxid', str(ghost_score['extid']))
+                    root.add_child(sdata)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX21pc_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'common':
+            root = Node.void('IIDX21pc')
+            root.set_attribute('expire', '600')
+
+            # TODO: Hook all of these up to config options I guess?
+            ir = Node.void('ir')
+            root.add_child(ir)
+            ir.set_attribute('beat', '2')
+
+            limit = Node.void('limit')
+            root.add_child(limit)
+            limit.set_attribute('phase', '24')
+
+            # See if we configured event overrides
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                omni_events = game_config.get_bool('omnimix_events_enabled')
+            else:
+                # If we aren't in an arcade, we turn off events
+                omni_events = False
+
+            if self.omnimix and (not omni_events):
+                boss_phase = 0
+            else:
+                # TODO: Figure out what these map to
+                boss_phase = 0
+
+            boss = Node.void('boss')
+            root.add_child(boss)
+            boss.set_attribute('phase', str(boss_phase))
+
+            boss1 = Node.void('boss1')
+            root.add_child(boss1)
+            boss1.set_attribute('phase', '1')
+
+            medal = Node.void('medal')
+            root.add_child(medal)
+            medal.set_attribute('phase', '1')
+
+            vip_black_pass = Node.void('vip_pass_black')
+            root.add_child(vip_black_pass)
+
+            cafe = Node.void('cafe')
+            root.add_child(cafe)
+            cafe.set_attribute('open', '1')
+
+            tricolettepark = Node.void('tricolettepark')
+            root.add_child(tricolettepark)
+            tricolettepark.set_attribute('open', '0')
+
+            tricolettepark_skip = Node.void('tricolettepark_skip')
+            root.add_child(tricolettepark_skip)
+            tricolettepark_skip.set_attribute('phase', '1')
+
+            newsong_another = Node.void('newsong_another')
+            root.add_child(newsong_another)
+            newsong_another.set_attribute('open', '1')
+
+            superstar = Node.void('superstar')
+            root.add_child(superstar)
+            superstar.set_attribute('phase', '1')
+
+            return root
+
+        if method == 'delete':
+            return Node.void('IIDX21pc')
+
+        if method == 'playstart':
+            return Node.void('IIDX21pc')
+
+        if method == 'playend':
+            return Node.void('IIDX21pc')
+
+        if method == 'oldget':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+
+            root = Node.void('IIDX21pc')
+            root.set_attribute('status', '1' if profile is None else '0')
+            return root
+
+        if method == 'getname':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+            if profile is None:
+                raise Exception(
+                    'Should not get here if we have no profile, we should ' +
+                    'have returned \'1\' in the \'oldget\' method above ' +
+                    'which should tell the game not to present a migration.'
+                )
+
+            root = Node.void('IIDX21pc')
+            root.set_attribute('name', profile.get_str('name'))
+            root.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+            root.set_attribute('pid', str(profile.get_int('pid')))
+            return root
+
+        if method == 'takeover':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            newprofile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('IIDX21pc')
+            if newprofile is not None:
+                root.set_attribute('id', str(newprofile.get_int('extid')))
+            return root
+
+        if method == 'reg':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            profile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('IIDX21pc')
+            if profile is not None:
+                root.set_attribute('id', str(profile.get_int('extid')))
+                root.set_attribute('id_str', ID.format_extid(profile.get_int('extid')))
+            return root
+
+        if method == 'get':
+            refid = request.attribute('rid')
+            root = self.get_profile_by_refid(refid)
+            if root is None:
+                root = Node.void('IIDX21pc')
+            return root
+
+        if method == 'save':
+            extid = int(request.attribute('iidxid'))
+            self.put_profile_by_extid(extid, request)
+
+            root = Node.void('IIDX21pc')
+            return root
+
+        if method == 'visit':
+            root = Node.void('IIDX21pc')
+            root.set_attribute('anum', '0')
+            root.set_attribute('pnum', '0')
+            root.set_attribute('sflg', '0')
+            root.set_attribute('pflg', '0')
+            root.set_attribute('aflg', '0')
+            root.set_attribute('snum', '0')
+            return root
+
+        if method == 'shopregister':
+            extid = int(request.child_value('iidx_id'))
+            location = ID.parse_machine_id(request.child_value('location_id'))
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                profile = self.get_profile(userid)
+                if profile is None:
+                    profile = ValidatedDict()
+                profile.replace_int('shop_location', location)
+                self.put_profile(userid, profile)
+
+            root = Node.void('IIDX21pc')
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_IIDX21grade_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'raised':
+            extid = int(request.attribute('iidxid'))
+            cltype = int(request.attribute('gtype'))
+            rank = self.game_to_db_rank(int(request.attribute('gid')), cltype)
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                percent = int(request.attribute('achi'))
+                stages_cleared = int(request.attribute('cflg'))
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    max_stages = self.DAN_STAGES_SINGLE
+                else:
+                    max_stages = self.DAN_STAGES_DOUBLE
+                cleared = stages_cleared == max_stages
+
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    index = self.DAN_RANKING_SINGLE
+                else:
+                    index = self.DAN_RANKING_DOUBLE
+
+                self.update_rank(
+                    userid,
+                    index,
+                    rank,
+                    percent,
+                    cleared,
+                    stages_cleared,
+                )
+
+            # Figure out number of players that played this ranking
+            all_achievements = self.data.local.user.get_all_achievements(self.game, self.version)
+            num_players = 0
+            for [_, ach] in all_achievements:
+                if ach.type != index:
+                    continue
+                if ach.id != rank:
+                    continue
+                num_players = num_players + 1
+
+            root = Node.void('IIDX21grade')
+            root.set_attribute('pnum', str(num_players))
+            return root
+
+        # Invalid method
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('IIDX21pc')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Look up judge window adjustments
+        judge_dict = profile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+
+        # Profile data
+        pcdata = Node.void('pcdata')
+        root.add_child(pcdata)
+        pcdata.set_attribute('id', str(profile.get_int('extid')))
+        pcdata.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+        pcdata.set_attribute('name', profile.get_str('name'))
+        pcdata.set_attribute('pid', str(profile.get_int('pid')))
+        pcdata.set_attribute('spnum', str(play_stats.get_int('single_plays')))
+        pcdata.set_attribute('dpnum', str(play_stats.get_int('double_plays')))
+        pcdata.set_attribute('sach', str(play_stats.get_int('single_dj_points')))
+        pcdata.set_attribute('dach', str(play_stats.get_int('double_dj_points')))
+        pcdata.set_attribute('mode', str(profile.get_int('mode')))
+        pcdata.set_attribute('pmode', str(profile.get_int('pmode')))
+        pcdata.set_attribute('rtype', str(profile.get_int('rtype')))
+        pcdata.set_attribute('sp_opt', str(profile.get_int('sp_opt')))
+        pcdata.set_attribute('dp_opt', str(profile.get_int('dp_opt')))
+        pcdata.set_attribute('dp_opt2', str(profile.get_int('dp_opt2')))
+        pcdata.set_attribute('gpos', str(profile.get_int('gpos')))
+        pcdata.set_attribute('s_sorttype', str(profile.get_int('s_sorttype')))
+        pcdata.set_attribute('d_sorttype', str(profile.get_int('d_sorttype')))
+        pcdata.set_attribute('s_pace', str(profile.get_int('s_pace')))
+        pcdata.set_attribute('d_pace', str(profile.get_int('d_pace')))
+        pcdata.set_attribute('s_gno', str(profile.get_int('s_gno')))
+        pcdata.set_attribute('d_gno', str(profile.get_int('d_gno')))
+        pcdata.set_attribute('s_gtype', str(profile.get_int('s_gtype')))
+        pcdata.set_attribute('d_gtype', str(profile.get_int('d_gtype')))
+        pcdata.set_attribute('s_sdlen', str(profile.get_int('s_sdlen')))
+        pcdata.set_attribute('d_sdlen', str(profile.get_int('d_sdlen')))
+        pcdata.set_attribute('s_sdtype', str(profile.get_int('s_sdtype')))
+        pcdata.set_attribute('d_sdtype', str(profile.get_int('d_sdtype')))
+        pcdata.set_attribute('s_timing', str(profile.get_int('s_timing')))
+        pcdata.set_attribute('d_timing', str(profile.get_int('d_timing')))
+        pcdata.set_attribute('s_notes', str(profile.get_float('s_notes')))
+        pcdata.set_attribute('d_notes', str(profile.get_float('d_notes')))
+        pcdata.set_attribute('s_judge', str(profile.get_int('s_judge')))
+        pcdata.set_attribute('d_judge', str(profile.get_int('d_judge')))
+        pcdata.set_attribute('s_judgeAdj', str(machine_judge.get_int('single')))
+        pcdata.set_attribute('d_judgeAdj', str(machine_judge.get_int('double')))
+        pcdata.set_attribute('s_hispeed', str(profile.get_float('s_hispeed')))
+        pcdata.set_attribute('d_hispeed', str(profile.get_float('d_hispeed')))
+        pcdata.set_attribute('s_liflen', str(profile.get_int('s_lift')))
+        pcdata.set_attribute('d_liflen', str(profile.get_int('d_lift')))
+        pcdata.set_attribute('s_disp_judge', str(profile.get_int('s_disp_judge')))
+        pcdata.set_attribute('d_disp_judge', str(profile.get_int('d_disp_judge')))
+        pcdata.set_attribute('s_opstyle', str(profile.get_int('s_opstyle')))
+        pcdata.set_attribute('d_opstyle', str(profile.get_int('d_opstyle')))
+
+        # If the user joined a particular shop, let the game know.
+        if 'shop_location' in profile:
+            shop_id = profile.get_int('shop_location')
+            machine = self.get_machine_by_id(shop_id)
+            if machine is not None:
+                join_shop = Node.void('join_shop')
+                root.add_child(join_shop)
+                join_shop.set_attribute('joinflg', '1')
+                join_shop.set_attribute('join_cflg', '1')
+                join_shop.set_attribute('join_id', ID.format_machine_id(machine.id))
+                join_shop.set_attribute('join_name', machine.name)
+
+        # Daily recommendations
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'dailies')
+        if entry is not None:
+            packinfo = Node.void('packinfo')
+            root.add_child(packinfo)
+
+            pack_id = int(entry['start_time'] / 86400)
+            packinfo.set_attribute('pack_id', str(pack_id))
+            packinfo.set_attribute('music_0', str(entry['music'][0]))
+            packinfo.set_attribute('music_1', str(entry['music'][1]))
+            packinfo.set_attribute('music_2', str(entry['music'][2]))
+        else:
+            # No dailies :(
+            pack_id = None
+
+        # Track deller
+        deller = Node.void('deller')
+        root.add_child(deller)
+        deller.set_attribute('deller', str(profile.get_int('deller')))
+        deller.set_attribute('rate', '0')
+
+        # Secret flags (shh!)
+        secret_dict = profile.get_dict('secret')
+        secret = Node.void('secret')
+        root.add_child(secret)
+        secret.add_child(Node.s64_array('flg1', secret_dict.get_int_array('flg1', 2)))
+        secret.add_child(Node.s64_array('flg2', secret_dict.get_int_array('flg2', 2)))
+        secret.add_child(Node.s64_array('flg3', secret_dict.get_int_array('flg3', 2)))
+
+        # Tran medals and shit
+        achievements = Node.void('achievements')
+        root.add_child(achievements)
+
+        # Dailies
+        if pack_id is None:
+            achievements.set_attribute('pack', '0')
+            achievements.set_attribute('pack_comp', '0')
+        else:
+            daily_played = self.data.local.user.get_achievement(self.game, self.version, userid, pack_id, 'daily')
+            if daily_played is None:
+                daily_played = ValidatedDict()
+            achievements.set_attribute('pack', str(daily_played.get_int('pack_flg')))
+            achievements.set_attribute('pack_comp', str(daily_played.get_int('pack_comp')))
+
+        # Weeklies
+        achievements.set_attribute('last_weekly', str(profile.get_int('last_weekly')))
+        achievements.set_attribute('weekly_num', str(profile.get_int('weekly_num')))
+
+        # Prefecture visit flag
+        achievements.set_attribute('visit_flg', str(profile.get_int('visit_flg')))
+
+        # Number of rivals beaten
+        achievements.set_attribute('rival_crush', str(profile.get_int('rival_crush')))
+
+        # Tran medals
+        achievements.add_child(Node.s64_array('trophy', profile.get_int_array('trophy', 10)))
+
+        # User settings
+        settings_dict = profile.get_dict('settings')
+        skin = Node.s16_array(
+            'skin',
+            [
+                settings_dict.get_int('frame'),
+                settings_dict.get_int('turntable'),
+                settings_dict.get_int('burst'),
+                settings_dict.get_int('bgm'),
+                settings_dict.get_int('flags'),
+                settings_dict.get_int('towel'),
+                settings_dict.get_int('judge_pos'),
+                settings_dict.get_int('voice'),
+                settings_dict.get_int('noteskin'),
+                settings_dict.get_int('full_combo'),
+                settings_dict.get_int('beam'),
+                settings_dict.get_int('judge'),
+                0,
+                settings_dict.get_int('disable_song_preview'),
+            ],
+        )
+        root.add_child(skin)
+
+        # DAN rankings
+        grade = Node.void('grade')
+        root.add_child(grade)
+        grade.set_attribute('sgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+        grade.set_attribute('dgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+        rankings = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for rank in rankings:
+            if rank.type == self.DAN_RANKING_SINGLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_SINGLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_SINGLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+            if rank.type == self.DAN_RANKING_DOUBLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_DOUBLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_DOUBLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+
+        # Qpro data
+        qpro_dict = profile.get_dict('qpro')
+        root.add_child(Node.u32_array(
+            'qprodata',
+            [
+                qpro_dict.get_int('head'),
+                qpro_dict.get_int('hair'),
+                qpro_dict.get_int('face'),
+                qpro_dict.get_int('hand'),
+                qpro_dict.get_int('body'),
+            ],
+        ))
+
+        # Rivals
+        rlist = Node.void('rlist')
+        root.add_child(rlist)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            rival_type = None
+            if link.type == 'sp_rival':
+                rival_type = '1'
+            elif link.type == 'dp_rival':
+                rival_type = '2'
+            else:
+                # No business with this link type
+                continue
+
+            other_profile = self.get_profile(link.other_userid)
+            if other_profile is None:
+                continue
+            other_play_stats = self.get_play_statistics(link.other_userid)
+
+            rival = Node.void('rival')
+            rlist.add_child(rival)
+            rival.set_attribute('spdp', rival_type)
+            rival.set_attribute('id', str(other_profile.get_int('extid')))
+            rival.set_attribute('id_str', ID.format_extid(other_profile.get_int('extid')))
+            rival.set_attribute('djname', other_profile.get_str('name'))
+            rival.set_attribute('pid', str(other_profile.get_int('pid')))
+            rival.set_attribute('sg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+            rival.set_attribute('dg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+            rival.set_attribute('sa', str(other_play_stats.get_int('single_dj_points')))
+            rival.set_attribute('da', str(other_play_stats.get_int('double_dj_points')))
+
+            # If the user joined a particular shop, let the game know.
+            if 'shop_location' in other_profile:
+                shop_id = other_profile.get_int('shop_location')
+                machine = self.get_machine_by_id(shop_id)
+                if machine is not None:
+                    shop = Node.void('shop')
+                    rival.add_child(shop)
+                    shop.set_attribute('name', machine.name)
+
+            qprodata = Node.void('qprodata')
+            rival.add_child(qprodata)
+            qpro = other_profile.get_dict('qpro')
+            qprodata.set_attribute('head', str(qpro.get_int('head')))
+            qprodata.set_attribute('hair', str(qpro.get_int('hair')))
+            qprodata.set_attribute('face', str(qpro.get_int('face')))
+            qprodata.set_attribute('body', str(qpro.get_int('body')))
+            qprodata.set_attribute('hand', str(qpro.get_int('hand')))
+
+        # Step up mode
+        step_dict = profile.get_dict('step')
+        step = Node.void('step')
+        root.add_child(step)
+        step.set_attribute('damage', str(step_dict.get_int('damage')))
+        step.set_attribute('defeat', str(step_dict.get_int('defeat')))
+        step.set_attribute('progress', str(step_dict.get_int('progress')))
+        step.set_attribute('round', str(step_dict.get_int('round')))
+        step.set_attribute('sp_mission', str(step_dict.get_int('sp_mission')))
+        step.set_attribute('dp_mission', str(step_dict.get_int('dp_mission')))
+        step.set_attribute('sp_level', str(step_dict.get_int('sp_level')))
+        step.set_attribute('dp_level', str(step_dict.get_int('dp_level')))
+        step.set_attribute('sp_mplay', str(step_dict.get_int('sp_mplay')))
+        step.set_attribute('dp_mplay', str(step_dict.get_int('dp_mplay')))
+        step.set_attribute('last_select', str(step_dict.get_int('last_select')))
+        step.add_child(Node.binary('album', step_dict.get_bytes('album', b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')))
+
+        # Favorites
+        favorite = Node.void('favorite')
+        root.add_child(favorite)
+        favorite_dict = profile.get_dict('favorite')
+
+        sp_mlist = b''
+        sp_clist = b''
+        singles_list = favorite_dict['single'] if 'single' in favorite_dict else []
+        for single in singles_list:
+            sp_mlist = sp_mlist + struct.pack('<L', single['id'])
+            sp_clist = sp_clist + struct.pack('B', single['chart'])
+        while len(sp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+            sp_mlist = sp_mlist + b'\x00\x00\x00\x00'
+        while len(sp_clist) < self.FAVORITE_LIST_LENGTH:
+            sp_clist = sp_clist + b'\x00'
+
+        dp_mlist = b''
+        dp_clist = b''
+        doubles_list = favorite_dict['double'] if 'double' in favorite_dict else []
+        for double in doubles_list:
+            dp_mlist = dp_mlist + struct.pack('<L', double['id'])
+            dp_clist = dp_clist + struct.pack('B', double['chart'])
+        while len(dp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
+            dp_mlist = dp_mlist + b'\x00\x00\x00\x00'
+        while len(dp_clist) < self.FAVORITE_LIST_LENGTH:
+            dp_clist = dp_clist + b'\x00'
+
+        favorite.add_child(Node.binary('sp_mlist', sp_mlist))
+        favorite.add_child(Node.binary('sp_clist', sp_clist))
+        favorite.add_child(Node.binary('dp_mlist', dp_mlist))
+        favorite.add_child(Node.binary('dp_clist', dp_clist))
+
+        # Orb data
+        orb_data = Node.void('orb_data')
+        root.add_child(orb_data)
+        orb_data.set_attribute('rest_orb', str(profile.get_int('orbs')))
+
+        # Link5 data
+        if 'link5' in profile:
+            # Don't provide link5 if we haven't saved it, so the game can
+            # initialize it properly.
+            link5_dict = profile.get_dict('link5')
+            link5 = Node.void('link5')
+            root.add_child(link5)
+            for attr in [
+                'qpro',
+                'glass',
+                'treasure',  # Doesn't seem to be saved
+                'beautiful',
+                'quaver',
+                'castle',
+                'flip',
+                'titans',
+                'exusia',
+                'waxing',
+                'sampling',
+                'beachside',
+                'cuvelia',
+                'reunion',
+                'bad',
+                'turii',
+                'anisakis',
+                'second',
+                'whydidyou',
+                'china',
+                'fallen',
+                'broken',
+                'summer',
+                'sakura',
+                'wuv',
+                'survival',
+                'thunder',
+                'qproflg',  # Doesn't seem to be saved
+                'glassflg',  # Doesn't seem to be saved
+                'reflec_data',  # Doesn't seem to be saved
+            ]:
+                link5.set_attribute(attr, str(link5_dict.get_int(attr)))
+
+        # Boss1 data
+        if 'boss1' in profile:
+            # Don't provide boss1 if we haven't saved it, so the game can
+            # initialize it properly.
+            boss1_dict = profile.get_dict('boss1')
+            boss1 = Node.void('boss1')
+            root.add_child(boss1)
+            for attr in [
+                'stamina',
+                'attack',
+                'item_flg',
+                'item_flg2',
+                'pick',
+                'row0',
+                'row1',
+                'row2',
+                'row3',
+                'column0',
+                'column1',
+                'column2',
+                'column3',
+                'map',
+                'job',
+                'general',
+                'battle',
+                'boss0_n',
+                'boss0_h',
+                'boss0_a',
+                'boss1_n',
+                'boss1_h',
+                'boss1_a',
+                'boss2_n',
+                'boss2_h',
+                'boss2_a',
+                'item1',
+                'item2',
+                'item3',
+                'boss_scene',
+                'boss0_damage',
+                'boss1_damage',
+                'boss2_damage',
+                'boss3_damage',
+                'boss4_damage',
+                'boss5_damage',
+                'boss6_damage',
+            ]:
+                boss1.set_attribute(attr, str(boss1_dict.get_int(attr)))
+            boss1.add_child(Node.s32_array('level', boss1_dict.get_int_array('level', 7)))
+            if 'durability' in boss1_dict:
+                boss1.add_child(Node.binary('durability', boss1_dict.get_bytes('durability')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Track play counts
+        cltype = int(request.attribute('cltype'))
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            play_stats.increment_int('single_plays')
+        if cltype == self.GAME_CLTYPE_DOUBLE:
+            play_stats.increment_int('double_plays')
+
+        # Track DJ points
+        play_stats.replace_int('single_dj_points', int(request.attribute('s_achi')))
+        play_stats.replace_int('double_dj_points', int(request.attribute('d_achi')))
+
+        # Profile settings
+        newprofile.replace_int('mode', int(request.attribute('mode')))
+        newprofile.replace_int('pmode', int(request.attribute('pmode')))
+        newprofile.replace_int('rtype', int(request.attribute('rtype')))
+        newprofile.replace_int('s_lift', int(request.attribute('s_lift')))
+        newprofile.replace_int('d_lift', int(request.attribute('d_lift')))
+        newprofile.replace_int('sp_opt', int(request.attribute('sp_opt')))
+        newprofile.replace_int('dp_opt', int(request.attribute('dp_opt')))
+        newprofile.replace_int('dp_opt2', int(request.attribute('dp_opt2')))
+        newprofile.replace_int('gpos', int(request.attribute('gpos')))
+        newprofile.replace_int('s_sorttype', int(request.attribute('s_sorttype')))
+        newprofile.replace_int('d_sorttype', int(request.attribute('d_sorttype')))
+        newprofile.replace_int('s_pace', int(request.attribute('s_pace')))
+        newprofile.replace_int('d_pace', int(request.attribute('d_pace')))
+        newprofile.replace_int('s_gno', int(request.attribute('s_gno')))
+        newprofile.replace_int('d_gno', int(request.attribute('d_gno')))
+        newprofile.replace_int('s_gtype', int(request.attribute('s_gtype')))
+        newprofile.replace_int('d_gtype', int(request.attribute('d_gtype')))
+        newprofile.replace_int('s_sdlen', int(request.attribute('s_sdlen')))
+        newprofile.replace_int('d_sdlen', int(request.attribute('d_sdlen')))
+        newprofile.replace_int('s_sdtype', int(request.attribute('s_sdtype')))
+        newprofile.replace_int('d_sdtype', int(request.attribute('d_sdtype')))
+        newprofile.replace_int('s_timing', int(request.attribute('s_timing')))
+        newprofile.replace_int('d_timing', int(request.attribute('d_timing')))
+        newprofile.replace_float('s_notes', float(request.attribute('s_notes')))
+        newprofile.replace_float('d_notes', float(request.attribute('d_notes')))
+        newprofile.replace_int('s_judge', int(request.attribute('s_judge')))
+        newprofile.replace_int('d_judge', int(request.attribute('d_judge')))
+        newprofile.replace_float('s_hispeed', float(request.attribute('s_hispeed')))
+        newprofile.replace_float('d_hispeed', float(request.attribute('d_hispeed')))
+        newprofile.replace_int('s_disp_judge', int(request.attribute('s_disp_judge')))
+        newprofile.replace_int('d_disp_judge', int(request.attribute('d_disp_judge')))
+        newprofile.replace_int('s_opstyle', int(request.attribute('s_opstyle')))
+        newprofile.replace_int('d_opstyle', int(request.attribute('d_opstyle')))
+
+        # Update judge window adjustments per-machine
+        judge_dict = newprofile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+        machine_judge.replace_int('single', int(request.attribute('s_judgeAdj')))
+        machine_judge.replace_int('double', int(request.attribute('d_judgeAdj')))
+        judge_dict.replace_dict(self.config['machine']['pcbid'], machine_judge)
+        newprofile.replace_dict('machine_judge_adjust', judge_dict)
+
+        # Secret flags saving
+        secret = request.child('secret')
+        if secret is not None:
+            secret_dict = newprofile.get_dict('secret')
+            secret_dict.replace_int_array('flg1', 2, secret.child_value('flg1'))
+            secret_dict.replace_int_array('flg2', 2, secret.child_value('flg2'))
+            secret_dict.replace_int_array('flg3', 2, secret.child_value('flg3'))
+            newprofile.replace_dict('secret', secret_dict)
+
+        # Basic achievements
+        achievements = request.child('achievements')
+        if achievements is not None:
+            newprofile.replace_int('visit_flg', int(achievements.attribute('visit_flg')))
+            newprofile.replace_int('last_weekly', int(achievements.attribute('last_weekly')))
+            newprofile.replace_int('weekly_num', int(achievements.attribute('weekly_num')))
+
+            pack_id = int(achievements.attribute('pack_id'))
+            if pack_id > 0:
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    pack_id,
+                    'daily',
+                    {
+                        'pack_flg': int(achievements.attribute('pack_flg')),
+                        'pack_comp': int(achievements.attribute('pack_comp')),
+                    },
+                )
+
+            trophies = achievements.child('trophy')
+            if trophies is not None:
+                # We only load the first 10 in profile load.
+                newprofile.replace_int_array('trophy', 10, trophies.value[:10])
+
+        # Deller saving
+        deller = request.child('deller')
+        if deller is not None:
+            newprofile.replace_int('deller', newprofile.get_int('deller') + int(deller.attribute('deller')))
+
+        # Favorites saving
+        favorite = request.child('favorite')
+        if favorite is not None:
+            single_music_bin = favorite.child_value('sp_mlist')
+            single_chart_bin = favorite.child_value('sp_clist')
+            double_music_bin = favorite.child_value('dp_mlist')
+            double_chart_bin = favorite.child_value('dp_clist')
+
+            singles = []
+            doubles = []
+            for i in range(self.FAVORITE_LIST_LENGTH):
+                singles.append({
+                    'id': struct.unpack('<L', single_music_bin[(i * 4):((i + 1) * 4)])[0],
+                    'chart': struct.unpack('B', single_chart_bin[i:(i + 1)])[0],
+                })
+                doubles.append({
+                    'id': struct.unpack('<L', double_music_bin[(i * 4):((i + 1) * 4)])[0],
+                    'chart': struct.unpack('B', double_chart_bin[i:(i + 1)])[0],
+                })
+
+            # Filter out empty charts
+            singles = [single for single in singles if single['id'] != 0]
+            doubles = [double for double in doubles if double['id'] != 0]
+
+            newprofile.replace_dict(
+                'favorite',
+                {
+                    'single': singles,
+                    'double': doubles,
+                },
+            )
+
+        # Step-up mode
+        step = request.child('step')
+        if step is not None:
+            step_dict = newprofile.get_dict('step')
+            step_dict.replace_int('damage', int(step.attribute('damage')))
+            step_dict.replace_int('defeat', int(step.attribute('defeat')))
+            step_dict.replace_int('progress', int(step.attribute('progress')))
+            step_dict.replace_int('round', int(step.attribute('round')))
+            step_dict.replace_int('sp_mission', int(step.attribute('sp_mission')))
+            step_dict.replace_int('dp_mission', int(step.attribute('dp_mission')))
+            step_dict.replace_int('sp_level', int(step.attribute('sp_level')))
+            step_dict.replace_int('dp_level', int(step.attribute('dp_level')))
+            step_dict.replace_int('sp_mplay', int(step.attribute('sp_mplay')))
+            step_dict.replace_int('dp_mplay', int(step.attribute('dp_mplay')))
+            step_dict.replace_int('last_select', int(step.attribute('last_select')))
+            step_dict.replace_bytes('album', step.value)
+            newprofile.replace_dict('step', step_dict)
+
+        # Orb data saving
+        orb_data = request.child('orb_data')
+        if orb_data is not None:
+            orbs = newprofile.get_int('orbs')
+            orbs = orbs + int(orb_data.attribute('add_orb'))
+            if orb_data.child_value('use_vip_pass'):
+                orbs = 0
+            newprofile.replace_int('orbs', orbs)
+
+        # Link5 data
+        link5 = request.child('link5')
+        if link5 is not None:
+            link5_dict = newprofile.get_dict('link5')
+            for attr in [
+                'qpro',
+                'glass',
+                'beautiful',
+                'quaver',
+                'castle',
+                'flip',
+                'titans',
+                'exusia',
+                'waxing',
+                'sampling',
+                'beachside',
+                'cuvelia',
+                'reunion',
+                'bad',
+                'turii',
+                'anisakis',
+                'second',
+                'whydidyou',
+                'china',
+                'fallen',
+                'broken',
+                'summer',
+                'sakura',
+                'wuv',
+                'survival',
+                'thunder',
+            ]:
+                link5_dict.replace_int(attr, int(link5.attribute(attr)))
+            newprofile.replace_dict('link5', link5_dict)
+
+        # Boss1 data
+        boss1 = request.child('boss1')
+        if boss1 is not None:
+            boss1_dict = newprofile.get_dict('boss1')
+            for attr in [
+                'stamina',
+                'attack',
+                'item_flg',
+                'item_flg2',
+                'pick',
+                'row0',
+                'row1',
+                'row2',
+                'row3',
+                'column0',
+                'column1',
+                'column2',
+                'column3',
+                'map',
+                'job',
+                'general',
+                'battle',
+                'boss0_n',
+                'boss0_h',
+                'boss0_a',
+                'boss1_n',
+                'boss1_h',
+                'boss1_a',
+                'boss2_n',
+                'boss2_h',
+                'boss2_a',
+                'boss_scene',
+                'boss0_damage',
+                'boss1_damage',
+                'boss2_damage',
+                'boss3_damage',
+                'boss4_damage',
+                'boss5_damage',
+                'boss6_damage',
+            ]:
+                boss1_dict.replace_int(attr, int(boss1.attribute(attr)))
+            level = boss1.child_value('level')
+            if level is not None:
+                boss1_dict.replace_int_array('level', 7, level[:7])
+            durability = boss1.child_value('durability')
+            if durability is not None:
+                boss1_dict.replace_bytes('durability', durability)
+            newprofile.replace_dict('boss1', boss1_dict)
+
+        # Keep track of play statistics across all mixes
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/iidx/stubs.py b/bemani/backend/iidx/stubs.py
new file mode 100644
index 0000000..bbd99ba
--- /dev/null
+++ b/bemani/backend/iidx/stubs.py
@@ -0,0 +1,173 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.common import VersionConstants
+
+
+class IIDX1stStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 1st style & substream'
+    version = VersionConstants.IIDX
+
+
+class IIDX2ndStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 2nd style'
+    version = VersionConstants.IIDX_2ND_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX1stStyle(self.data, self.config, self.model)
+
+
+class IIDX3rdStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 3rd style'
+    version = VersionConstants.IIDX_3RD_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX2ndStyle(self.data, self.config, self.model)
+
+
+class IIDX4thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 4th style'
+    version = VersionConstants.IIDX_4TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX3rdStyle(self.data, self.config, self.model)
+
+
+class IIDX5thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 5th style'
+    version = VersionConstants.IIDX_5TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX4thStyle(self.data, self.config, self.model)
+
+
+class IIDX6thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 6th style'
+    version = VersionConstants.IIDX_6TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX5thStyle(self.data, self.config, self.model)
+
+
+class IIDX7thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 7th style'
+    version = VersionConstants.IIDX_7TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX6thStyle(self.data, self.config, self.model)
+
+
+class IIDX8thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 8th style'
+    version = VersionConstants.IIDX_8TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX7thStyle(self.data, self.config, self.model)
+
+
+class IIDX9thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 9th style'
+    version = VersionConstants.IIDX_9TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX8thStyle(self.data, self.config, self.model)
+
+
+class IIDX10thStyle(IIDXBase):
+
+    name = 'Beatmania IIDX 10th style'
+    version = VersionConstants.IIDX_10TH_STYLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX9thStyle(self.data, self.config, self.model)
+
+
+class IIDXRed(IIDXBase):
+
+    name = 'Beatmania IIDX RED'
+    version = VersionConstants.IIDX_RED
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDX10thStyle(self.data, self.config, self.model)
+
+
+class IIDXHappySky(IIDXBase):
+
+    name = 'Beatmania IIDX HAPPY SKY'
+    version = VersionConstants.IIDX_HAPPY_SKY
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXRed(self.data, self.config, self.model)
+
+
+class IIDXDistorted(IIDXBase):
+
+    name = 'Beatmania IIDX DistorteD'
+    version = VersionConstants.IIDX_DISTORTED
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXHappySky(self.data, self.config, self.model)
+
+
+class IIDXGold(IIDXBase):
+
+    name = 'Beatmania IIDX GOLD'
+    version = VersionConstants.IIDX_GOLD
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXDistorted(self.data, self.config, self.model)
+
+
+class IIDXDJTroopers(IIDXBase):
+
+    name = 'Beatmania IIDX DJ TROOPERS'
+    version = VersionConstants.IIDX_DJ_TROOPERS
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXGold(self.data, self.config, self.model)
+
+
+class IIDXEmpress(IIDXBase):
+
+    name = 'Beatmania IIDX EMPRESS'
+    version = VersionConstants.IIDX_EMPRESS
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXDJTroopers(self.data, self.config, self.model)
+
+
+class IIDXSirius(IIDXBase):
+
+    name = 'Beatmania IIDX SIRIUS'
+    version = VersionConstants.IIDX_SIRIUS
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXEmpress(self.data, self.config, self.model)
+
+
+class IIDXResortAnthem(IIDXBase):
+
+    name = 'Beatmania IIDX Resort Anthem'
+    version = VersionConstants.IIDX_RESORT_ANTHEM
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXSirius(self.data, self.config, self.model)
+
+
+class IIDXLincle(IIDXBase):
+
+    name = 'Beatmania IIDX Lincle'
+    version = VersionConstants.IIDX_LINCLE
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXResortAnthem(self.data, self.config, self.model)
diff --git a/bemani/backend/iidx/tricoro.py b/bemani/backend/iidx/tricoro.py
new file mode 100644
index 0000000..143c3fc
--- /dev/null
+++ b/bemani/backend/iidx/tricoro.py
@@ -0,0 +1,1401 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.backend.iidx.base import IIDXBase
+from bemani.backend.iidx.stubs import IIDXLincle
+
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import Data, UserID
+from bemani.protocol import Node
+
+
+class IIDXTricoro(IIDXBase):
+
+    name = 'Beatmania IIDX Tricoro'
+    version = VersionConstants.IIDX_TRICORO
+
+    GAME_CLTYPE_SINGLE = 0
+    GAME_CLTYPE_DOUBLE = 1
+
+    DAN_STAGES_SINGLE = 4
+    DAN_STAGES_DOUBLE = 3
+
+    GAME_CLEAR_STATUS_NO_PLAY = 0
+    GAME_CLEAR_STATUS_FAILED = 1
+    GAME_CLEAR_STATUS_ASSIST_CLEAR = 2
+    GAME_CLEAR_STATUS_EASY_CLEAR = 3
+    GAME_CLEAR_STATUS_CLEAR = 4
+    GAME_CLEAR_STATUS_HARD_CLEAR = 5
+    GAME_CLEAR_STATUS_EX_HARD_CLEAR = 6
+    GAME_CLEAR_STATUS_FULL_COMBO = 7
+
+    GAME_GHOST_TYPE_RIVAL = 1
+    GAME_GHOST_TYPE_GLOBAL_TOP = 2
+    GAME_GHOST_TYPE_GLOBAL_AVERAGE = 3
+    GAME_GHOST_TYPE_LOCAL_TOP = 4
+    GAME_GHOST_TYPE_LOCAL_AVERAGE = 5
+    GAME_GHOST_TYPE_DAN_TOP = 6
+    GAME_GHOST_TYPE_DAN_AVERAGE = 7
+    GAME_GHOST_TYPE_RIVAL_TOP = 8
+    GAME_GHOST_TYPE_RIVAL_AVERAGE = 9
+
+    GAME_GHOST_LENGTH = 64
+
+    GAME_SP_DAN_RANK_7_KYU = 0
+    GAME_SP_DAN_RANK_6_KYU = 1
+    GAME_SP_DAN_RANK_5_KYU = 2
+    GAME_SP_DAN_RANK_4_KYU = 3
+    GAME_SP_DAN_RANK_3_KYU = 4
+    GAME_SP_DAN_RANK_2_KYU = 5
+    GAME_SP_DAN_RANK_1_KYU = 6
+    GAME_SP_DAN_RANK_1_DAN = 7
+    GAME_SP_DAN_RANK_2_DAN = 8
+    GAME_SP_DAN_RANK_3_DAN = 9
+    GAME_SP_DAN_RANK_4_DAN = 10
+    GAME_SP_DAN_RANK_5_DAN = 11
+    GAME_SP_DAN_RANK_6_DAN = 12
+    GAME_SP_DAN_RANK_7_DAN = 13
+    GAME_SP_DAN_RANK_8_DAN = 14
+    GAME_SP_DAN_RANK_9_DAN = 15
+    GAME_SP_DAN_RANK_10_DAN = 16
+    GAME_SP_DAN_RANK_KAIDEN = 17
+
+    GAME_DP_DAN_RANK_5_KYU = 0
+    GAME_DP_DAN_RANK_4_KYU = 1
+    GAME_DP_DAN_RANK_3_KYU = 2
+    GAME_DP_DAN_RANK_2_KYU = 3
+    GAME_DP_DAN_RANK_1_KYU = 4
+    GAME_DP_DAN_RANK_1_DAN = 5
+    GAME_DP_DAN_RANK_2_DAN = 6
+    GAME_DP_DAN_RANK_3_DAN = 7
+    GAME_DP_DAN_RANK_4_DAN = 8
+    GAME_DP_DAN_RANK_5_DAN = 9
+    GAME_DP_DAN_RANK_6_DAN = 10
+    GAME_DP_DAN_RANK_7_DAN = 11
+    GAME_DP_DAN_RANK_8_DAN = 12
+    GAME_DP_DAN_RANK_9_DAN = 13
+    GAME_DP_DAN_RANK_10_DAN = 14
+    GAME_DP_DAN_RANK_KAIDEN = 15
+
+    FAVORITE_LIST_LENGTH = 20
+
+    def previous_version(self) -> Optional[IIDXBase]:
+        return IIDXLincle(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert dailies into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'daily_charts', 'daily'):
+            # Generate a new list of three dailies.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = list(set([song.id for song in data.local.music.get_all_songs(cls.game, cls.version)]))
+            daily_songs = random.sample(all_songs, 3)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'dailies',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': daily_songs,
+                },
+            )
+            events.append((
+                'iidx_daily_charts',
+                {
+                    'version': cls.version,
+                    'music': daily_songs,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'daily_charts', 'daily')
+        return events
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Global Shop Ranking',
+                    'tip': 'Return network-wide ranking instead of shop ranking on results screen.',
+                    'category': 'game_config',
+                    'setting': 'global_shop_ranking',
+                },
+                {
+                    'name': 'Events In Omnimix',
+                    'tip': 'Allow events to be enabled at all for Omnimix.',
+                    'category': 'game_config',
+                    'setting': 'omnimix_events_enabled',
+                },
+            ],
+        }
+
+    def db_to_game_status(self, db_status: int) -> int:
+        return {
+            self.CLEAR_STATUS_NO_PLAY: self.GAME_CLEAR_STATUS_NO_PLAY,
+            self.CLEAR_STATUS_FAILED: self.GAME_CLEAR_STATUS_FAILED,
+            self.CLEAR_STATUS_ASSIST_CLEAR: self.GAME_CLEAR_STATUS_ASSIST_CLEAR,
+            self.CLEAR_STATUS_EASY_CLEAR: self.GAME_CLEAR_STATUS_EASY_CLEAR,
+            self.CLEAR_STATUS_CLEAR: self.GAME_CLEAR_STATUS_CLEAR,
+            self.CLEAR_STATUS_HARD_CLEAR: self.GAME_CLEAR_STATUS_HARD_CLEAR,
+            self.CLEAR_STATUS_EX_HARD_CLEAR: self.GAME_CLEAR_STATUS_EX_HARD_CLEAR,
+            self.CLEAR_STATUS_FULL_COMBO: self.GAME_CLEAR_STATUS_FULL_COMBO,
+        }[db_status]
+
+    def game_to_db_status(self, game_status: int) -> int:
+        return {
+            self.GAME_CLEAR_STATUS_NO_PLAY: self.CLEAR_STATUS_NO_PLAY,
+            self.GAME_CLEAR_STATUS_FAILED: self.CLEAR_STATUS_FAILED,
+            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: self.CLEAR_STATUS_ASSIST_CLEAR,
+            self.GAME_CLEAR_STATUS_EASY_CLEAR: self.CLEAR_STATUS_EASY_CLEAR,
+            self.GAME_CLEAR_STATUS_CLEAR: self.CLEAR_STATUS_CLEAR,
+            self.GAME_CLEAR_STATUS_HARD_CLEAR: self.CLEAR_STATUS_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: self.CLEAR_STATUS_EX_HARD_CLEAR,
+            self.GAME_CLEAR_STATUS_FULL_COMBO: self.CLEAR_STATUS_FULL_COMBO,
+        }[game_status]
+
+    def db_to_game_rank(self, db_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if db_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.DAN_RANK_7_KYU: self.GAME_SP_DAN_RANK_7_KYU,
+                self.DAN_RANK_6_KYU: self.GAME_SP_DAN_RANK_6_KYU,
+                self.DAN_RANK_5_KYU: self.GAME_SP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_SP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_SP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_SP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_SP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_SP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_SP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_SP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_SP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_SP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_SP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_SP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_SP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_SP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_SP_DAN_RANK_10_DAN,
+                self.DAN_RANK_KAIDEN: self.GAME_SP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.DAN_RANK_5_KYU: self.GAME_DP_DAN_RANK_5_KYU,
+                self.DAN_RANK_4_KYU: self.GAME_DP_DAN_RANK_4_KYU,
+                self.DAN_RANK_3_KYU: self.GAME_DP_DAN_RANK_3_KYU,
+                self.DAN_RANK_2_KYU: self.GAME_DP_DAN_RANK_2_KYU,
+                self.DAN_RANK_1_KYU: self.GAME_DP_DAN_RANK_1_KYU,
+                self.DAN_RANK_1_DAN: self.GAME_DP_DAN_RANK_1_DAN,
+                self.DAN_RANK_2_DAN: self.GAME_DP_DAN_RANK_2_DAN,
+                self.DAN_RANK_3_DAN: self.GAME_DP_DAN_RANK_3_DAN,
+                self.DAN_RANK_4_DAN: self.GAME_DP_DAN_RANK_4_DAN,
+                self.DAN_RANK_5_DAN: self.GAME_DP_DAN_RANK_5_DAN,
+                self.DAN_RANK_6_DAN: self.GAME_DP_DAN_RANK_6_DAN,
+                self.DAN_RANK_7_DAN: self.GAME_DP_DAN_RANK_7_DAN,
+                self.DAN_RANK_8_DAN: self.GAME_DP_DAN_RANK_8_DAN,
+                self.DAN_RANK_9_DAN: self.GAME_DP_DAN_RANK_9_DAN,
+                self.DAN_RANK_10_DAN: self.GAME_DP_DAN_RANK_10_DAN,
+                self.DAN_RANK_KAIDEN: self.GAME_DP_DAN_RANK_KAIDEN,
+            }[db_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def game_to_db_rank(self, game_dan: int, cltype: int) -> int:
+        # Special case for no DAN rank
+        if game_dan == -1:
+            return -1
+
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            return {
+                self.GAME_SP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
+                self.GAME_SP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
+                self.GAME_SP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_SP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_SP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_SP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_SP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_SP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_SP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_SP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_SP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_SP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_SP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_SP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_SP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_SP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_SP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_SP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        elif cltype == self.GAME_CLTYPE_DOUBLE:
+            return {
+                self.GAME_DP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
+                self.GAME_DP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
+                self.GAME_DP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
+                self.GAME_DP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
+                self.GAME_DP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
+                self.GAME_DP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
+                self.GAME_DP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
+                self.GAME_DP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
+                self.GAME_DP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
+                self.GAME_DP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
+                self.GAME_DP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
+                self.GAME_DP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
+                self.GAME_DP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
+                self.GAME_DP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
+                self.GAME_DP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
+                self.GAME_DP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
+            }[game_dan]
+        else:
+            raise Exception('Invalid cltype!')
+
+    def handle_shop_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getname':
+            root = Node.void('shop')
+            root.set_attribute('cls_opt', '0')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            root.set_attribute('opname', machine.name)
+            root.set_attribute('pid', '51')
+            return root
+
+        if method == 'savename':
+            self.update_machine_name(request.attribute('opname'))
+            root = Node.void('shop')
+            return root
+
+        if method == 'sentinfo':
+            root = Node.void('shop')
+            return root
+
+        if method == 'getconvention':
+            root = Node.void('shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            root.set_attribute('music_0', str(course.get_int('music_0', 20032)))
+            root.set_attribute('music_1', str(course.get_int('music_1', 20009)))
+            root.set_attribute('music_2', str(course.get_int('music_2', 20015)))
+            root.set_attribute('music_3', str(course.get_int('music_3', 20064)))
+            root.add_child(Node.bool('valid', course.get_bool('valid')))
+            return root
+
+        if method == 'setconvention':
+            root = Node.void('shop')
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = ValidatedDict()
+                course.replace_int('music_0', request.child_value('music_0'))
+                course.replace_int('music_1', request.child_value('music_1'))
+                course.replace_int('music_2', request.child_value('music_2'))
+                course.replace_int('music_3', request.child_value('music_3'))
+                course.replace_bool('valid', request.child_value('valid'))
+                self.data.local.machine.put_settings(machine.arcade, self.game, self.music_version, 'shop_course', course)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_ranking_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'getranker':
+            root = Node.void('ranking')
+            chart = int(request.attribute('clid'))
+            if chart not in [
+                self.CHART_TYPE_N7,
+                self.CHART_TYPE_H7,
+                self.CHART_TYPE_A7,
+                self.CHART_TYPE_N14,
+                self.CHART_TYPE_H14,
+                self.CHART_TYPE_A14,
+            ]:
+                # Chart type 6 is presumably beginner mode, but it crashes the game
+                return root
+
+            machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            if machine.arcade is not None:
+                course = self.data.local.machine.get_settings(machine.arcade, self.game, self.music_version, 'shop_course')
+            else:
+                course = None
+
+            if course is None:
+                course = ValidatedDict()
+
+            if not course.get_bool('valid'):
+                # Shop course not enabled or not present
+                return root
+
+            convention = Node.void('convention')
+            root.add_child(convention)
+            convention.set_attribute('clid', str(chart))
+            convention.set_attribute('update_date', str(Time.now() * 1000))
+
+            # Grab all scores for each of the four songs, filter out people who haven't
+            # set us as their arcade and then return the top 20 scores (adding all 4 songs).
+            songids = [
+                course.get_int('music_0'),
+                course.get_int('music_1'),
+                course.get_int('music_2'),
+                course.get_int('music_3'),
+            ]
+
+            totalscores: Dict[UserID, int] = {}
+            profiles: Dict[UserID, ValidatedDict] = {}
+            for songid in songids:
+                scores = self.data.local.music.get_all_scores(
+                    self.game,
+                    self.music_version,
+                    songid=songid,
+                    songchart=chart,
+                )
+
+                for score in scores:
+                    if score[0] not in totalscores:
+                        totalscores[score[0]] = 0
+                        profile = self.get_any_profile(score[0])
+                        if profile is None:
+                            profile = ValidatedDict()
+                        profiles[score[0]] = profile
+
+                    totalscores[score[0]] += score[1].points
+
+            topscores = sorted(
+                [
+                    (totalscores[userid], profiles[userid])
+                    for userid in totalscores
+                    if self.user_joined_arcade(machine, profiles[userid])
+                ],
+                key=lambda tup: tup[0],
+                reverse=True,
+            )[:20]
+
+            rank = 0
+            for topscore in topscores:
+                rank = rank + 1
+
+                detail = Node.void('detail')
+                convention.add_child(detail)
+                detail.set_attribute('name', topscore[1].get_str('name'))
+                detail.set_attribute('rank', str(rank))
+                detail.set_attribute('score', str(topscore[0]))
+                detail.set_attribute('pid', str(topscore[1].get_int('pid')))
+
+                qpro = topscore[1].get_dict('qpro')
+                detail.set_attribute('head', str(qpro.get_int('head')))
+                detail.set_attribute('hair', str(qpro.get_int('hair')))
+                detail.set_attribute('face', str(qpro.get_int('face')))
+                detail.set_attribute('body', str(qpro.get_int('body')))
+                detail.set_attribute('hand', str(qpro.get_int('hand')))
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_music_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'crate':
+            root = Node.void('music')
+            attempts = self.get_clear_rates()
+
+            all_songs = list(set([song.id for song in self.data.local.music.get_all_songs(self.game, self.music_version)]))
+            for song in all_songs:
+                clears = []
+                fcs = []
+
+                for chart in [0, 1, 2, 3, 4, 5]:
+                    placed = False
+                    if song in attempts and chart in attempts[song]:
+                        values = attempts[song][chart]
+                        if values['total'] > 0:
+                            clears.append(int((100 * values['clears']) / values['total']))
+                            fcs.append(int((100 * values['fcs']) / values['total']))
+                            placed = True
+                    if not placed:
+                        clears.append(101)
+                        fcs.append(101)
+
+                clearnode = Node.u8_array('c', clears + fcs)
+                clearnode.set_attribute('mid', str(song))
+                root.add_child(clearnode)
+
+            return root
+
+        if method == 'getrank':
+            cltype = int(request.attribute('cltype'))
+
+            root = Node.void('music')
+            style = Node.void('style')
+            root.add_child(style)
+            style.set_attribute('type', str(cltype))
+
+            for rivalid in [-1, 0, 1, 2, 3, 4]:
+                if rivalid == -1:
+                    attr = 'iidxid'
+                else:
+                    attr = 'iidxid{}'.format(rivalid)
+
+                try:
+                    extid = int(request.attribute(attr))
+                except Exception:
+                    # Invalid extid
+                    continue
+
+                userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if userid is not None:
+                    scores = self.data.remote.music.get_scores(self.game, self.music_version, userid)
+
+                    # Grab score data for user/rival
+                    scoredata = self.make_score_struct(
+                        scores,
+                        self.CLEAR_TYPE_SINGLE if cltype == self.GAME_CLTYPE_SINGLE else self.CLEAR_TYPE_DOUBLE,
+                        rivalid,
+                    )
+                    for s in scoredata:
+                        root.add_child(Node.s16_array('m', s))
+
+                    # Grab most played for user/rival
+                    most_played = [
+                        play[0] for play in
+                        self.data.local.music.get_most_played(self.game, self.music_version, userid, 20)
+                    ]
+                    if len(most_played) < 20:
+                        most_played.extend([0] * (20 - len(most_played)))
+                    best = Node.u16_array('best', most_played)
+                    best.set_attribute('rno', str(rivalid))
+                    root.add_child(best)
+
+                    if rivalid == -1:
+                        # Grab beginner statuses for user only
+                        beginnerdata = self.make_beginner_struct(scores)
+                        for b in beginnerdata:
+                            root.add_child(Node.u16_array('b', b))
+
+            return root
+
+        if method == 'reg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            # See if we need to report global or shop scores
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                global_scores = game_config.get_bool('global_shop_ranking')
+                machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+            else:
+                # If we aren't in an arcade, we can only show global scores
+                global_scores = True
+                machine = None
+
+            # First, determine our current ranking before saving the new score
+            all_scores = sorted(
+                self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                key=lambda s: (s[1].points, s[1].timestamp),
+                reverse=True,
+            )
+            all_players = {
+                uid: prof for (uid, prof) in
+                self.get_any_profiles([s[0] for s in all_scores])
+            }
+
+            if not global_scores:
+                all_scores = [
+                    score for score in all_scores
+                    if (
+                        score[0] == userid or
+                        self.user_joined_arcade(machine, all_players[score[0]])
+                    )
+                ]
+
+            # Find our actual index
+            oldindex = None
+            for i in range(len(all_scores)):
+                if all_scores[i][0] == userid:
+                    oldindex = i
+                    break
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+                miss_count = int(request.attribute('mnum'))
+                ghost = request.child_value('ghost')
+                shopid = ID.parse_machine_id(request.attribute('shopconvid'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    chart,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    miss_count,
+                    ghost,
+                    shopid,
+                )
+
+            # Calculate and return statistics about this song
+            root = Node.void('music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+
+            if userid is not None:
+                # Shop ranking
+                shopdata = Node.void('shopdata')
+                root.add_child(shopdata)
+                shopdata.set_attribute('rank', '-1' if oldindex is None else str(oldindex + 1))
+
+                # Grab the rank of some other players on this song
+                ranklist = Node.void('ranklist')
+                root.add_child(ranklist)
+
+                all_scores = sorted(
+                    self.data.remote.music.get_all_scores(game=self.game, version=self.music_version, songid=musicid, songchart=chart),
+                    key=lambda s: (s[1].points, s[1].timestamp),
+                    reverse=True,
+                )
+                missing_players = [
+                    uid for (uid, _) in all_scores
+                    if uid not in all_players
+                ]
+                for (uid, prof) in self.get_any_profiles(missing_players):
+                    all_players[uid] = prof
+
+                if not global_scores:
+                    all_scores = [
+                        score for score in all_scores
+                        if (
+                            score[0] == userid or
+                            self.user_joined_arcade(machine, all_players[score[0]])
+                        )
+                    ]
+
+                # Find our actual index
+                ourindex = None
+                for i in range(len(all_scores)):
+                    if all_scores[i][0] == userid:
+                        ourindex = i
+                        break
+                if ourindex is None:
+                    raise Exception('Cannot find our own score after saving to DB!')
+                start = ourindex - 4
+                end = ourindex + 4
+                if start < 0:
+                    start = 0
+                if end >= len(all_scores):
+                    end = len(all_scores) - 1
+                relevant_scores = all_scores[start:(end + 1)]
+
+                record_num = start + 1
+                for score in relevant_scores:
+                    profile = all_players[score[0]]
+
+                    data = Node.void('data')
+                    ranklist.add_child(data)
+                    data.set_attribute('iidx_id', str(profile.get_int('extid')))
+                    data.set_attribute('name', profile.get_str('name'))
+
+                    machine_name = ''
+                    if 'shop_location' in profile:
+                        shop_id = profile.get_int('shop_location')
+                        machine = self.get_machine_by_id(shop_id)
+                        if machine is not None:
+                            machine_name = machine.name
+                    data.set_attribute('opname', machine_name)
+                    data.set_attribute('rnum', str(record_num))
+                    data.set_attribute('score', str(score[1].points))
+                    data.set_attribute('clflg', str(self.db_to_game_status(score[1].data.get_int('clear_status'))))
+                    data.set_attribute('pid', str(profile.get_int('pid')))
+                    data.set_attribute('myFlg', '1' if score[0] == userid else '0')
+
+                    data.set_attribute('sgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE),
+                    ))
+                    data.set_attribute('dgrade', str(
+                        self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE),
+                    ))
+
+                    qpro = profile.get_dict('qpro')
+                    data.set_attribute('head', str(qpro.get_int('head')))
+                    data.set_attribute('hair', str(qpro.get_int('hair')))
+                    data.set_attribute('face', str(qpro.get_int('face')))
+                    data.set_attribute('body', str(qpro.get_int('body')))
+                    data.set_attribute('hand', str(qpro.get_int('hand')))
+
+                    record_num = record_num + 1
+
+            return root
+
+        if method == 'breg':
+            extid = int(request.attribute('iidxid'))
+            musicid = int(request.attribute('mid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            if userid is not None:
+                clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+                pgreats = int(request.attribute('pgnum'))
+                greats = int(request.attribute('gnum'))
+
+                self.update_score(
+                    userid,
+                    musicid,
+                    self.CHART_TYPE_B7,
+                    clear_status,
+                    pgreats,
+                    greats,
+                    -1,
+                    b'',
+                    None,
+                )
+
+            # Return nothing.
+            root = Node.void('music')
+            return root
+
+        if method == 'play':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            clear_status = self.game_to_db_status(int(request.attribute('cflg')))
+
+            self.update_score(
+                None,  # No userid since its anonymous
+                musicid,
+                chart,
+                clear_status,
+                0,  # No ex score
+                0,  # No ex score
+                0,  # No miss count
+                None,  # No ghost
+                None,  # No shop for this user
+            )
+
+            # Calculate and return statistics about this song
+            root = Node.void('music')
+            root.set_attribute('clid', request.attribute('clid'))
+            root.set_attribute('mid', request.attribute('mid'))
+
+            attempts = self.get_clear_rates(musicid, chart)
+            count = attempts[musicid][chart]['total']
+            clear = attempts[musicid][chart]['clears']
+            full_combo = attempts[musicid][chart]['fcs']
+
+            if count > 0:
+                root.set_attribute('crate', str(int((100 * clear) / count)))
+                root.set_attribute('frate', str(int((100 * full_combo) / count)))
+            else:
+                root.set_attribute('crate', '0')
+                root.set_attribute('frate', '0')
+
+            return root
+
+        if method == 'appoint':
+            musicid = int(request.attribute('mid'))
+            chart = int(request.attribute('clid'))
+            ghost_type = int(request.attribute('ctype'))
+            extid = int(request.attribute('iidxid'))
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+            root = Node.void('music')
+
+            if userid is not None:
+                # Try to look up previous ghost for user
+                my_score = self.data.remote.music.get_score(self.game, self.music_version, userid, musicid, chart)
+                if my_score is not None:
+                    mydata = Node.binary('mydata', my_score.data.get_bytes('ghost'))
+                    mydata.set_attribute('score', str(my_score.points))
+                    root.add_child(mydata)
+
+                ghost_score = self.get_ghost(
+                    {
+                        self.GAME_GHOST_TYPE_RIVAL: self.GHOST_TYPE_RIVAL,
+                        self.GAME_GHOST_TYPE_GLOBAL_TOP: self.GHOST_TYPE_GLOBAL_TOP,
+                        self.GAME_GHOST_TYPE_GLOBAL_AVERAGE: self.GHOST_TYPE_GLOBAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_LOCAL_TOP: self.GHOST_TYPE_LOCAL_TOP,
+                        self.GAME_GHOST_TYPE_LOCAL_AVERAGE: self.GHOST_TYPE_LOCAL_AVERAGE,
+                        self.GAME_GHOST_TYPE_DAN_TOP: self.GHOST_TYPE_DAN_TOP,
+                        self.GAME_GHOST_TYPE_DAN_AVERAGE: self.GHOST_TYPE_DAN_AVERAGE,
+                        self.GAME_GHOST_TYPE_RIVAL_TOP: self.GHOST_TYPE_RIVAL_TOP,
+                        self.GAME_GHOST_TYPE_RIVAL_AVERAGE: self.GHOST_TYPE_RIVAL_AVERAGE,
+                    }.get(ghost_type, self.GHOST_TYPE_NONE),
+                    request.attribute('subtype'),
+                    self.GAME_GHOST_LENGTH,
+                    musicid,
+                    chart,
+                    userid,
+                )
+
+                # Add ghost score if we support it
+                if ghost_score is not None:
+                    sdata = Node.binary('sdata', ghost_score['ghost'])
+                    sdata.set_attribute('score', str(ghost_score['score']))
+                    if 'name' in ghost_score:
+                        sdata.set_attribute('name', ghost_score['name'])
+                    if 'pid' in ghost_score:
+                        sdata.set_attribute('pid', str(ghost_score['pid']))
+                    if 'extid' in ghost_score:
+                        sdata.set_attribute('riidxid', str(ghost_score['extid']))
+                    root.add_child(sdata)
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_pc_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'common':
+            root = Node.void('pc')
+            root.set_attribute('expire', '600')
+
+            # TODO: Hook all of these up to config options I guess?
+            ir = Node.void('ir')
+            root.add_child(ir)
+            ir.set_attribute('beat', '2')
+
+            limit = Node.void('limit')
+            root.add_child(limit)
+            limit.set_attribute('phase', '24')
+
+            # See if we configured event overrides
+            if self.machine_joined_arcade():
+                game_config = self.get_game_config()
+                omni_events = game_config.get_bool('omnimix_events_enabled')
+            else:
+                # If we aren't in an arcade, we turn off events
+                omni_events = False
+
+            if self.omnimix and (not omni_events):
+                boss_phase = 0
+            else:
+                # TODO: Figure out what these map to
+                boss_phase = 0
+
+            boss = Node.void('boss')
+            root.add_child(boss)
+            boss.set_attribute('phase', str(boss_phase))
+
+            red = Node.void('red')
+            root.add_child(red)
+            red.set_attribute('phase', '0')
+
+            yellow = Node.void('yellow')
+            root.add_child(yellow)
+            yellow.set_attribute('phase', '0')
+
+            medal = Node.void('medal')
+            root.add_child(medal)
+            medal.set_attribute('phase', '1')
+
+            cafe = Node.void('cafe')
+            root.add_child(cafe)
+            cafe.set_attribute('open', '1')
+
+            tricolettepark = Node.void('tricolettepark')
+            root.add_child(tricolettepark)
+            tricolettepark.set_attribute('open', '0')
+
+            return root
+
+        if method == 'delete':
+            return Node.void('pc')
+
+        if method == 'playstart':
+            return Node.void('pc')
+
+        if method == 'playend':
+            return Node.void('pc')
+
+        if method == 'oldget':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+
+            root = Node.void('pc')
+            root.set_attribute('status', '1' if profile is None else '0')
+            return root
+
+        if method == 'getname':
+            refid = request.attribute('rid')
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is not None:
+                oldversion = self.previous_version()
+                profile = oldversion.get_profile(userid)
+            else:
+                profile = None
+            if profile is None:
+                raise Exception(
+                    'Should not get here if we have no profile, we should ' +
+                    'have returned \'1\' in the \'oldget\' method above ' +
+                    'which should tell the game not to present a migration.'
+                )
+
+            root = Node.void('pc')
+            root.set_attribute('name', profile.get_str('name'))
+            root.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+            root.set_attribute('pid', str(profile.get_int('pid')))
+            return root
+
+        if method == 'reg':
+            refid = request.attribute('rid')
+            name = request.attribute('name')
+            pid = int(request.attribute('pid'))
+            profile = self.new_profile_by_refid(refid, name, pid)
+
+            root = Node.void('pc')
+            if profile is not None:
+                root.set_attribute('id', str(profile.get_int('extid')))
+                root.set_attribute('id_str', ID.format_extid(profile.get_int('extid')))
+            return root
+
+        if method == 'get':
+            refid = request.attribute('rid')
+            root = self.get_profile_by_refid(refid)
+            if root is None:
+                root = Node.void('pc')
+            return root
+
+        if method == 'save':
+            extid = int(request.attribute('iidxid'))
+            self.put_profile_by_extid(extid, request)
+
+            root = Node.void('pc')
+            return root
+
+        if method == 'visit':
+            root = Node.void('pc')
+            root.set_attribute('anum', '0')
+            root.set_attribute('snum', '0')
+            root.set_attribute('pnum', '0')
+            root.set_attribute('aflg', '0')
+            root.set_attribute('sflg', '0')
+            root.set_attribute('pflg', '0')
+            return root
+
+        if method == 'shopregister':
+            extid = int(request.child_value('iidx_id'))
+            location = ID.parse_machine_id(request.child_value('location_id'))
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                profile = self.get_profile(userid)
+                if profile is None:
+                    profile = ValidatedDict()
+                profile.replace_int('shop_location', location)
+                self.put_profile(userid, profile)
+
+            root = Node.void('pc')
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_grade_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'raised':
+            extid = int(request.attribute('iidxid'))
+            cltype = int(request.attribute('gtype'))
+            rank = self.game_to_db_rank(int(request.attribute('gid')), cltype)
+
+            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+            if userid is not None:
+                percent = int(request.attribute('achi'))
+                stages_cleared = int(request.attribute('cflg'))
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    max_stages = self.DAN_STAGES_SINGLE
+                else:
+                    max_stages = self.DAN_STAGES_DOUBLE
+                cleared = stages_cleared == max_stages
+
+                if cltype == self.GAME_CLTYPE_SINGLE:
+                    index = self.DAN_RANKING_SINGLE
+                else:
+                    index = self.DAN_RANKING_DOUBLE
+
+                self.update_rank(
+                    userid,
+                    index,
+                    rank,
+                    percent,
+                    cleared,
+                    stages_cleared,
+                )
+
+            # Figure out number of players that played this ranking
+            all_achievements = self.data.local.user.get_all_achievements(self.game, self.version)
+            num_players = 0
+            for [_, ach] in all_achievements:
+                if ach.type != index:
+                    continue
+                if ach.id != rank:
+                    continue
+                num_players = num_players + 1
+
+            root = Node.void('grade')
+            root.set_attribute('pnum', str(num_players))
+            return root
+
+        # Invalid method
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('pc')
+
+        # Look up play stats we bridge to every mix
+        play_stats = self.get_play_statistics(userid)
+
+        # Look up judge window adjustments
+        judge_dict = profile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+
+        # Profile data
+        pcdata = Node.void('pcdata')
+        root.add_child(pcdata)
+        pcdata.set_attribute('id', str(profile.get_int('extid')))
+        pcdata.set_attribute('idstr', ID.format_extid(profile.get_int('extid')))
+        pcdata.set_attribute('name', profile.get_str('name'))
+        pcdata.set_attribute('pid', str(profile.get_int('pid')))
+        pcdata.set_attribute('spnum', str(play_stats.get_int('single_plays')))
+        pcdata.set_attribute('dpnum', str(play_stats.get_int('double_plays')))
+        pcdata.set_attribute('sach', str(play_stats.get_int('single_dj_points')))
+        pcdata.set_attribute('dach', str(play_stats.get_int('double_dj_points')))
+        pcdata.set_attribute('help', str(profile.get_int('help')))
+        pcdata.set_attribute('gno', str(profile.get_int('gno')))
+        pcdata.set_attribute('gpos', str(profile.get_int('gpos')))
+        pcdata.set_attribute('timing', str(profile.get_int('timing')))
+        pcdata.set_attribute('sdhd', str(profile.get_int('sdhd')))
+        pcdata.set_attribute('sdtype', str(profile.get_int('sdtype')))
+        pcdata.set_attribute('notes', str(profile.get_float('notes')))
+        pcdata.set_attribute('pase', str(profile.get_int('pase')))
+        pcdata.set_attribute('sp_opt', str(profile.get_int('sp_opt')))
+        pcdata.set_attribute('dp_opt', str(profile.get_int('dp_opt')))
+        pcdata.set_attribute('dp_opt2', str(profile.get_int('dp_opt2')))
+        pcdata.set_attribute('mode', str(profile.get_int('mode')))
+        pcdata.set_attribute('pmode', str(profile.get_int('pmode')))
+        pcdata.set_attribute('liflen', str(profile.get_int('lift')))
+        pcdata.set_attribute('judge', str(profile.get_int('judge')))
+        pcdata.set_attribute('opstyle', str(profile.get_int('opstyle')))
+        pcdata.set_attribute('hispeed', str(profile.get_float('hispeed')))
+        pcdata.set_attribute('judgeAdj', str(machine_judge.get_int('adj')))
+
+        # Secret flags (shh!)
+        secret_dict = profile.get_dict('secret')
+        secret = Node.void('secret')
+        root.add_child(secret)
+        secret.add_child(Node.s64('flg1', secret_dict.get_int('flg1')))
+        secret.add_child(Node.s64('flg2', secret_dict.get_int('flg2')))
+        secret.add_child(Node.s64('flg3', secret_dict.get_int('flg3')))
+
+        # DAN rankings
+        grade = Node.void('grade')
+        root.add_child(grade)
+        grade.set_attribute('sgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+        grade.set_attribute('dgid', str(self.db_to_game_rank(profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+        rankings = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for rank in rankings:
+            if rank.type == self.DAN_RANKING_SINGLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_SINGLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_SINGLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+            if rank.type == self.DAN_RANKING_DOUBLE:
+                grade.add_child(Node.u8_array('g', [
+                    self.GAME_CLTYPE_DOUBLE,
+                    self.db_to_game_rank(rank.id, self.GAME_CLTYPE_DOUBLE),
+                    rank.data.get_int('stages_cleared'),
+                    rank.data.get_int('percent'),
+                ]))
+
+        # User settings
+        settings_dict = profile.get_dict('settings')
+        skin = Node.s16_array(
+            'skin',
+            [
+                settings_dict.get_int('frame'),
+                settings_dict.get_int('turntable'),
+                settings_dict.get_int('burst'),
+                settings_dict.get_int('bgm'),
+                settings_dict.get_int('flags'),
+                settings_dict.get_int('towel'),
+                settings_dict.get_int('judge_pos'),
+                settings_dict.get_int('voice'),
+                settings_dict.get_int('noteskin'),
+                settings_dict.get_int('full_combo'),
+                settings_dict.get_int('beam'),
+                settings_dict.get_int('judge'),
+                0,
+                settings_dict.get_int('disable_song_preview'),
+            ],
+        )
+        root.add_child(skin)
+
+        # Qpro data
+        qpro_dict = profile.get_dict('qpro')
+        root.add_child(Node.u32_array(
+            'qprodata',
+            [
+                qpro_dict.get_int('head'),
+                qpro_dict.get_int('hair'),
+                qpro_dict.get_int('face'),
+                qpro_dict.get_int('hand'),
+                qpro_dict.get_int('body'),
+            ],
+        ))
+
+        # Rivals
+        rlist = Node.void('rlist')
+        root.add_child(rlist)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        for link in links:
+            rival_type = None
+            if link.type == 'sp_rival':
+                rival_type = '1'
+            elif link.type == 'dp_rival':
+                rival_type = '2'
+            else:
+                # No business with this link type
+                continue
+
+            other_profile = self.get_profile(link.other_userid)
+            if other_profile is None:
+                continue
+            other_play_stats = self.get_play_statistics(link.other_userid)
+
+            rival = Node.void('rival')
+            rlist.add_child(rival)
+            rival.set_attribute('spdp', rival_type)
+            rival.set_attribute('id', str(other_profile.get_int('extid')))
+            rival.set_attribute('id_str', ID.format_extid(other_profile.get_int('extid')))
+            rival.set_attribute('djname', other_profile.get_str('name'))
+            rival.set_attribute('pid', str(other_profile.get_int('pid')))
+            rival.set_attribute('sg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_SINGLE, -1), self.GAME_CLTYPE_SINGLE)))
+            rival.set_attribute('dg', str(self.db_to_game_rank(other_profile.get_int(self.DAN_RANKING_DOUBLE, -1), self.GAME_CLTYPE_DOUBLE)))
+            rival.set_attribute('sa', str(other_play_stats.get_int('single_dj_points')))
+            rival.set_attribute('da', str(other_play_stats.get_int('double_dj_points')))
+
+            # If the user joined a particular shop, let the game know.
+            if 'shop_location' in other_profile:
+                shop_id = other_profile.get_int('shop_location')
+                machine = self.get_machine_by_id(shop_id)
+                if machine is not None:
+                    shop = Node.void('shop')
+                    rival.add_child(shop)
+                    shop.set_attribute('name', machine.name)
+
+            qprodata = Node.void('qprodata')
+            rival.add_child(qprodata)
+            qpro = other_profile.get_dict('qpro')
+            qprodata.set_attribute('head', str(qpro.get_int('head')))
+            qprodata.set_attribute('hair', str(qpro.get_int('hair')))
+            qprodata.set_attribute('face', str(qpro.get_int('face')))
+            qprodata.set_attribute('body', str(qpro.get_int('body')))
+            qprodata.set_attribute('hand', str(qpro.get_int('hand')))
+
+        # If the user joined a particular shop, let the game know.
+        if 'shop_location' in profile:
+            shop_id = profile.get_int('shop_location')
+            machine = self.get_machine_by_id(shop_id)
+            if machine is not None:
+                join_shop = Node.void('join_shop')
+                root.add_child(join_shop)
+                join_shop.set_attribute('joinflg', '1')
+                join_shop.set_attribute('join_cflg', '1')
+                join_shop.set_attribute('join_id', ID.format_machine_id(machine.id))
+                join_shop.set_attribute('join_name', machine.name)
+
+        # Step up mode
+        step_dict = profile.get_dict('step')
+        step = Node.void('step')
+        root.add_child(step)
+        step.set_attribute('sp_ach', str(step_dict.get_int('sp_ach')))
+        step.set_attribute('dp_ach', str(step_dict.get_int('dp_ach')))
+        step.set_attribute('sp_hdpt', str(step_dict.get_int('sp_hdpt')))
+        step.set_attribute('dp_hdpt', str(step_dict.get_int('dp_hdpt')))
+        step.set_attribute('sp_level', str(step_dict.get_int('sp_level')))
+        step.set_attribute('dp_level', str(step_dict.get_int('dp_level')))
+        step.set_attribute('sp_round', str(step_dict.get_int('sp_round')))
+        step.set_attribute('dp_round', str(step_dict.get_int('dp_round')))
+        step.set_attribute('sp_mplay', str(step_dict.get_int('sp_mplay')))
+        step.set_attribute('dp_mplay', str(step_dict.get_int('dp_mplay')))
+        step.set_attribute('review', str(step_dict.get_int('review')))
+        if 'stamp' in step_dict:
+            step.add_child(Node.binary('stamp', step_dict.get_bytes('stamp', bytes([0] * 36))))
+        if 'help' in step_dict:
+            step.add_child(Node.binary('help', step_dict.get_bytes('help', bytes([0] * 6))))
+
+        # Daily recommendations
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'dailies')
+        if entry is not None:
+            packinfo = Node.void('packinfo')
+            root.add_child(packinfo)
+
+            pack_id = int(entry['start_time'] / 86400)
+            packinfo.set_attribute('pack_id', str(pack_id))
+            packinfo.set_attribute('music_0', str(entry['music'][0]))
+            packinfo.set_attribute('music_1', str(entry['music'][1]))
+            packinfo.set_attribute('music_2', str(entry['music'][2]))
+        else:
+            # No dailies :(
+            pack_id = None
+
+        # Tran medals and shit
+        achievements = Node.void('achievements')
+        root.add_child(achievements)
+
+        # Dailies
+        if pack_id is None:
+            achievements.set_attribute('pack', '0')
+            achievements.set_attribute('pack_comp', '0')
+        else:
+            daily_played = self.data.local.user.get_achievement(self.game, self.version, userid, pack_id, 'daily')
+            if daily_played is None:
+                daily_played = ValidatedDict()
+            achievements.set_attribute('pack', str(daily_played.get_int('pack_flg')))
+            achievements.set_attribute('pack_comp', str(daily_played.get_int('pack_comp')))
+
+        # Weeklies
+        achievements.set_attribute('last_weekly', str(profile.get_int('last_weekly')))
+        achievements.set_attribute('weekly_num', str(profile.get_int('weekly_num')))
+
+        # Prefecture visit flag
+        achievements.set_attribute('visit_flg', str(profile.get_int('visit_flg')))
+
+        # Number of rivals beaten
+        achievements.set_attribute('rival_crush', str(profile.get_int('rival_crush')))
+
+        # Tran medals
+        achievements.add_child(Node.s64_array('trophy', profile.get_int_array('trophy', 10)))
+
+        # Link5 data
+        if 'link5' in profile:
+            # Don't provide link5 if we haven't saved it, so the game can
+            # initialize it properly.
+            link5_dict = profile.get_dict('link5')
+            link5 = Node.void('link5')
+            root.add_child(link5)
+            for attr in [
+                'qpro',
+                'glass',
+                'treasure',  # not saved
+                'beautiful',
+                'quaver',
+                'castle',
+                'flip',
+                'titans',
+                'exusia',
+                'waxing',
+                'sampling',
+                'beachside',
+                'cuvelia',
+                'reunion',
+                'bad',
+                'turii',
+                'anisakis',
+                'second',
+                'whydidyou',
+                'china',
+                'fallen',
+                'broken',
+                'summer',
+                'sakura',
+                'wuv',
+                'survival',
+                'thunder',
+                'qproflg',  # not saved
+                'glassflg',  # not saved
+                'reflec_data',  # not saved
+            ]:
+                link5.set_attribute(attr, str(link5_dict.get_int(attr)))
+
+        # Track deller, orbs and baron
+        commonboss = Node.void('commonboss')
+        root.add_child(commonboss)
+        commonboss.set_attribute('deller', str(profile.get_int('deller')))
+        commonboss.set_attribute('orb', str(profile.get_int('orbs')))
+        commonboss.set_attribute('baron', str(profile.get_int('baron')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        play_stats = self.get_play_statistics(userid)
+
+        # Track play counts, DJ points and options
+        cltype = int(request.attribute('cltype'))
+        if cltype == self.GAME_CLTYPE_SINGLE:
+            play_stats.increment_int('single_plays')
+            play_stats.replace_int('single_dj_points', int(request.attribute('achi')))
+            newprofile.replace_int('sp_opt', int(request.attribute('opt')))
+        if cltype == self.GAME_CLTYPE_DOUBLE:
+            play_stats.increment_int('double_plays')
+            play_stats.replace_int('double_dj_points', int(request.attribute('achi')))
+            newprofile.replace_int('dp_opt', int(request.attribute('opt')))
+            newprofile.replace_int('dp_opt2', int(request.attribute('opt2')))
+
+        # Profile settings
+        newprofile.replace_int('gno', int(request.attribute('gno')))
+        newprofile.replace_int('gpos', int(request.attribute('gpos')))
+        newprofile.replace_int('timing', int(request.attribute('timing')))
+        newprofile.replace_int('help', int(request.attribute('help')))
+        newprofile.replace_int('sdhd', int(request.attribute('sdhd')))
+        newprofile.replace_int('sdtype', int(request.attribute('sdtype')))
+        newprofile.replace_float('notes', float(request.attribute('notes')))
+        newprofile.replace_int('pase', int(request.attribute('pase')))
+        newprofile.replace_int('judge', int(request.attribute('judge')))
+        newprofile.replace_int('opstyle', int(request.attribute('opstyle')))
+        newprofile.replace_float('hispeed', float(request.attribute('hispeed')))
+        newprofile.replace_int('mode', int(request.attribute('mode')))
+        newprofile.replace_int('pmode', int(request.attribute('pmode')))
+        if 'lift' in request.attributes:
+            newprofile.replace_int('lift', int(request.attribute('lift')))
+
+        # Update judge window adjustments per-machine
+        judge_dict = newprofile.get_dict('machine_judge_adjust')
+        machine_judge = judge_dict.get_dict(self.config['machine']['pcbid'])
+        machine_judge.replace_int('adj', int(request.attribute('judgeAdj')))
+        judge_dict.replace_dict(self.config['machine']['pcbid'], machine_judge)
+        newprofile.replace_dict('machine_judge_adjust', judge_dict)
+
+        # Secret flags saving
+        secret = request.child('secret')
+        if secret is not None:
+            secret_dict = newprofile.get_dict('secret')
+            secret_dict.replace_int('flg1', secret.child_value('flg1'))
+            secret_dict.replace_int('flg2', secret.child_value('flg2'))
+            secret_dict.replace_int('flg3', secret.child_value('flg3'))
+            newprofile.replace_dict('secret', secret_dict)
+
+        # Basic achievements
+        achievements = request.child('achievements')
+        if achievements is not None:
+            newprofile.replace_int('visit_flg', int(achievements.attribute('visit_flg')))
+            newprofile.replace_int('last_weekly', int(achievements.attribute('last_weekly')))
+            newprofile.replace_int('weekly_num', int(achievements.attribute('weekly_num')))
+
+            pack_id = int(achievements.attribute('pack_id'))
+            if pack_id > 0:
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    pack_id,
+                    'daily',
+                    {
+                        'pack_flg': int(achievements.attribute('pack_flg')),
+                        'pack_comp': int(achievements.attribute('pack_comp')),
+                    },
+                )
+
+            trophies = achievements.child('trophy')
+            if trophies is not None:
+                # We only load the first 10 in profile load.
+                newprofile.replace_int_array('trophy', 10, trophies.value[:10])
+
+        # Deller and orb saving
+        commonboss = request.child('commonboss')
+        if commonboss is not None:
+            newprofile.replace_int('deller', newprofile.get_int('deller') + int(commonboss.attribute('deller')))
+            orbs = newprofile.get_int('orbs')
+            orbs = orbs + int(commonboss.attribute('orb'))
+            newprofile.replace_int('orbs', orbs)
+
+        # Step-up mode
+        step = request.child('step')
+        if step is not None:
+            step_dict = newprofile.get_dict('step')
+            if cltype == self.GAME_CLTYPE_SINGLE:
+                step_dict.replace_int('sp_ach', int(step.attribute('sp_ach')))
+                step_dict.replace_int('sp_hdpt', int(step.attribute('sp_hdpt')))
+                step_dict.replace_int('sp_level', int(step.attribute('sp_level')))
+                step_dict.replace_int('sp_round', int(step.attribute('sp_round')))
+                step_dict.replace_int('sp_mplay', int(step.attribute('sp_mplay')))
+            else:
+                step_dict.replace_int('dp_ach', int(step.attribute('dp_ach')))
+                step_dict.replace_int('dp_hdpt', int(step.attribute('dp_hdpt')))
+                step_dict.replace_int('dp_level', int(step.attribute('dp_level')))
+                step_dict.replace_int('dp_round', int(step.attribute('dp_round')))
+                step_dict.replace_int('dp_mplay', int(step.attribute('dp_mplay')))
+            step_dict.replace_int('review', int(step.attribute('review')))
+
+            newprofile.replace_dict('step', step_dict)
+
+        # Link5 data
+        link5 = request.child('link5')
+        if link5 is not None:
+            link5_dict = newprofile.get_dict('link5')
+            for attr in [
+                'qpro',
+                'glass',
+                'beautiful',
+                'quaver',
+                'castle',
+                'flip',
+                'titans',
+                'exusia',
+                'waxing',
+                'sampling',
+                'beachside',
+                'cuvelia',
+                'reunion',
+                'bad',
+                'turii',
+                'anisakis',
+                'second',
+                'whydidyou',
+                'china',
+                'fallen',
+                'broken',
+                'summer',
+                'sakura',
+                'wuv',
+                'survival',
+                'thunder',
+            ]:
+                link5_dict.replace_int(attr, int(link5.attribute(attr)))
+            newprofile.replace_dict('link5', link5_dict)
+
+        # Keep track of play statistics across all mixes
+        self.update_play_statistics(userid, play_stats)
+
+        return newprofile
diff --git a/bemani/backend/jubeat/__init__.py b/bemani/backend/jubeat/__init__.py
new file mode 100644
index 0000000..028c492
--- /dev/null
+++ b/bemani/backend/jubeat/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.jubeat.factory import JubeatFactory
+from bemani.backend.jubeat.base import JubeatBase
diff --git a/bemani/backend/jubeat/base.py b/bemani/backend/jubeat/base.py
new file mode 100644
index 0000000..64c782c
--- /dev/null
+++ b/bemani/backend/jubeat/base.py
@@ -0,0 +1,255 @@
+# vim: set fileencoding=utf-8
+from typing import Dict, List, Optional
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import DBConstants, GameConstants, ValidatedDict
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class JubeatBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all Jubeat versions. Handles common functionality for getting
+    profiles based on refid, creating new profiles, looking up and saving scores.
+    """
+
+    game = GameConstants.JUBEAT
+
+    GAME_FLAG_BIT_PLAYED = 0x1
+    GAME_FLAG_BIT_CLEARED = 0x2
+    GAME_FLAG_BIT_FULL_COMBO = 0x4
+    GAME_FLAG_BIT_EXCELLENT = 0x8
+    GAME_FLAG_BIT_NEARLY_FULL_COMBO = 0x10
+    GAME_FLAG_BIT_NEARLY_EXCELLENT = 0x20
+    GAME_FLAG_BIT_NO_GRAY = 0x40
+    GAME_FLAG_BIT_NO_YELLOW = 0x80
+
+    PLAY_MEDAL_FAILED = DBConstants.JUBEAT_PLAY_MEDAL_FAILED
+    PLAY_MEDAL_CLEARED = DBConstants.JUBEAT_PLAY_MEDAL_CLEARED
+    PLAY_MEDAL_NEARLY_FULL_COMBO = DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_FULL_COMBO
+    PLAY_MEDAL_FULL_COMBO = DBConstants.JUBEAT_PLAY_MEDAL_FULL_COMBO
+    PLAY_MEDAL_NEARLY_EXCELLENT = DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT
+    PLAY_MEDAL_EXCELLENT = DBConstants.JUBEAT_PLAY_MEDAL_EXCELLENT
+
+    CHART_TYPE_BASIC = 0
+    CHART_TYPE_ADVANCED = 1
+    CHART_TYPE_EXTREME = 2
+
+    def previous_version(self) -> Optional['JubeatBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def put_profile(self, userid: UserID, profile: ValidatedDict) -> None:
+        """
+        Save a new profile for this user given a game/version. Overrides but calls
+        the same functionality in Base, to ensure we don't save calculated values.
+
+        Parameters:
+            userid - The user ID we are saving the profile for.
+            profile - A dictionary that should be looked up later using get_profile.
+        """
+        if 'has_old_version' in profile:
+            del profile['has_old_version']
+        super().put_profile(userid, profile)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('gametop')
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        """
+        Base handler for a score list. Given a userid, profile and a score list,
+        return a Node representing a score list. Should be overridden.
+        """
+        return Node.void('gametop')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication.
+        """
+        if refid is None:
+            return None
+
+        # First try to load the actual profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+
+        # Now try to find out if the profile is new or old
+        oldversion = self.previous_version()
+        oldprofile = oldversion.get_profile(userid)
+        profile['has_old_version'] = oldprofile is not None
+
+        # Now, return it
+        return self.format_profile(userid, profile)
+
+    def new_profile_by_refid(self, refid: Optional[str], name: Optional[str]) -> Node:
+        """
+        Given a RefID and an optional name, create a profile and then return
+        a formatted profile node. Similar rationale to get_profile_by_refid.
+        """
+        if refid is None:
+            return None
+
+        if name is None:
+            name = 'なし'
+
+        # First, create and save the default profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        defaultprofile = ValidatedDict({
+            'name': name,
+        })
+        self.put_profile(userid, defaultprofile)
+
+        # Now, reload and format the profile, looking up the has old version flag
+        profile = self.get_profile(userid)
+
+        oldversion = self.previous_version()
+        oldprofile = oldversion.get_profile(userid)
+        profile['has_old_version'] = oldprofile is not None
+
+        return self.format_profile(userid, profile)
+
+    def get_scores_by_extid(self, extid: Optional[int]) -> Optional[Node]:
+        """
+        Given an ExtID, return a formatted score node. Similar rationale to
+        get_profile_by_refid.
+        """
+        if extid is None:
+            return None
+
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        if scores is None:
+            return None
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+        return self.format_scores(userid, profile, scores)
+
+    def update_score(
+        self,
+        userid: UserID,
+        timestamp: int,
+        songid: int,
+        chart: int,
+        points: int,
+        medal: int,
+        combo: int,
+        ghost: Optional[List[int]]=None,
+        stats: Optional[Dict[str, int]]=None,
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in Jubeat series can expect
+        the same attributes in a score.
+        """
+        # Range check medals
+        if medal not in [
+            self.PLAY_MEDAL_FAILED,
+            self.PLAY_MEDAL_CLEARED,
+            self.PLAY_MEDAL_NEARLY_FULL_COMBO,
+            self.PLAY_MEDAL_FULL_COMBO,
+            self.PLAY_MEDAL_NEARLY_EXCELLENT,
+            self.PLAY_MEDAL_EXCELLENT,
+        ]:
+            raise Exception("Invalid medal value {}".format(medal))
+
+        oldscore = self.data.local.music.get_score(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+        )
+
+        # Score history is verbatum, instead of highest score
+        history = ValidatedDict({})
+        oldpoints = points
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({})
+            raised = True
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            raised = points > oldscore.points
+            highscore = points >= oldscore.points
+            points = max(oldscore.points, points)
+            scoredata = oldscore.data
+
+        # Replace medal with highest value
+        scoredata.replace_int('medal', max(scoredata.get_int('medal'), medal))
+        history.replace_int('medal', medal)
+
+        # Increment counters based on medal
+        if medal == self.PLAY_MEDAL_CLEARED:
+            scoredata.increment_int('clear_count')
+        if medal == self.PLAY_MEDAL_FULL_COMBO:
+            scoredata.increment_int('full_combo_count')
+        if medal == self.PLAY_MEDAL_EXCELLENT:
+            scoredata.increment_int('excellent_count')
+
+        # If we have a combo, replace it
+        scoredata.replace_int('combo', max(scoredata.get_int('combo'), combo))
+        history.replace_int('combo', combo)
+
+        if stats is not None:
+            if raised:
+                # We have stats, and there's a new high score, update the stats
+                scoredata.replace_dict('stats', stats)
+            history.replace_dict('stats', stats)
+
+        if ghost is not None:
+            # Update the ghost regardless, but don't bother with it in history
+            scoredata.replace_int_array('ghost', len(ghost), ghost)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        # Write the new score back
+        self.data.local.music.put_score(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+            lid,
+            points,
+            scoredata,
+            highscore,
+            timestamp=timestamp,
+        )
+
+        # Save the history of this score too
+        self.data.local.music.put_attempt(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+            lid,
+            oldpoints,
+            history,
+            raised,
+            timestamp=timestamp,
+        )
diff --git a/bemani/backend/jubeat/clan.py b/bemani/backend/jubeat/clan.py
new file mode 100644
index 0000000..80426d9
--- /dev/null
+++ b/bemani/backend/jubeat/clan.py
@@ -0,0 +1,1897 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.backend.jubeat.common import (
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+)
+from bemani.backend.jubeat.qubell import JubeatQubell
+
+from bemani.backend.base import Status
+from bemani.common import Time, ValidatedDict, VersionConstants
+from bemani.data import Data, Achievement, Score, Song, UserID
+from bemani.protocol import Node
+
+
+class JubeatClan(
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+    JubeatBase,
+):
+
+    name = 'Jubeat Clan'
+    version = VersionConstants.JUBEAT_CLAN
+
+    JBOX_EMBLEM_NORMAL = 1
+    JBOX_EMBLEM_PREMIUM = 2
+
+    EVENT_STATUS_OPEN = 0x1
+    EVENT_STATUS_COMPLETE = 0x2
+
+    EVENTS = {
+        5: {
+            'enabled': False,
+        },
+        6: {
+            'enabled': False,
+        },
+        15: {
+            'enabled': True,
+        },
+        22: {
+            'enabled': False,
+        },
+        23: {
+            'enabled': False,
+        },
+        34: {
+            'enabled': False,
+        },
+    }
+
+    FIVE_PLAYS_UNLOCK_EVENT_SONG_IDS = set(range(80000301, 80000348))
+
+    COURSE_STATUS_SEEN = 0x01
+    COURSE_STATUS_PLAYED = 0x02
+    COURSE_STATUS_CLEARED = 0x04
+
+    COURSE_TYPE_PERMANENT = 1
+    COURSE_TYPE_TIME_BASED = 2
+
+    COURSE_CLEAR_SCORE = 1
+    COURSE_CLEAR_COMBINED_SCORE = 2
+    COURSE_CLEAR_HAZARD = 3
+
+    COURSE_HAZARD_EXC1 = 1
+    COURSE_HAZARD_EXC2 = 2
+    COURSE_HAZARD_EXC3 = 3
+    COURSE_HAZARD_FC1 = 4
+    COURSE_HAZARD_FC2 = 5
+    COURSE_HAZARD_FC3 = 6
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatQubell(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert daily FC challenges into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'fc_challenge', 'daily'):
+            # Generate a new list of two FC challenge songs. Skip a particular song range since these are all a single song ID.
+            # Jubeat Clan has an unlock event where you have to play different charts for the same song, and the charts are
+            # loaded in based on the cabinet's prefecture. So, no matter where you are, you will only see one song within this
+            # range, but it will be a different ID depending on the prefecture set in settings. This means its not safe to send
+            # these song IDs, so we explicitly exclude them.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = set(song.id for song in data.local.music.get_all_songs(cls.game, cls.version) if song.id not in cls.FIVE_PLAYS_UNLOCK_EVENT_SONG_IDS)
+            daily_songs = random.sample(all_songs, 2)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'fc_challenge',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            )
+            events.append((
+                'jubeat_fc_challenge_charts',
+                {
+                    'version': cls.version,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'fc_challenge', 'daily')
+        return events
+
+    def __get_course_list(self) -> List[Dict[str, Any]]:
+        return [
+            # Papricapcap courses
+            {
+                'id': 1,
+                'name': 'Thank You Merry Christmas',
+                'course_type': self.COURSE_TYPE_TIME_BASED,
+                'end_time': Time.end_of_this_week() + Time.SECONDS_IN_WEEK,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 3,
+                'score': 700000,
+                'music': [
+                    [(50000077, 0), (50000077, 1), (50000077, 2)],
+                    [(80000080, 0), (80000080, 1), (80000080, 2)],
+                    [(50000278, 0), (50000278, 1), (50000278, 2)],
+                ],
+            },
+            {
+                'id': 2,
+                'name': 'はじめての山道',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 1,
+                'score': 700000,
+                'music': [
+                    [(20000002, 0), (20000022, 0), (30000108, 0)],
+                    [(70000035, 0), (70000069, 0), (80000020, 0)],
+                    [(50000116, 0), (50000120, 0), (50000383, 0)],
+                ],
+            },
+            {
+                'id': 3,
+                'name': 'NOBOLOT検定 第1の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 1,
+                'score': 700000,
+                'music': [
+                    [(20000109, 0), (50000218, 0), (60000100, 0)],
+                    [(50000228, 0), (70000125, 0)],
+                    [(70000109, 0)],
+                ],
+            },
+            {
+                'id': 4,
+                'name': 'アニメハイキング',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 2,
+                'score': 750000,
+                'music': [
+                    [(70000028, 0)],
+                    [(70000030, 0)],
+                    [(80001009, 0)],
+                ],
+            },
+            {
+                'id': 5,
+                'name': 'しりとり山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 3,
+                'score': 750000,
+                'music': [
+                    [(10000068, 0), (50000089, 0), (60000078, 0)],
+                    [(50000059, 0), (50000147, 0), (50000367, 0)],
+                    [(50000202, 0), (70000144, 0), (70000156, 0)],
+                ],
+            },
+            {
+                'id': 6,
+                'name': 'NOBOLOT検定 第2の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 3,
+                'score': 800000,
+                'music': [
+                    [(50000268, 0), (70000039, 0), (70000160, 0)],
+                    [(60000080, 1), (80000014, 0)],
+                    [(60000053, 0)],
+                ],
+            },
+            # Harapenya-na courses
+            {
+                'id': 11,
+                'name': 'おためし！い~あみゅちゃん',
+                'course_type': self.COURSE_TYPE_TIME_BASED,
+                'end_time': Time.end_of_this_week() + Time.SECONDS_IN_WEEK,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 4,
+                'score': 700000,
+                'music': [
+                    [(50000207, 0), (50000207, 1), (50000207, 2)],
+                    [(50000111, 0), (50000111, 1), (50000111, 2)],
+                    [(60000009, 0), (60000009, 1), (60000009, 2)],
+                ],
+            },
+            {
+                'id': 12,
+                'name': 'NOBOLOT検定 第3の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 4,
+                'score': 850000,
+                'music': [
+                    [(40000110, 1), (70000059, 1), (70000131, 1)],
+                    [(30000004, 1), (80000035, 1)],
+                    [(40000051, 1)],
+                ],
+            },
+            {
+                'id': 13,
+                'name': '頂上から見えるお月様',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 5,
+                'score': 850000,
+                'music': [
+                    [(50000245, 1)],
+                    [(60000051, 1)],
+                    [(80001011, 1)],
+                ],
+            },
+            {
+                'id': 14,
+                'name': 'ヒッチハイクでGO!GO!',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 5,
+                'score': 850000,
+                'music': [
+                    [(10000053, 1), (80000038, 1)],
+                    [(30000123, 1), (50000086, 1), (70000119, 1)],
+                    [(50000196, 1), (60000006, 1), (70000153, 1)],
+                ],
+            },
+            {
+                'id': 15,
+                'name': '今日の一文字',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 6,
+                'score': 2600000,
+                'music': [
+                    [(50000071, 1)],
+                    [(40000053, 1)],
+                    [(70000107, 1)],
+                ],
+            },
+            {
+                'id': 16,
+                'name': 'NOBOLOT検定 第4の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 6,
+                'score': 2650000,
+                'music': [
+                    [(50000085, 2), (50000176, 2), (70000055, 2)],
+                    [(50000157, 2), (60001008, 2)],
+                    [(10000068, 2)],
+                ],
+            },
+            # Tillhorn courses
+            {
+                'id': 21,
+                'name': 'ちくわの山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 7,
+                'score': 870000,
+                'music': [
+                    [(70000099, 2)],
+                    [(50000282, 2), (60000106, 2), (80000041, 2)],
+                    [(50000234, 2)],
+                ],
+            },
+            {
+                'id': 22,
+                'name': 'NOBOLOT検定 第5の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 7,
+                'score': 2650000,
+                'music': [
+                    [(50000233, 2), (50000242, 1), (80000032, 2)],
+                    [(60000027, 2), (60000045, 2)],
+                    [(20000038, 2)],
+                ],
+            },
+            {
+                'id': 23,
+                'name': '初めてのHARD MODE',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'hard': True,
+                'difficulty': 8,
+                'score': 835000,
+                'music': [
+                    [(50000247, 2)],
+                    [(70000071, 2)],
+                    [(20000042, 2)],
+                ],
+            },
+            {
+                'id': 24,
+                'name': '雪山の上のお姫様',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 8,
+                'score': 2700000,
+                'music': [
+                    [(50000101, 2)],
+                    [(50000119, 2), (50000174, 2), (60000009, 2)],
+                    [(80001010, 2)],
+                ],
+            },
+            {
+                'id': 25,
+                'name': 'なが~い山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 9,
+                'score': 2800000,
+                'music': [
+                    [(70000170, 2), (80000013, 2)],
+                    [(70000161, 2), (80000057, 2)],
+                    [(80000043, 2)],
+                ],
+            },
+            {
+                'id': 26,
+                'name': 'NOBOLOT検定 第6の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 9,
+                'score': 2750000,
+                'music': [
+                    [(50000034, 2), (50000252, 2), (50000347, 2)],
+                    [(70000117, 2), (70000138, 2)],
+                    [(50000078, 2)],
+                ],
+            },
+            # Bahaneroy courses
+            {
+                'id': 31,
+                'name': '挑戦！い~あみゅちゃん',
+                'course_type': self.COURSE_TYPE_TIME_BASED,
+                'end_time': Time.end_of_this_week() + Time.SECONDS_IN_WEEK,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 12,
+                'score': 2823829,
+                'music': [
+                    [(50000207, 2)],
+                    [(50000111, 2)],
+                    [(60001006, 2)],
+                ],
+            },
+            {
+                'id': 32,
+                'name': '更なる高みを目指して',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'difficulty': 10,
+                'score': 920000,
+                'music': [
+                    [(50000210, 2)],
+                    [(50000122, 2)],
+                    [(70000022, 2)],
+                ],
+            },
+            {
+                'id': 33,
+                'name': 'NOBOLOT検定 第7の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 10,
+                'score': 2800000,
+                'music': [
+                    [(60000059, 2), (60000079, 2), (70000006, 2)],
+                    [(50000060, 2), (50000127, 2)],
+                    [(60000073, 2)],
+                ],
+            },
+            {
+                'id': 34,
+                'name': '崖っぷち! スリーチャレンジ!',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_HAZARD,
+                'hazard_type': self.COURSE_HAZARD_FC3,
+                'difficulty': 11,
+                'music': [
+                    [(10000036, 2), (30000049, 2), (50000172, 2)],
+                    [(30000044, 2), (40000044, 2), (60000028, 2)],
+                    [(60000074, 2)],
+                ],
+            },
+            {
+                'id': 35,
+                'name': '芽吹いて咲いて',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 11,
+                'score': 2800000,
+                'music': [
+                    [(60001003, 2)],
+                    [(70000097, 2)],
+                    [(80001013, 2)],
+                ],
+            },
+            {
+                'id': 36,
+                'name': '1! 2! Party Night!',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 12,
+                'score': 2800000,
+                'music': [
+                    [(70000174, 2)],
+                    [(60000081, 2)],
+                    [(30000048, 2)],
+                ],
+            },
+            {
+                'id': 37,
+                'name': 'NOBOLOT検定 第8の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 12,
+                'score': 2820000,
+                'music': [
+                    [(50000124, 2)],
+                    [(50000291, 2)],
+                    [(60000065, 2)],
+                ],
+            },
+            # Jolokili courses
+            {
+                'id': 41,
+                'name': 'The 7th KAC 1st Stage 個人部門',
+                'course_type': self.COURSE_TYPE_TIME_BASED,
+                'end_time': Time.end_of_this_week() + Time.SECONDS_IN_WEEK,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'hard': True,
+                'difficulty': 13,
+                'score': 700000,
+                'music': [
+                    [(80000076, 2)],
+                    [(80000025, 2)],
+                    [(60000073, 2)],
+                ],
+            },
+            {
+                'id': 42,
+                'name': 'The 7th KAC 2nd Stage 個人部門',
+                'course_type': self.COURSE_TYPE_TIME_BASED,
+                'end_time': Time.end_of_this_week() + Time.SECONDS_IN_WEEK,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'hard': True,
+                'difficulty': 13,
+                'score': 700000,
+                'music': [
+                    [(80000081, 2)],
+                    [(70000145, 2)],
+                    [(80001013, 2)],
+                ],
+            },
+            {
+                'id': 43,
+                'name': 'The 7th KAC 団体部門',
+                'course_type': self.COURSE_TYPE_TIME_BASED,
+                'end_time': Time.end_of_this_week() + Time.SECONDS_IN_WEEK,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'hard': True,
+                'difficulty': 13,
+                'score': 700000,
+                'music': [
+                    [(70000162, 2)],
+                    [(70000134, 2)],
+                    [(70000173, 1)],
+                ],
+            },
+            {
+                'id': 44,
+                'name': 'ハードモード de ホームラン?!',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 13,
+                'score': 2750000,
+                'music': [
+                    [(50000259, 2)],
+                    [(50000255, 2)],
+                    [(50000266, 2)],
+                ],
+            },
+            {
+                'id': 45,
+                'name': 'NOBOLOT検定 第9の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'difficulty': 13,
+                'score': 2830000,
+                'music': [
+                    [(50000022, 2)],
+                    [(50000023, 2)],
+                    [(50000323, 2)],
+                ],
+            },
+            {
+                'id': 46,
+                'name': '崖っぷちスリーチャレンジ!その2',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_HAZARD,
+                'hazard_type': self.COURSE_HAZARD_EXC3,
+                'difficulty': 14,
+                'music': [
+                    [(50000024, 2), (50000160, 2), (70000065, 2)],
+                    [(30000122, 2), (50000178, 2), (50000383, 2)],
+                    [(50000122, 2), (50000261, 2), (80000010, 2)],
+                ],
+            },
+            {
+                'id': 47,
+                'name': 'もう一つの姿を求めて',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_SCORE,
+                'hard': True,
+                'difficulty': 14,
+                'score': 920000,
+                'music': [
+                    [(60001009, 2)],
+                    [(80001006, 2)],
+                    [(80001015, 2)],
+                ],
+            },
+            {
+                'id': 48,
+                'name': 'NOBOLOT検定 第10の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 14,
+                'score': 2820000,
+                'music': [
+                    [(50000202, 2), (50000203, 2), (70000108, 2)],
+                    [(40000046, 2), (40000057, 2)],
+                    [(50000134, 2)],
+                ],
+            },
+            # Calorest courses
+            {
+                'id': 51,
+                'name': '流れに身を任せて',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 15,
+                'score': 2850000,
+                'music': [
+                    [(60000001, 2)],
+                    [(80000022, 2)],
+                    [(50000108, 2)],
+                ],
+            },
+            {
+                'id': 52,
+                'name': '【挑戦】NOBOLOT検定 神の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 15,
+                'score': 2850000,
+                'music': [
+                    [(40000057, 2)],
+                    [(60000076, 2)],
+                    [(50000102, 2)],
+                ],
+            },
+            {
+                'id': 53,
+                'name': '伝説の伝導師の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 16,
+                'score': 2960000,
+                'music': [
+                    [(80000028, 2)],
+                    [(80000023, 2)],
+                    [(80000087, 2)],
+                ],
+            },
+            {
+                'id': 54,
+                'name': 'EXCELLENT MASTER',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_HAZARD,
+                'hazard_type': self.COURSE_HAZARD_EXC1,
+                'difficulty': 16,
+                'music': [
+                    [(20000125, 2), (50000330, 2), (40000060, 2)],
+                    [(30000127, 2), (50000206, 2), (50000253, 2)],
+                    [(70000011, 2)],
+                ],
+            },
+            {
+                'id': 55,
+                'name': '【挑戦】NOBOLOT検定 英雄の山',
+                'course_type': self.COURSE_TYPE_PERMANENT,
+                'clear_type': self.COURSE_CLEAR_COMBINED_SCORE,
+                'hard': True,
+                'difficulty': 16,
+                'score': 2980000,
+                'music': [
+                    [(50000100, 2)],
+                    [(70000110, 2)],
+                    [(50000208, 2)],
+                ],
+            },
+        ]
+
+    def __get_global_info(self) -> Node:
+        info = Node.void('info')
+
+        # Event info.
+        event_info = Node.void('event_info')
+        info.add_child(event_info)
+        for event in self.EVENTS:
+            evt = Node.void('event')
+            event_info.add_child(evt)
+            evt.set_attribute('type', str(event))
+            evt.add_child(Node.u8('state', self.EVENT_STATUS_OPEN if self.EVENTS[event]['enabled'] else 0))
+
+        # Each of the following two sections should have zero or more child nodes (no
+        # particular name) which look like the following:
+        #     <node>
+        #         <id __type="s32">songid</id>
+        #         <stime __type="str">start time?</stime>
+        #         <etime __type="str">end time?</etime>
+        #     </node>
+        # Share music?
+        share_music = Node.void('share_music')
+        info.add_child(share_music)
+
+        genre_def_music = Node.void('genre_def_music')
+        info.add_child(genre_def_music)
+
+        info.add_child(Node.s32_array(
+            'black_jacket_list',
+            [
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+            ],
+        ))
+
+        # Some sort of music DB whitelist
+        info.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'white_marker_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'white_theme_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'open_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'shareable_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        jbox = Node.void('jbox')
+        info.add_child(jbox)
+        jbox.add_child(Node.s32('point', 0))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        normal = Node.void('normal')
+        emblem.add_child(normal)
+        premium = Node.void('premium')
+        emblem.add_child(premium)
+        normal.add_child(Node.s16('index', 0))
+        premium.add_child(Node.s16('index', 0))
+
+        born = Node.void('born')
+        info.add_child(born)
+        born.add_child(Node.s8('status', 0))
+        born.add_child(Node.s16('year', 0))
+
+        # Collection list values should look like:
+        #     <rating>
+        #         <id __type="s32">songid</id>
+        #         <stime __type="str">start time?</stime>
+        #         <etime __type="str">end time?</etime>
+        #     </node>
+        collection = Node.void('collection')
+        info.add_child(collection)
+        collection.add_child(Node.void('rating_s'))
+
+        expert_option = Node.void('expert_option')
+        info.add_child(expert_option)
+        expert_option.add_child(Node.bool('is_available', True))
+
+        all_music_matching = Node.void('all_music_matching')
+        info.add_child(all_music_matching)
+        all_music_matching.add_child(Node.bool('is_available', True))
+        team = Node.void('team')
+        all_music_matching.add_child(team)
+        team.add_child(Node.s32('default_flag', 0))
+        team.add_child(Node.s32('redbelk_flag', 0))
+        team.add_child(Node.s32('cyanttle_flag', 0))
+        team.add_child(Node.s32('greenesia_flag', 0))
+        team.add_child(Node.s32('plumpark_flag', 0))
+
+        question_list = Node.void('question_list')
+        info.add_child(question_list)
+
+        drop_list = Node.void('drop_list')
+        info.add_child(drop_list)
+
+        daily_bonus_list = Node.void('daily_bonus_list')
+        info.add_child(daily_bonus_list)
+
+        department = Node.void('department')
+        info.add_child(department)
+        department.add_child(Node.void('pack_list'))
+
+        # Set up NOBOLOT course requirements
+        clan_course_list = Node.void('clan_course_list')
+        info.add_child(clan_course_list)
+
+        valid_courses: Set[int] = set()
+        for course in self.__get_course_list():
+            if course['id'] < 1:
+                raise Exception(f"Invalid course ID {course['id']} found in course list!")
+            if course['id'] in valid_courses:
+                raise Exception(f"Duplicate ID {course['id']} found in course list!")
+            if course['clear_type'] == self.COURSE_CLEAR_HAZARD and 'hazard_type' not in course:
+                raise Exception(f"Need 'hazard_type' set in course {course['id']}!")
+            if course['course_type'] == self.COURSE_TYPE_TIME_BASED and 'end_time' not in course:
+                raise Exception(f"Need 'end_time' set in course {course['id']}!")
+            if course['clear_type'] in [self.COURSE_CLEAR_SCORE, self.COURSE_CLEAR_COMBINED_SCORE] and 'score' not in course:
+                raise Exception(f"Need 'score' set in course {course['id']}!")
+            if course['clear_type'] == self.COURSE_CLEAR_SCORE and course['score'] > 1000000:
+                raise Exception(f"Invalid per-coure score in course {course['id']}!")
+            if course['clear_type'] == self.COURSE_CLEAR_COMBINED_SCORE and course['score'] <= 1000000:
+                raise Exception(f"Invalid combined score in course {course['id']}!")
+            valid_courses.add(course['id'])
+
+            # Basics
+            clan_course = Node.void('clan_course')
+            clan_course_list.add_child(clan_course)
+            clan_course.set_attribute('release_code', '2017062600')
+            clan_course.set_attribute('version_id', '0')
+            clan_course.set_attribute('id', str(course['id']))
+            clan_course.set_attribute('course_type', str(course['course_type']))
+            clan_course.add_child(Node.s32('difficulty', course['difficulty']))
+            clan_course.add_child(Node.u64('etime', (course['end_time'] if 'end_time' in course else 0) * 1000))
+            clan_course.add_child(Node.string('name', course['name']))
+
+            # List of included songs
+            tune_list = Node.void('tune_list')
+            clan_course.add_child(tune_list)
+            for order, charts in enumerate(course['music']):
+                tune = Node.void('tune')
+                tune_list.add_child(tune)
+                tune.set_attribute('no', str(order + 1))
+
+                seq_list = Node.void('seq_list')
+                tune.add_child(seq_list)
+
+                for songid, chart in charts:
+                    seq = Node.void('seq')
+                    seq_list.add_child(seq)
+                    seq.add_child(Node.s32('music_id', songid))
+                    seq.add_child(Node.s32('difficulty', chart))
+                    seq.add_child(Node.bool('is_secret', False))
+
+            # Clear criteria
+            clear = Node.void('clear')
+            clan_course.add_child(clear)
+            ex_option = Node.void('ex_option')
+            clear.add_child(ex_option)
+            ex_option.add_child(Node.bool('is_hard', course['hard'] if 'hard' in course else False))
+            ex_option.add_child(Node.s32('hazard_type', course['hazard_type'] if 'hazard_type' in course else 0))
+            clear.set_attribute('type', str(course['clear_type']))
+            clear.add_child(Node.s32('score', course['score'] if 'score' in course else 0))
+
+            reward_list = Node.void('reward_list')
+            clear.add_child(reward_list)
+
+        # Set up NOBOLOT category display
+        category_list = Node.void('category_list')
+        clan_course_list.add_child(category_list)
+
+        # Each category has one of the following nodes
+        categories: List[Tuple[int, int]] = [
+            (1, 3),
+            (4, 6),
+            (7, 9),
+            (10, 12),
+            (13, 14),
+            (15, 16),
+        ]
+        for categoryid, (min_level, max_level) in enumerate(categories):
+            category = Node.void('category')
+            category_list.add_child(category)
+            category.set_attribute('id', str(categoryid + 1))
+            category.add_child(Node.bool('is_secret', False))
+            category.add_child(Node.s32('level_min', min_level))
+            category.add_child(Node.s32('level_max', max_level))
+
+        return info
+
+    def handle_shopinfo_regist_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('shop/name'))
+
+        shopinfo = Node.void('shopinfo')
+
+        data = Node.void('data')
+        shopinfo.add_child(data)
+        data.add_child(Node.u32('cabid', 1))
+        data.add_child(Node.string('locationid', 'nowhere'))
+        data.add_child(Node.u8('tax_phase', 1))
+
+        facility = Node.void('facility')
+        data.add_child(facility)
+        facility.add_child(Node.u32('exist', 1))
+
+        data.add_child(self.__get_global_info())
+
+        return shopinfo
+
+    def handle_demodata_get_info_request(self, request: Node) -> Node:
+        root = Node.void('demodata')
+        data = Node.void('data')
+        root.add_child(data)
+
+        info = Node.void('info')
+        data.add_child(info)
+
+        info.add_child(Node.s32_array(
+            'black_jacket_list',
+            [
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+            ],
+        ))
+
+        return root
+
+    def handle_demodata_get_jbox_list_request(self, request: Node) -> Node:
+        root = Node.void('demodata')
+        return root
+
+    def handle_jbox_get_agreement_request(self, request: Node) -> Node:
+        root = Node.void('jbox')
+        root.add_child(Node.bool('is_agreement', True))
+        return root
+
+    def handle_jbox_get_list_request(self, request: Node) -> Node:
+        root = Node.void('jbox')
+        root.add_child(Node.void('selection_list'))
+        return root
+
+    def handle_recommend_get_recommend_request(self, request: Node) -> Node:
+        recommend = Node.void('recommend')
+        data = Node.void('data')
+        recommend.add_child(data)
+
+        player = Node.void('player')
+        data.add_child(player)
+        music_list = Node.void('music_list')
+        player.add_child(music_list)
+
+        recommended_songs: List[Song] = []
+        for i, song in enumerate(recommended_songs):
+            music = Node.void('music')
+            music_list.add_child(music)
+            music.set_attribute('order', str(i))
+            music.add_child(Node.s32('music_id', song.id))
+            music.add_child(Node.s8('seq', song.chart))
+
+        return recommend
+
+    def handle_gametop_get_info_request(self, request: Node) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        data.add_child(self.__get_global_info())
+
+        return root
+
+    def handle_gametop_regist_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        refid = player.child_value('refid')
+        name = player.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        return root
+
+    def handle_gametop_get_pdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        refid = player.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_mdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+        root = self.get_scores_by_extid(extid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gameend_final_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+
+        if player is not None:
+            refid = player.child_value('refid')
+        else:
+            refid = None
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            profile = self.get_profile(userid)
+
+            # Grab unlock progress
+            item = player.child('item')
+            if item is not None:
+                profile.replace_int_array('emblem_list', 96, item.child_value('emblem_list'))
+
+            # jbox stuff
+            jbox = player.child('jbox')
+            jboxdict = profile.get_dict('jbox')
+            if jbox is not None:
+                jboxdict.replace_int('point', jbox.child_value('point'))
+                emblemtype = jbox.child_value('emblem/type')
+                index = jbox.child_value('emblem/index')
+                if emblemtype == self.JBOX_EMBLEM_NORMAL:
+                    jboxdict.replace_int('normal_index', index)
+                elif emblemtype == self.JBOX_EMBLEM_PREMIUM:
+                    jboxdict.replace_int('premium_index', index)
+            profile.replace_dict('jbox', jboxdict)
+
+            # Born stuff
+            born = player.child('born')
+            if born is not None:
+                profile.replace_int('born_status', born.child_value('status'))
+                profile.replace_int('born_year', born.child_value('year'))
+        else:
+            profile = None
+
+        if userid is not None and profile is not None:
+            self.put_profile(userid, profile)
+
+        return Node.void('gameend')
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('gametop')
+        datanode = Node.void('data')
+        root.add_child(datanode)
+        player = Node.void('player')
+        datanode.add_child(player)
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+        playdata = Node.void('mdata_list')
+        player.add_child(playdata)
+
+        music = ValidatedDict()
+        for score in scores:
+            data = music.get_dict(str(score.id))
+            play_cnt = data.get_int_array('play_cnt', 3)
+            clear_cnt = data.get_int_array('clear_cnt', 3)
+            clear_flags = data.get_int_array('clear_flags', 3)
+            fc_cnt = data.get_int_array('fc_cnt', 3)
+            ex_cnt = data.get_int_array('ex_cnt', 3)
+            points = data.get_int_array('points', 3)
+
+            # Replace data for this chart type
+            play_cnt[score.chart] = score.plays
+            clear_cnt[score.chart] = score.data.get_int('clear_count')
+            fc_cnt[score.chart] = score.data.get_int('full_combo_count')
+            ex_cnt[score.chart] = score.data.get_int('excellent_count')
+            points[score.chart] = score.points
+
+            # Format the clear flags
+            clear_flags[score.chart] = self.GAME_FLAG_BIT_PLAYED
+            if score.data.get_int('clear_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_CLEARED
+            if score.data.get_int('full_combo_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_FULL_COMBO
+            if score.data.get_int('excellent_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_EXCELLENT
+
+            # Save chart data back
+            data.replace_int_array('play_cnt', 3, play_cnt)
+            data.replace_int_array('clear_cnt', 3, clear_cnt)
+            data.replace_int_array('clear_flags', 3, clear_flags)
+            data.replace_int_array('fc_cnt', 3, fc_cnt)
+            data.replace_int_array('ex_cnt', 3, ex_cnt)
+            data.replace_int_array('points', 3, points)
+
+            # Update the ghost (untyped)
+            ghost = data.get('ghost', [None, None, None])
+            ghost[score.chart] = score.data.get('ghost')
+            data['ghost'] = ghost
+
+            # Save it back
+            if score.id in self.FIVE_PLAYS_UNLOCK_EVENT_SONG_IDS:
+                # Mirror it to every version so the score shows up regardless of
+                # prefecture setting.
+                for prefecture_id in self.FIVE_PLAYS_UNLOCK_EVENT_SONG_IDS:
+                    music.replace_dict(str(prefecture_id), data)
+            else:
+                # Regular copy.
+                music.replace_dict(str(score.id), data)
+
+        for scoreid in music:
+            scoredata = music.get_dict(scoreid)
+            musicdata = Node.void('musicdata')
+            playdata.add_child(musicdata)
+
+            musicdata.set_attribute('music_id', scoreid)
+            musicdata.add_child(Node.s32_array('play_cnt', scoredata.get_int_array('play_cnt', 3)))
+            musicdata.add_child(Node.s32_array('clear_cnt', scoredata.get_int_array('clear_cnt', 3)))
+            musicdata.add_child(Node.s32_array('fc_cnt', scoredata.get_int_array('fc_cnt', 3)))
+            musicdata.add_child(Node.s32_array('ex_cnt', scoredata.get_int_array('ex_cnt', 3)))
+            musicdata.add_child(Node.s32_array('score', scoredata.get_int_array('points', 3)))
+            musicdata.add_child(Node.s8_array('clear', scoredata.get_int_array('clear_flags', 3)))
+
+            for i, ghost in enumerate(scoredata.get('ghost', [None, None, None])):
+                if ghost is None:
+                    continue
+
+                bar = Node.u8_array('bar', ghost)
+                musicdata.add_child(bar)
+                bar.set_attribute('seq', str(i))
+
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+
+        # Jubeat Clan appears to allow full event overrides per-player
+        data.add_child(self.__get_global_info())
+
+        player = Node.void('player')
+        data.add_child(player)
+
+        # Basic profile info
+        player.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+
+        # Miscelaneous crap
+        player.add_child(Node.s32('session_id', 1))
+        player.add_child(Node.u64('event_flag', profile.get_int('event_flag')))
+
+        # Player info and statistics
+        info = Node.void('info')
+        player.add_child(info)
+        info.add_child(Node.s32('tune_cnt', profile.get_int('tune_cnt')))
+        info.add_child(Node.s32('save_cnt', profile.get_int('save_cnt')))
+        info.add_child(Node.s32('saved_cnt', profile.get_int('saved_cnt')))
+        info.add_child(Node.s32('fc_cnt', profile.get_int('fc_cnt')))
+        info.add_child(Node.s32('ex_cnt', profile.get_int('ex_cnt')))
+        info.add_child(Node.s32('clear_cnt', profile.get_int('clear_cnt')))
+        info.add_child(Node.s32('match_cnt', profile.get_int('match_cnt')))
+        info.add_child(Node.s32('beat_cnt', profile.get_int('beat_cnt')))
+        info.add_child(Node.s32('mynews_cnt', profile.get_int('mynews_cnt')))
+        info.add_child(Node.s32('bonus_tune_points', profile.get_int('bonus_tune_points')))
+        info.add_child(Node.bool('is_bonus_tune_played', profile.get_bool('is_bonus_tune_played')))
+
+        # Looks to be set to true when there's an old profile, stops tutorial from
+        # happening on first load.
+        info.add_child(Node.bool('inherit', profile.get_bool('has_old_version')))
+
+        # Not saved, but loaded
+        info.add_child(Node.s32('mtg_entry_cnt', 123))
+        info.add_child(Node.s32('mtg_hold_cnt', 456))
+        info.add_child(Node.u8('mtg_result', 10))
+
+        # Last played data, for showing cursor and such
+        lastdict = profile.get_dict('last')
+        last = Node.void('last')
+        player.add_child(last)
+        last.add_child(Node.s64('play_time', lastdict.get_int('play_time')))
+        last.add_child(Node.string('shopname', lastdict.get_str('shopname')))
+        last.add_child(Node.string('areaname', lastdict.get_str('areaname')))
+        last.add_child(Node.s32('music_id', lastdict.get_int('music_id')))
+        last.add_child(Node.s8('seq_id', lastdict.get_int('seq_id')))
+        last.add_child(Node.s8('sort', lastdict.get_int('sort')))
+        last.add_child(Node.s8('category', lastdict.get_int('category')))
+        last.add_child(Node.s8('expert_option', lastdict.get_int('expert_option')))
+
+        settings = Node.void('settings')
+        last.add_child(settings)
+        settings.add_child(Node.s8('marker', lastdict.get_int('marker')))
+        settings.add_child(Node.s8('theme', lastdict.get_int('theme')))
+        settings.add_child(Node.s16('title', lastdict.get_int('title')))
+        settings.add_child(Node.s16('parts', lastdict.get_int('parts')))
+        settings.add_child(Node.s8('rank_sort', lastdict.get_int('rank_sort')))
+        settings.add_child(Node.s8('combo_disp', lastdict.get_int('combo_disp')))
+        settings.add_child(Node.s16_array('emblem', lastdict.get_int_array('emblem', 5)))
+        settings.add_child(Node.s8('matching', lastdict.get_int('matching')))
+        settings.add_child(Node.s8('hard', lastdict.get_int('hard')))
+        settings.add_child(Node.s8('hazard', lastdict.get_int('hazard')))
+
+        # Secret unlocks
+        item = Node.void('item')
+        player.add_child(item)
+        item.add_child(Node.s32_array('music_list', profile.get_int_array('music_list', 64, [-1] * 64)))
+        item.add_child(Node.s32_array('secret_list', profile.get_int_array('secret_list', 64, [-1] * 64)))
+        item.add_child(Node.s32_array('theme_list', profile.get_int_array('theme_list', 16, [-1] * 16)))
+        item.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list', 16, [-1] * 16)))
+        item.add_child(Node.s32_array('title_list', profile.get_int_array('title_list', 160, [-1] * 160)))
+        item.add_child(Node.s32_array('parts_list', profile.get_int_array('parts_list', 160, [-1] * 160)))
+        item.add_child(Node.s32_array('emblem_list', profile.get_int_array('emblem_list', 96, [-1] * 96)))
+        item.add_child(Node.s32_array('commu_list', profile.get_int_array('commu_list', 16, [-1] * 16)))
+
+        new = Node.void('new')
+        item.add_child(new)
+        new.add_child(Node.s32_array('secret_list', profile.get_int_array('secret_list_new', 64, [-1] * 64)))
+        new.add_child(Node.s32_array('theme_list', profile.get_int_array('theme_list_new', 16, [-1] * 16)))
+        new.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list_new', 16, [-1] * 16)))
+
+        # No rival support, yet.
+        rivallist = Node.void('rivallist')
+        player.add_child(rivallist)
+        rivallist.set_attribute('count', '0')
+
+        lab_edit_seq = Node.void('lab_edit_seq')
+        player.add_child(lab_edit_seq)
+        lab_edit_seq.set_attribute('count', '0')
+
+        # Full combo challenge
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'fc_challenge')
+        if entry is None:
+            entry = ValidatedDict()
+
+        # Figure out if we've played these songs
+        start_time, end_time = self.data.local.network.get_schedule_duration('daily')
+        today_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('today', -1), timelimit=start_time)
+        whim_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('whim', -1), timelimit=start_time)
+
+        fc_challenge = Node.void('fc_challenge')
+        player.add_child(fc_challenge)
+        today = Node.void('today')
+        fc_challenge.add_child(today)
+        today.add_child(Node.s32('music_id', entry.get_int('today', -1)))
+        today.add_child(Node.u8('state', 0x40 if len(today_attempts) > 0 else 0x0))
+        whim = Node.void('whim')
+        fc_challenge.add_child(whim)
+        whim.add_child(Node.s32('music_id', entry.get_int('whim', -1)))
+        whim.add_child(Node.u8('state', 0x40 if len(whim_attempts) > 0 else 0x0))
+
+        # No news, ever.
+        official_news = Node.void('official_news')
+        player.add_child(official_news)
+        news_list = Node.void('news_list')
+        official_news.add_child(news_list)
+
+        # Sane defaults for unknown/who cares nodes
+        history = Node.void('history')
+        player.add_child(history)
+        history.set_attribute('count', '0')
+
+        free_first_play = Node.void('free_first_play')
+        player.add_child(free_first_play)
+        free_first_play.add_child(Node.bool('is_available', False))
+
+        # Player status for events
+        event_info = Node.void('event_info')
+        player.add_child(event_info)
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        event_completion: Dict[int, bool] = {}
+        course_completion: Dict[int, ValidatedDict] = {}
+        for achievement in achievements:
+            if achievement.type == 'event':
+                event_completion[achievement.id] = achievement.data.get_bool('is_completed')
+            if achievement.type == 'course':
+                course_completion[achievement.id] = achievement.data
+
+        for eventid, eventdata in self.EVENTS.items():
+            # There are two significant bits here, bit 0 and bit 1, I think the first
+            # one is whether the event is started, second is if its finished?
+            event = Node.void('event')
+            event_info.add_child(event)
+            event.set_attribute('type', str(eventid))
+
+            state = 0x0
+            state |= self.EVENT_STATUS_OPEN if eventdata['enabled'] else 0
+            state |= self.EVENT_STATUS_COMPLETE if event_completion.get(eventid, False) else 0
+            event.add_child(Node.u8('state', state))
+
+        # JBox stuff
+        jbox = Node.void('jbox')
+        jboxdict = profile.get_dict('jbox')
+        player.add_child(jbox)
+        jbox.add_child(Node.s32('point', jboxdict.get_int('point')))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        normal = Node.void('normal')
+        emblem.add_child(normal)
+        premium = Node.void('premium')
+        emblem.add_child(premium)
+        normal.add_child(Node.s16('index', jboxdict.get_int('normal_index') + 1))
+        premium.add_child(Node.s16('index', jboxdict.get_int('premium_index') + 1))
+
+        # New Music stuff
+        new_music = Node.void('new_music')
+        player.add_child(new_music)
+
+        navi = Node.void('navi')
+        player.add_child(navi)
+        navi.add_child(Node.u64('flag', profile.get_int('navi_flag')))
+
+        # Gift list, maybe from other players?
+        gift_list = Node.void('gift_list')
+        player.add_child(gift_list)
+        # If we had gifts, they look like this:
+        #     <gift reason="??" kind="??">
+        #         <id __type="s32">??</id>
+        #     </gift>
+
+        # Birthday event?
+        born = Node.void('born')
+        player.add_child(born)
+        born.add_child(Node.s8('status', profile.get_int('born_status')))
+        born.add_child(Node.s16('year', profile.get_int('born_year')))
+
+        # More crap
+        question_list = Node.void('question_list')
+        player.add_child(question_list)
+
+        # Player Jubility
+        jubility = Node.void('jubility')
+        player.add_child(jubility)
+        jubility.set_attribute('param', str(profile.get_int('jubility')))
+        target_music_list = Node.void('target_music_list')
+        jubility.add_child(target_music_list)
+
+        # Calculate top 30 songs contributing to jubility.
+        jubeat_entries: List[ValidatedDict] = []
+        for achievement in achievements:
+            if achievement.type != 'jubility':
+                continue
+
+            # Figure out for each song, what's the highest value jubility and
+            # keep that.
+            bestentry = ValidatedDict()
+            for chart in [0, 1, 2]:
+                entry = achievement.data.get_dict(str(chart))
+                if entry.get_int("value") >= bestentry.get_int("value"):
+                    bestentry = copy.deepcopy(entry)
+                    bestentry.replace_int("songid", achievement.id)
+                    bestentry.replace_int("chart", chart)
+            jubeat_entries.append(bestentry)
+        jubeat_entries = sorted(jubeat_entries, key=lambda entry: entry.get_int("value"), reverse=True)
+
+        # Now, give the game the list.
+        for i, entry in enumerate(jubeat_entries):
+            # The game only reads the top 30 anyway, so skip extra network traffic.
+            if i >= 30:
+                break
+
+            target_music = Node.void("target_music")
+            target_music_list.add_child(target_music)
+            target_music.add_child(Node.s32("music_id", entry.get_int("songid")))
+            target_music.add_child(Node.s8("seq", entry.get_int("chart")))
+            target_music.add_child(Node.s32("score", entry.get_int("score")))
+            target_music.add_child(Node.s32("value", entry.get_int("value")))
+            target_music.add_child(Node.bool("is_hard_mode", entry.get_bool("hard_mode")))
+
+        # Team stuff
+        team = Node.void('team')
+        teamdict = profile.get_dict('team')
+        player.add_child(team)
+        team.set_attribute('id', str(teamdict.get_int('id')))
+        team.add_child(Node.s32("section", teamdict.get_int('section')))
+        team.add_child(Node.s32("street", teamdict.get_int('street')))
+        team.add_child(Node.s32("house_number_1", teamdict.get_int('house_1')))
+        team.add_child(Node.s32("house_number_2", teamdict.get_int('house_2')))
+
+        # Set up where the player moves to (random) after their first play
+        move = Node.void('move')
+        team.add_child(move)
+        # 1 - Redbelk, 2 - Cyantle, 3 - Greenesia, 4 - Plumpark
+        move.set_attribute('id', str(random.choice([1, 2, 3, 4])))
+        move.set_attribute("section", str(random.choice([1, 2, 3, 4, 5])))
+        move.set_attribute("street", str(random.choice([1, 2, 3, 4, 5, 6])))
+        move.set_attribute("house_number_1", str(random.choice(range(10, 100))))
+        move.set_attribute("house_number_2", str(random.choice(range(10, 100))))
+
+        # Union Battle
+        union_battle = Node.void('union_battle')
+        player.add_child(union_battle)
+        union_battle.set_attribute('id', "-1")
+        union_battle.add_child(Node.s32("power", 0))
+
+        # Some server node
+        server = Node.void('server')
+        player.add_child(server)
+
+        # Another unknown gift list?
+        eamuse_gift_list = Node.void('eamuse_gift_list')
+        player.add_child(eamuse_gift_list)
+
+        # Clan Course List Progress
+        clan_course_list = Node.void('clan_course_list')
+        player.add_child(clan_course_list)
+
+        # Each course that we have completed has one of the following nodes.
+        for course in self.__get_course_list():
+            status_dict = course_completion.get(course['id'], ValidatedDict())
+            status = 0
+            status |= self.COURSE_STATUS_SEEN if status_dict.get_bool('seen') else 0
+            status |= self.COURSE_STATUS_PLAYED if status_dict.get_bool('played') else 0
+            status |= self.COURSE_STATUS_CLEARED if status_dict.get_bool('cleared') else 0
+
+            clan_course = Node.void('clan_course')
+            clan_course_list.add_child(clan_course)
+            clan_course.set_attribute('id', str(course['id']))
+            clan_course.add_child(Node.s8('status', status))
+
+        category_list = Node.void('category_list')
+        player.add_child(category_list)
+
+        # Each category has one of the following nodes
+        for categoryid in range(1, 7):
+            category = Node.void('category')
+            category_list.add_child(category)
+            category.set_attribute('id', str(categoryid))
+            category.add_child(Node.bool('is_display', True))
+
+        # Drop list
+        drop_list = Node.void('drop_list')
+        player.add_child(drop_list)
+
+        dropachievements: Dict[int, Achievement] = {}
+        for achievement in achievements:
+            if achievement.type == 'drop':
+                dropachievements[achievement.id] = achievement
+
+        for dropid in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
+            if dropid in dropachievements:
+                dropdata = dropachievements[dropid].data
+            else:
+                dropdata = ValidatedDict()
+
+            drop = Node.void('drop')
+            drop_list.add_child(drop)
+            drop.set_attribute('id', str(dropid))
+            drop.add_child(Node.s32('exp', dropdata.get_int('exp', -1)))
+            drop.add_child(Node.s32('flag', dropdata.get_int('flag', 0)))
+
+            item_list = Node.void('item_list')
+            drop.add_child(item_list)
+
+            for itemid in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
+                item = Node.void('item')
+                item_list.add_child(item)
+                item.set_attribute('id', str(itemid))
+                item.add_child(Node.s32('num', dropdata.get_int('item_{}'.format(itemid))))
+
+        # Fill in category
+        fill_in_category = Node.void('fill_in_category')
+        player.add_child(fill_in_category)
+        fill_in_category.add_child(Node.s32_array('no_gray_flag_list', profile.get_int_array('no_gray_flag_list', 16, [-1] * 16)))
+        fill_in_category.add_child(Node.s32_array('all_yellow_flag_list', profile.get_int_array('all_yellow_flag_list', 16, [-1] * 16)))
+        fill_in_category.add_child(Node.s32_array('full_combo_flag_list', profile.get_int_array('full_combo_flag_list', 16, [-1] * 16)))
+        fill_in_category.add_child(Node.s32_array('excellent_flag_list', profile.get_int_array('excellent_flag_list', 16, [-1] * 16)))
+
+        # Daily Bonus
+        daily_bonus_list = Node.void('daily_bonus_list')
+        player.add_child(daily_bonus_list)
+
+        # Tickets
+        ticket_list = Node.void('ticket_list')
+        player.add_child(ticket_list)
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        data = request.child('data')
+
+        # Grab system information
+        sysinfo = data.child('info')
+
+        # Grab player information
+        player = data.child('player')
+
+        # Grab result information
+        result = data.child('result')
+
+        # Grab last information. Lots of this will be filled in while grabbing scores
+        last = newprofile.get_dict('last')
+        if sysinfo is not None:
+            last.replace_int('play_time', sysinfo.child_value('time_gameend'))
+            last.replace_str('shopname', sysinfo.child_value('shopname'))
+            last.replace_str('areaname', sysinfo.child_value('areaname'))
+
+        # Grab player info for echoing back
+        info = player.child('info')
+        if info is not None:
+            newprofile.replace_int('tune_cnt', info.child_value('tune_cnt'))
+            newprofile.replace_int('save_cnt', info.child_value('save_cnt'))
+            newprofile.replace_int('saved_cnt', info.child_value('saved_cnt'))
+            newprofile.replace_int('fc_cnt', info.child_value('fc_cnt'))
+            newprofile.replace_int('ex_cnt', info.child_value('ex_cnt'))
+            newprofile.replace_int('clear_cnt', info.child_value('clear_cnt'))
+            newprofile.replace_int('match_cnt', info.child_value('match_cnt'))
+            newprofile.replace_int('beat_cnt', info.child_value('beat_cnt'))
+            newprofile.replace_int('mynews_cnt', info.child_value('mynews_cnt'))
+
+            newprofile.replace_int('bonus_tune_points', info.child_value('bonus_tune_points'))
+            newprofile.replace_bool('is_bonus_tune_played', info.child_value('is_bonus_tune_played'))
+
+        # Grab last settings
+        lastnode = player.child('last')
+        if lastnode is not None:
+            last.replace_int('expert_option', lastnode.child_value('expert_option'))
+            last.replace_int('sort', lastnode.child_value('sort'))
+            last.replace_int('category', lastnode.child_value('category'))
+
+            settings = lastnode.child('settings')
+            if settings is not None:
+                last.replace_int('matching', settings.child_value('matching'))
+                last.replace_int('hazard', settings.child_value('hazard'))
+                last.replace_int('hard', settings.child_value('hard'))
+                last.replace_int('marker', settings.child_value('marker'))
+                last.replace_int('theme', settings.child_value('theme'))
+                last.replace_int('title', settings.child_value('title'))
+                last.replace_int('parts', settings.child_value('parts'))
+                last.replace_int('rank_sort', settings.child_value('rank_sort'))
+                last.replace_int('combo_disp', settings.child_value('combo_disp'))
+                last.replace_int_array('emblem', 5, settings.child_value('emblem'))
+
+        # Grab unlock progress
+        item = player.child('item')
+        if item is not None:
+            newprofile.replace_int_array('music_list', 64, item.child_value('music_list'))
+            newprofile.replace_int_array('secret_list', 64, item.child_value('secret_list'))
+            newprofile.replace_int_array('theme_list', 16, item.child_value('theme_list'))
+            newprofile.replace_int_array('marker_list', 16, item.child_value('marker_list'))
+            newprofile.replace_int_array('title_list', 160, item.child_value('title_list'))
+            newprofile.replace_int_array('parts_list', 160, item.child_value('parts_list'))
+            newprofile.replace_int_array('emblem_list', 96, item.child_value('emblem_list'))
+            newprofile.replace_int_array('commu_list', 96, item.child_value('commu_list'))
+
+            newitem = item.child('new')
+            if newitem is not None:
+                newprofile.replace_int_array('secret_list_new', 64, newitem.child_value('secret_list'))
+                newprofile.replace_int_array('theme_list_new', 16, newitem.child_value('theme_list'))
+                newprofile.replace_int_array('marker_list_new', 16, newitem.child_value('marker_list'))
+
+        # Grab categories stuff
+        fill_in_category = player.child('fill_in_category')
+        if fill_in_category is not None:
+            newprofile.replace_int_array('no_gray_flag_list', 16, fill_in_category.child_value('no_gray_flag_list'))
+            newprofile.replace_int_array('all_yellow_flag_list', 16, fill_in_category.child_value('all_yellow_flag_list'))
+            newprofile.replace_int_array('full_combo_flag_list', 16, fill_in_category.child_value('full_combo_flag_list'))
+            newprofile.replace_int_array('excellent_flag_list', 16, fill_in_category.child_value('excellent_flag_list'))
+
+        # jbox stuff
+        jbox = player.child('jbox')
+        jboxdict = newprofile.get_dict('jbox')
+        if jbox is not None:
+            jboxdict.replace_int('point', jbox.child_value('point'))
+            emblemtype = jbox.child_value('emblem/type')
+            index = jbox.child_value('emblem/index')
+            if emblemtype == self.JBOX_EMBLEM_NORMAL:
+                jboxdict.replace_int('normal_index', index)
+            elif emblemtype == self.JBOX_EMBLEM_PREMIUM:
+                jboxdict.replace_int('premium_index', index)
+        newprofile.replace_dict('jbox', jboxdict)
+
+        # Team stuff
+        team = player.child('team')
+        teamdict = newprofile.get_dict('team')
+        if team is not None:
+            teamdict.replace_int('id', int(team.attribute('id')))
+            teamdict.replace_int('section', team.child_value('section'))
+            teamdict.replace_int('street', team.child_value('street'))
+            teamdict.replace_int('house_1', team.child_value('house_number_1'))
+            teamdict.replace_int('house_2', team.child_value('house_number_2'))
+        newprofile.replace_dict('team', teamdict)
+
+        # Drop list
+        drop_list = player.child('drop_list')
+        if drop_list is not None:
+            for drop in drop_list.children:
+                try:
+                    dropid = int(drop.attribute('id'))
+                except TypeError:
+                    # Unrecognized drop
+                    continue
+                exp = drop.child_value('exp')
+                flag = drop.child_value('flag')
+                items: Dict[int, int] = {}
+
+                item_list = drop.child('item_list')
+                if item_list is not None:
+                    for item in item_list.children:
+                        try:
+                            itemid = int(item.attribute('id'))
+                        except TypeError:
+                            # Unrecognized item
+                            continue
+                        items[itemid] = item.child_value('num')
+
+                olddrop = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    dropid,
+                    'drop',
+                )
+
+                if olddrop is None:
+                    # Create a new event structure for this
+                    olddrop = ValidatedDict()
+
+                olddrop.replace_int('exp', exp)
+                olddrop.replace_int('flag', flag)
+                for itemid, num in items.items():
+                    olddrop.replace_int('item_{}'.format(itemid), num)
+
+                # Save it as an achievement
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    dropid,
+                    'drop',
+                    olddrop,
+                )
+
+        # event stuff
+        newprofile.replace_int('event_flag', player.child_value('event_flag'))
+        event_info = player.child('event_info')
+        if event_info is not None:
+            for child in event_info.children:
+                try:
+                    eventid = int(child.attribute('type'))
+                except TypeError:
+                    # Event is empty
+                    continue
+                is_completed = child.child_value('is_completed')
+
+                # Figure out if we should update the rating/scores or not
+                oldevent = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    'event',
+                )
+
+                if oldevent is None:
+                    # Create a new event structure for this
+                    oldevent = ValidatedDict()
+
+                oldevent.replace_bool('is_completed', is_completed)
+
+                # Save it as an achievement
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    'event',
+                    oldevent,
+                )
+
+        # Still don't know what this is for lol
+        newprofile.replace_int('navi_flag', player.child_value('navi/flag'))
+
+        # Grab scores and save those
+        if result is not None:
+            for tune in result.children:
+                if tune.name != 'tune':
+                    continue
+                result = tune.child('player')
+
+                # Fix mapping to song IDs for the song with seven billion charts
+                # due to the prefecture unlock event.
+                songid = tune.child_value('music')
+                if songid in self.FIVE_PLAYS_UNLOCK_EVENT_SONG_IDS:
+                    songid = 80000301
+
+                timestamp = tune.child_value('timestamp') / 1000
+                chart = int(result.child('score').attribute('seq'))
+                points = result.child_value('score')
+                flags = int(result.child('score').attribute('clear'))
+                combo = int(result.child('score').attribute('combo'))
+                ghost = result.child_value('mbar')
+
+                stats = {
+                    'perfect': result.child_value('nr_perfect'),
+                    'great': result.child_value('nr_great'),
+                    'good': result.child_value('nr_good'),
+                    'poor': result.child_value('nr_poor'),
+                    'miss': result.child_value('nr_miss'),
+                }
+
+                # Miscelaneous last data for echoing to profile get
+                last.replace_int('music_id', songid)
+                last.replace_int('seq_id', chart)
+
+                mapping = {
+                    self.GAME_FLAG_BIT_CLEARED: self.PLAY_MEDAL_CLEARED,
+                    self.GAME_FLAG_BIT_FULL_COMBO: self.PLAY_MEDAL_FULL_COMBO,
+                    self.GAME_FLAG_BIT_EXCELLENT: self.PLAY_MEDAL_EXCELLENT,
+                    self.GAME_FLAG_BIT_NEARLY_FULL_COMBO: self.PLAY_MEDAL_NEARLY_FULL_COMBO,
+                    self.GAME_FLAG_BIT_NEARLY_EXCELLENT: self.PLAY_MEDAL_NEARLY_EXCELLENT,
+                }
+
+                # Figure out the highest medal based on bits passed in
+                medal = self.PLAY_MEDAL_FAILED
+                for bit in mapping:
+                    if flags & bit > 0:
+                        medal = max(medal, mapping[bit])
+
+                self.update_score(userid, timestamp, songid, chart, points, medal, combo, ghost, stats)
+
+        # Born stuff
+        born = player.child('born')
+        if born is not None:
+            newprofile.replace_int('born_status', born.child_value('status'))
+            newprofile.replace_int('born_year', born.child_value('year'))
+
+        # Save jubility
+        jubility = player.child('jubility')
+        if jubility is not None:
+            newprofile.replace_int('jubility', int(jubility.attribute('param')))
+            target_music_list = jubility.child('target_music_list')
+            if target_music_list is not None:
+                for target_music in target_music_list.children:
+                    if target_music.name != "target_music":
+                        continue
+
+                    songid = target_music.child_value("music_id")
+                    chart = target_music.child_value("seq")
+                    score = target_music.child_value("score")
+                    value = target_music.child_value("value")
+                    hard_mode = target_music.child_value("is_hard_mode")
+
+                    # Update jubility value tracking
+                    oldjubility = self.data.local.user.get_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        songid,
+                        'jubility',
+                    )
+
+                    if oldjubility is None:
+                        # Create a new jubility structure for this
+                        oldjubility = ValidatedDict()
+
+                    # Grab the entry for this sequence
+                    entry = oldjubility.get_dict(str(chart))
+                    if value >= entry.get_int("value"):
+                        entry.replace_int('score', score)
+                        entry.replace_int('value', value)
+                        entry.replace_bool('hard_mode', hard_mode)
+                    oldjubility.replace_dict(str(chart), entry)
+
+                    # Save it as an achievement
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        songid,
+                        'jubility',
+                        oldjubility,
+                    )
+
+        # Clan course saving
+        clan_course_list = player.child('clan_course_list')
+        if clan_course_list is not None:
+            for course in clan_course_list.children:
+                if course.name != 'clan_course':
+                    continue
+
+                courseid = int(course.attribute('id'))
+                status = course.child_value('status')
+                is_seen = (status & self.COURSE_STATUS_SEEN) != 0
+                is_played = (status & self.COURSE_STATUS_PLAYED) != 0
+
+                # Update seen status and played status
+                oldcourse = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    courseid,
+                    'course',
+                )
+
+                if oldcourse is None:
+                    # Create a new course structure for this
+                    oldcourse = ValidatedDict()
+
+                oldcourse.replace_bool('seen', oldcourse.get_bool('seen') or is_seen)
+                oldcourse.replace_bool('played', oldcourse.get_bool('played') or is_played)
+
+                # Save it as an achievement
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    courseid,
+                    'course',
+                    oldcourse,
+                )
+
+        select_course = player.child('select_course')
+        if select_course is not None:
+            try:
+                courseid = int(select_course.attribute('id'))
+            except Exception:
+                courseid = 0
+            cleared = select_course.child_value('is_cleared')
+
+            if courseid > 0 and cleared:
+                # Update course cleared status
+                oldcourse = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    courseid,
+                    'course',
+                )
+
+                if oldcourse is None:
+                    # Create a new course structure for this
+                    oldcourse = ValidatedDict()
+
+                oldcourse.replace_bool('cleared', True)
+
+                # Save it as an achievement
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    courseid,
+                    'course',
+                    oldcourse,
+                )
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', last)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/jubeat/common.py b/bemani/backend/jubeat/common.py
new file mode 100644
index 0000000..a73fd3a
--- /dev/null
+++ b/bemani/backend/jubeat/common.py
@@ -0,0 +1,130 @@
+import time
+
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.protocol import Node
+
+
+class JubeatLoggerReportHandler(JubeatBase):
+
+    def handle_logger_report_request(self, request: Node) -> Node:
+        # Handle this by returning nothing, game doesn't care
+        root = Node.void('logger')
+        return root
+
+
+class JubeatDemodataGetNewsHandler(JubeatBase):
+
+    def handle_demodata_get_news_request(self, request: Node) -> Node:
+        demodata = Node.void('demodata')
+        data = Node.void('data')
+        demodata.add_child(data)
+
+        officialnews = Node.void('officialnews')
+        data.add_child(officialnews)
+        officialnews.set_attribute('count', '0')
+
+        return demodata
+
+
+class JubeatDemodataGetHitchartHandler(JubeatBase):
+
+    def handle_demodata_get_hitchart_request(self, request: Node) -> Node:
+        demodata = Node.void('demodata')
+        data = Node.void('data')
+        demodata.add_child(data)
+
+        # Not sure what this is, maybe date?
+        data.add_child(Node.string('update', time.strftime("%d/%m/%Y")))
+
+        # No idea which songs are licensed or regular, so only return hit chart
+        # for all songs on regular mode.
+        hitchart_lic = Node.void('hitchart_lic')
+        data.add_child(hitchart_lic)
+        hitchart_lic.set_attribute('count', '0')
+
+        songs = self.data.local.music.get_hit_chart(self.game, self.version, 10)
+        hitchart_org = Node.void('hitchart_org')
+        data.add_child(hitchart_org)
+        hitchart_org.set_attribute('count', str(len(songs)))
+        rank = 1
+        for song in songs:
+            rankdata = Node.void('rankdata')
+            hitchart_org.add_child(rankdata)
+            rankdata.add_child(Node.s32('music_id', song[0]))
+            rankdata.add_child(Node.s16('rank', rank))
+            rankdata.add_child(Node.s16('prev', rank))
+            rank = rank + 1
+
+        return demodata
+
+
+class JubeatLobbyCheckHandler(JubeatBase):
+
+    def handle_lobby_check_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        data = Node.void('data')
+        root.add_child(data)
+
+        data.add_child(Node.s16('interval', 0))
+        data.add_child(Node.s16('entry_timeout', 0))
+        entrant_nr = Node.u32('entrant_nr', 0)
+        entrant_nr.set_attribute('time', '0')
+        data.add_child(entrant_nr)
+
+        return root
+
+
+class JubeatGamendRegisterHandler(JubeatBase):
+
+    def handle_gameend_regist_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+
+        if player is not None:
+            refid = player.child_value('refid')
+        else:
+            refid = None
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid)
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+        else:
+            newprofile = None
+
+        if userid is not None and newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+        gameend = Node.void('gameend')
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('session_id', 1))
+        player.add_child(Node.s32('end_final_session_id', 1))
+        return gameend
+
+
+class JubeatGametopGetMeetingHandler(JubeatBase):
+
+    def handle_gametop_get_meeting_request(self, request: Node) -> Node:
+        gametop = Node.void('gametop')
+        data = Node.void('data')
+        gametop.add_child(data)
+        meeting = Node.void('meeting')
+        data.add_child(meeting)
+        single = Node.void('single')
+        meeting.add_child(single)
+        single.set_attribute('count', '0')
+        tag = Node.void('tag')
+        meeting.add_child(tag)
+        tag.set_attribute('count', '0')
+        reward = Node.void('reward')
+        data.add_child(reward)
+        reward.add_child(Node.s32('total', -1))
+        reward.add_child(Node.s32('point', -1))
+        return gametop
diff --git a/bemani/backend/jubeat/course.py b/bemani/backend/jubeat/course.py
new file mode 100644
index 0000000..23111b7
--- /dev/null
+++ b/bemani/backend/jubeat/course.py
@@ -0,0 +1,541 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, List
+
+from bemani.data import UserID
+from bemani.backend.jubeat.base import JubeatBase
+
+
+class JubeatCourse(JubeatBase):
+
+    COURSE_RATING_FAILED = 100
+    COURSE_RATING_BRONZE = 200
+    COURSE_RATING_SILVER = 300
+    COURSE_RATING_GOLD = 400
+
+    COURSE_REQUIREMENT_SCORE = 100
+    COURSE_REQUIREMENT_FULL_COMBO = 200
+    COURSE_REQUIREMENT_PERFECT_PERCENT = 300
+
+    def get_all_courses(self) -> List[Dict[str, Any]]:
+        # List of base courses for Saucer Fulfill+ from BemaniWiki
+        return [
+            {
+                'id': 1,
+                'name': '溢れ出した記憶、特別なあなたにありがとう。',
+                'level': 1,
+                'music': [
+                    (50000241, 2),
+                    (10000052, 2),
+                    (30000042, 2),
+                    (50000085, 2),
+                    (50000144, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [850000, 900000, 950000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [0, 1, 2],
+                },
+            },
+            {
+                'id': 2,
+                'name': 'コースモードが怖い？ばっかお前TAGがついてるだろ',
+                'level': 1,
+                'music': [
+                    (50000121, 1),
+                    (30000122, 1),
+                    (40000159, 1),
+                    (50000089, 1),
+                    (40000051, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [800000, 850000, 900000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [0, 1, 2],
+                },
+            },
+            {
+                'id': 3,
+                'name': '満月の鐘踊り響くは虚空から成る恋の歌',
+                'level': 2,
+                'music': [
+                    (40000121, 2),
+                    (50000188, 2),
+                    (30000047, 2),
+                    (50000237, 2),
+                    (50000176, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [850000, 900000, 950000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [1, 2, 3],
+                },
+            },
+            {
+                'id': 4,
+                'name': 'スミスゼミナール 夏の陣開講記念 基本編',
+                'level': 2,
+                'music': [
+                    (50000267, 1),
+                    (50000233, 1),
+                    (50000228, 1),
+                    (50000268, 1),
+                    (50000291, 1),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [1, 2, 3],
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [85, 90, 95],
+                },
+            },
+            {
+                'id': 5,
+                'name': 'HARDモードじゃないから、絶対、大丈夫だよっ！',
+                'level': 2,
+                'music': [
+                    (50000144, 2),
+                    (50000188, 2),
+                    (50000070, 2),
+                    (50000151, 2),
+                    (50000152, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [850000, 900000, 950000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [0, 1, 2],
+                },
+            },
+            {
+                'id': 6,
+                'name': '星明かりの下、愛という名の日替わりランチを君と',
+                'level': 3,
+                'music': [
+                    (50000196, 1),
+                    (50000151, 2),
+                    (50000060, 1),
+                    (40000048, 2),
+                    (10000051, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [70, 80, 90],
+                },
+            },
+            {
+                'id': 7,
+                'name': '輝く北極星と幸せなヒーロー',
+                'level': 4,
+                'music': [
+                    (50000079, 2),
+                    (20000044, 2),
+                    (50000109, 2),
+                    (10000043, 2),
+                    (10000042, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [1, 2, 3],
+                },
+            },
+            {
+                'id': 8,
+                'name': '花-鳥-藻-夏',
+                'level': 4,
+                'music': [
+                    (10000068, 2),
+                    (40000154, 2),
+                    (50000123, 1),
+                    (40000051, 2),
+                    (30000045, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [70, 80, 90],
+                },
+            },
+            {
+                'id': 9,
+                'name': 'TAG生誕祭2014 俺の記録を抜いてみろ！',
+                'level': 4,
+                'music': [
+                    (30000122, 2),
+                    (50000086, 2),
+                    (50000121, 2),
+                    (50000196, 2),
+                    (40000051, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 967252],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [0, 0, 1],
+                },
+            },
+            {
+                'id': 10,
+                'name': 'さよなら、亡くした恋と蝶の舞うヒストリア',
+                'level': 5,
+                'music': [
+                    (20000041, 2),
+                    (30000044, 2),
+                    (50000037, 2),
+                    (20000124, 2),
+                    (50000033, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [80, 85, 90],
+                },
+            },
+            {
+                'id': 11,
+                'name': 'きらきらほしふるまぼろしなぎさちゃん',
+                'level': 5,
+                'music': [
+                    (30000050, 2),
+                    (30000049, 2),
+                    (50000235, 2),
+                    (50000157, 2),
+                    (50000038, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [700000, 800000, 900000],
+                },
+            },
+            {
+                'id': 12,
+                'name': 'The Memorial Third: 僕みたいに演奏してね',
+                'level': 5,
+                'music': [
+                    (10000037, 2),
+                    (20000048, 1),
+                    (50000253, 1),
+                    (20000121, 2),
+                    (50000133, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [75, 80, 85],
+                },
+            },
+            {
+                'id': 13,
+                'name': 'Enjoy! 4thKAC ~ Memories of saucer ~',
+                'level': 5,
+                'music': [
+                    (50000206, 1),
+                    (50000023, 1),
+                    (50000078, 1),
+                    (50000203, 1),
+                    (50000323, 1),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [1, 2, 4],
+                },
+            },
+            {
+                'id': 14,
+                'name': '風に吹かれるキケンなシロクマダンス',
+                'level': 6,
+                'music': [
+                    (50000059, 2),
+                    (50000197, 2),
+                    (30000037, 2),
+                    (50000182, 2),
+                    (20000038, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [1, 2, 3],
+                },
+            },
+            {
+                'id': 15,
+                'name': '君主は視線で友との愛を語るめう',
+                'level': 6,
+                'music': [
+                    (40000052, 2),
+                    (50000152, 2),
+                    (50000090, 2),
+                    (20000040, 2),
+                    (50000184, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [85, 90, 95],
+                },
+            },
+            {
+                'id': 16,
+                'name': 'スミスゼミナール 夏の陣開講記念 応用編',
+                'level': 6,
+                'music': [
+                    (50000233, 2),
+                    (50000267, 2),
+                    (50000268, 2),
+                    (50000228, 2),
+                    (50000291, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [750000, 850000, 900000],
+                },
+            },
+            {
+                'id': 17,
+                'name': '天から降り注ぐ星はまるで甘いキャンディ',
+                'level': 7,
+                'music': [
+                    (20000044, 2),
+                    (30000050, 2),
+                    (50000080, 2),
+                    (40000126, 2),
+                    (10000067, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [85, 90, 95],
+                },
+            },
+            {
+                'id': 18,
+                'name': 'てんとう虫が囁いている「Wow Wow…」',
+                'level': 7,
+                'music': [
+                    (50000132, 2),
+                    (40000128, 2),
+                    (10000036, 2),
+                    (50000119, 2),
+                    (50000030, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [85, 90, 95],
+                },
+            },
+            {
+                'id': 19,
+                'name': 'HARDモードでも大丈夫だよ！絶対、大丈夫だよっ！',
+                'level': 7,
+                'music': [
+                    (50000144, 2),
+                    (50000070, 2),
+                    (50000188, 2),
+                    (50000151, 2),
+                    (50000152, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [850000, 900000, 950000],
+                },
+            },
+            {
+                'id': 20,
+                'name': 'こんなHARDモード、滅べばいい…',
+                'level': 7,
+                'music': [
+                    (50000294, 2),
+                    (50000295, 2),
+                    (50000234, 2),
+                    (50000245, 2),
+                    (50000282, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [850000, 900000, 950000],
+                },
+            },
+            {
+                'id': 21,
+                'name': 'Challenge! 4thKAC ~ Memories of saucer ~',
+                'level': 7,
+                'music': [
+                    (50000206, 2),
+                    (50000023, 2),
+                    (50000078, 2),
+                    (50000203, 2),
+                    (50000323, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                },
+            },
+            {
+                'id': 22,
+                'name': 'サヨナラ・キングコング ~ 恋のつぼみは愛の虹へ ~',
+                'level': 8,
+                'music': [
+                    (50000148, 2),
+                    (50000101, 2),
+                    (10000064, 2),
+                    (50000171, 2),
+                    (50000070, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                },
+            },
+            {
+                'id': 23,
+                'name': '風に舞う白鳥の翼と花弁、さながら万華鏡のよう',
+                'level': 8,
+                'music': [
+                    (30000036, 2),
+                    (50000122, 2),
+                    (10000062, 2),
+                    (50000199, 2),
+                    (40000153, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [90, 95, 98],
+                },
+            },
+            {
+                'id': 24,
+                'name': 'The 小さなおぼろガチョウ♪',
+                'level': 8,
+                'music': [
+                    (50000049, 2),
+                    (50000071, 2),
+                    (10000041, 2),
+                    (50000031, 2),
+                    (40000129, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [970000, 980000, 990000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [2, 3, 4],
+                },
+            },
+            {
+                'id': 25,
+                'name': 'TAG生誕祭2014 俺の記録を抜いてみろ！~ HARD編 ~',
+                'level': 8,
+                'music': [
+                    (50000089, 2),
+                    (50000083, 2),
+                    (50000210, 2),
+                    (50000030, 2),
+                    (40000159, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [800000, 900000, 931463],
+                },
+            },
+            {
+                'id': 26,
+                'name': '凍る世界で見る鳳凰の火の花',
+                'level': 9,
+                'music': [
+                    (30000043, 2),
+                    (10000039, 2),
+                    (20000048, 2),
+                    (50000096, 2),
+                    (20000038, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [920000, 950000, 980000],
+                },
+            },
+            {
+                'id': 27,
+                'name': '真実の桜が乱れしとき、キルト纏いし君は修羅となる',
+                'level': 9,
+                'music': [
+                    (50000113, 2),
+                    (50000184, 2),
+                    (50000177, 2),
+                    (30000124, 2),
+                    (50000078, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: [80, 85, 90],
+                },
+            },
+            {
+                'id': 28,
+                'name': 'THE FINAL01 ~ 雷光に月、乙女に花散る祝福を ~',
+                'level': 10,
+                'music': [
+                    (10000038, 2),
+                    (20000051, 2),
+                    (30000048, 2),
+                    (40000060, 2),
+                    (50000023, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [920000, 950000, 980000],
+                },
+            },
+            {
+                'id': 29,
+                'name': 'The Memorial Third: assimilated all into Nature',
+                'level': 10,
+                'music': [
+                    (50000135, 2),
+                    (50000029, 2),
+                    (40000047, 2),
+                    (40000046, 2),
+                    (50000253, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [920000, 950000, 980000],
+                },
+            },
+            {
+                'id': 30,
+                'name': '4thKAC ~ Memories of saucer ~',
+                'level': 10,
+                'music': [
+                    (50000206, 2),
+                    (50000023, 2),
+                    (50000078, 2),
+                    (50000203, 2),
+                    (50000323, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [920000, 950000, 980000],
+                },
+            },
+        ]
+
+    def save_course(
+        self,
+        userid: UserID,
+        courseid: int,
+        rating: int,
+        scores: List[int],
+    ) -> None:
+        if len(scores) != 5:
+            raise Exception('Invalid course scores list!')
+        if rating not in [
+            self.COURSE_RATING_FAILED,
+            self.COURSE_RATING_BRONZE,
+            self.COURSE_RATING_SILVER,
+            self.COURSE_RATING_GOLD,
+        ]:
+            raise Exception('Invalid course rating!')
+
+        # Figure out if we should update the rating/scores or not
+        oldcourse = self.data.local.game.get_achievement(
+            self.game,
+            userid,
+            courseid,
+            'course',
+        )
+
+        if oldcourse is not None:
+            # Update the rating if the user did better
+            rating = max(rating, oldcourse.get_int('rating'))
+
+            # Update the scores if the total score was better
+            if sum(scores) < sum(oldcourse.get_int_array('scores', 5)):
+                scores = oldcourse.get_int_array('scores', 5)
+
+        # Save it as an achievement
+        self.data.local.game.put_achievement(
+            self.game,
+            userid,
+            courseid,
+            'course',
+            {
+                'rating': rating,
+                'scores': scores,
+            },
+        )
+
+    def get_courses(
+        self,
+        userid: UserID,
+    ) -> Dict[int, Dict[str, Any]]:
+        courses = {}
+        achievements = self.data.local.game.get_achievements(self.game, userid)
+        for achievement in achievements:
+            if achievement.type == 'course':
+                courses[achievement.id] = {
+                    'rating': achievement.data.get_int('rating'),
+                    'scores': achievement.data.get_int_array('scores', 5),
+                }
+        return courses
diff --git a/bemani/backend/jubeat/factory.py b/bemani/backend/jubeat/factory.py
new file mode 100644
index 0000000..46a2d55
--- /dev/null
+++ b/bemani/backend/jubeat/factory.py
@@ -0,0 +1,80 @@
+from typing import Dict, Optional, Any
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.jubeat.stubs import (
+    Jubeat,
+    JubeatRipples,
+    JubeatRipplesAppend,
+    JubeatKnit,
+    JubeatKnitAppend,
+    JubeatCopious,
+    JubeatCopiousAppend,
+)
+from bemani.backend.jubeat.saucer import JubeatSaucer
+from bemani.backend.jubeat.saucerfulfill import JubeatSaucerFulfill
+from bemani.backend.jubeat.prop import JubeatProp
+from bemani.backend.jubeat.qubell import JubeatQubell
+from bemani.backend.jubeat.clan import JubeatClan
+from bemani.backend.jubeat.festo import JubeatFesto
+from bemani.common import Model
+from bemani.data import Data
+
+
+class JubeatFactory(Factory):
+
+    MANAGED_CLASSES = [
+        Jubeat,
+        JubeatRipples,
+        JubeatRipplesAppend,
+        JubeatKnit,
+        JubeatKnitAppend,
+        JubeatCopious,
+        JubeatCopiousAppend,
+        JubeatSaucer,
+        JubeatSaucerFulfill,
+        JubeatProp,
+        JubeatQubell,
+        JubeatClan,
+        JubeatFesto,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['H44', 'I44', 'J44', 'K44', 'L44']:
+            Base.register(game, JubeatFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+        if model.game == 'H44':
+            return Jubeat(data, config, model)
+        if model.game == 'I44':
+            if model.version >= 2010031800:
+                return JubeatRipplesAppend(data, config, model)
+            else:
+                return JubeatRipples(data, config, model)
+        if model.game == 'J44':
+            if model.version >= 2011032300:
+                return JubeatKnitAppend(data, config, model)
+            else:
+                return JubeatKnit(data, config, model)
+        if model.game == 'K44':
+            if model.version >= 2012031400:
+                return JubeatCopiousAppend(data, config, model)
+            else:
+                return JubeatCopious(data, config, model)
+        if model.game == 'L44':
+            if model.version <= 2014022400:
+                return JubeatSaucer(data, config, model)
+            if model.version >= 2014030300 and model.version < 2015022000:
+                return JubeatSaucerFulfill(data, config, model)
+            if model.version >= 2015022000 and model.version < 2016033000:
+                return JubeatProp(data, config, model)
+            if model.version >= 2016033000 and model.version < 2017062600:
+                return JubeatQubell(data, config, model)
+            if model.version >= 2017062600 and model.version < 2018090500:
+                return JubeatClan(data, config, model)
+            if model.version >= 2018090500:
+                return JubeatFesto(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/jubeat/festo.py b/bemani/backend/jubeat/festo.py
new file mode 100644
index 0000000..8ca85f4
--- /dev/null
+++ b/bemani/backend/jubeat/festo.py
@@ -0,0 +1,16 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.backend.jubeat.clan import JubeatClan
+
+from bemani.common import VersionConstants
+
+
+class JubeatFesto(JubeatBase):
+
+    name = 'Jubeat Festo'
+    version = VersionConstants.JUBEAT_FESTO
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatClan(self.data, self.config, self.model)
diff --git a/bemani/backend/jubeat/prop.py b/bemani/backend/jubeat/prop.py
new file mode 100644
index 0000000..91e5cac
--- /dev/null
+++ b/bemani/backend/jubeat/prop.py
@@ -0,0 +1,1354 @@
+# vim: set fileencoding=utf-8
+import copy
+import math
+import random
+from typing import Optional, Dict, List, Any, Tuple
+
+from bemani.backend.base import Status
+from bemani.backend.jubeat.common import (
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+)
+from bemani.backend.jubeat.course import JubeatCourse
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.backend.jubeat.saucerfulfill import JubeatSaucerFulfill
+from bemani.common import ValidatedDict, VersionConstants, Time
+from bemani.data import Data, Score, UserID
+from bemani.protocol import Node
+
+
+class JubeatProp(
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+    JubeatCourse,
+    JubeatBase,
+):
+
+    name = 'Jubeat Prop'
+    version = VersionConstants.JUBEAT_PROP
+
+    GAME_COURSE_REQUIREMENT_SCORE = 1
+    GAME_COURSE_REQUIREMENT_FULL_COMBO = 2
+    GAME_COURSE_REQUIREMENT_PERFECT_PERCENT = 3
+
+    GAME_COURSE_RATING_FAILED = 1
+    GAME_COURSE_RATING_BRONZE = 2
+    GAME_COURSE_RATING_SILVER = 3
+    GAME_COURSE_RATING_GOLD = 4
+
+    JBOX_EMBLEM_NORMAL = 1
+    JBOX_EMBLEM_PREMIUM = 2
+
+    EVENTS = {
+        5: {
+            'enabled': False,
+        },
+        6: {
+            'enabled': False,
+        },
+        9: {
+            'enabled': False,
+        },
+        14: {
+            'enabled': False,
+        },
+        15: {
+            'enabled': False,
+        },
+        16: {
+            'enabled': False,
+        },
+        17: {
+            'enabled': False,
+        },
+        18: {
+            'enabled': False,
+        },
+        19: {
+            'enabled': False,
+        },
+    }
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatSaucerFulfill(self.data, self.config, self.model)
+
+    @classmethod
+    def __class_to_rank(cls, cur_class: int, cur_subclass: int) -> int:
+        """
+        Given a class and subclass, return an integer rank for that class.
+
+        Class mapping is as follows:
+            1 - Amateur
+            2 - Regular
+            3 - Master
+            4 - Legend
+
+        Subclass ranges from 1 to 5, except on Legend where it is 1 only.
+        """
+        if cur_subclass > 5:
+            cur_subclass = 5
+        if cur_subclass < 1:
+            cur_subclass = 1
+        if cur_class > 4:
+            cur_class = 4
+        if cur_class < 1:
+            cur_class = 1
+
+        lut = {
+            1: {
+                5: 0,
+                4: 1,
+                3: 2,
+                2: 3,
+                1: 4,
+            },
+            2: {
+                5: 5,
+                4: 6,
+                3: 7,
+                2: 8,
+                1: 9,
+            },
+            3: {
+                5: 10,
+                4: 11,
+                3: 12,
+                2: 13,
+                1: 14,
+            },
+            # Legend only has one sub-class value (1), so to make range checks
+            # easier, just map all 5 possible values to the same integer.
+            4: {
+                5: 15,
+                4: 15,
+                3: 15,
+                2: 15,
+                1: 15,
+            },
+        }
+        return lut[cur_class][cur_subclass]
+
+    @classmethod
+    def __rank_to_class(cls, rank: int) -> Tuple[int, int]:
+        """
+        Given a rank, return a tuple representing class, subclass. This function
+        is the inverse of __class_to_rank.
+        """
+        if rank < 0:
+            rank = 0
+        if rank > 15:
+            rank = 15
+
+        lut = {
+            0: (1, 5),
+            1: (1, 4),
+            2: (1, 3),
+            3: (1, 2),
+            4: (1, 1),
+            5: (2, 5),
+            6: (2, 4),
+            7: (2, 3),
+            8: (2, 2),
+            9: (2, 1),
+            10: (3, 5),
+            11: (3, 4),
+            12: (3, 3),
+            13: (3, 2),
+            14: (3, 1),
+            15: (4, 1),
+        }
+        return lut[rank]
+
+    @classmethod
+    def __increment_class(cls, cur_class: int, cur_subclass: int) -> Tuple[int, int]:
+        """
+        Given a class and subclass, return a tuple representing the next
+        class/subclass if we were to be promoted.
+        """
+        return cls.__rank_to_class(cls.__class_to_rank(cur_class, cur_subclass) + 1)
+
+    @classmethod
+    def __decrement_class(cls, cur_class: int, cur_subclass: int) -> Tuple[int, int]:
+        """
+        Given a class and subclass, return a tuple representing the previous
+        class/subclass if we were to be demoted.
+        """
+        return cls.__rank_to_class(cls.__class_to_rank(cur_class, cur_subclass) - 1)
+
+    @classmethod
+    def __get_league_buckets(cls, scores: List[Tuple[UserID, int]]) -> Tuple[List[UserID], List[UserID], List[UserID]]:
+        """
+        Given a list of userid, score tuples, return a tuple containing three lists.
+        The first list is the top 30% scorer IDs, the next list is the middle 40%
+        scorer IDs, and the final list is the bottom 30% scorer IDs.
+        """
+        sorted_scores = sorted(scores, key=lambda x: x[1], reverse=True)
+
+        # Top 30% get promoted
+        promoted_amount = math.ceil(len(sorted_scores) * 0.3)
+        promotions = [x[0] for x in sorted_scores[:promoted_amount]]
+        rest = sorted_scores[promoted_amount:]
+
+        # Bottom 30% get demoted (this is bottom 3/7 of the rest)
+        demoted_amount = math.ceil(len(rest) * 0.42)
+        demotions = [x[0] for x in rest[-demoted_amount:]]
+        neutrals = [x[0] for x in rest[:-demoted_amount]]
+
+        return (promotions, neutrals, demotions)
+
+    @classmethod
+    def __get_league_scores(cls, data: Data, current_id: int, profiles: List[Tuple[UserID, ValidatedDict]]) -> Tuple[List[Tuple[UserID, int]], List[UserID]]:
+        """
+        Given the current League ID (calculated based on the date range) and a list of
+        all user profiles for this game/version, return a uple containing two lists.
+        The first list should contain tuples where the first integer is a user ID and
+        the second integer is the user's total score for last week's course. The second
+        list is a list of user IDs that did not participate last week but have played
+        this game at some point.
+        """
+        last_id = current_id - 1
+
+        scores = []
+        absentees = []
+        for [userid, player] in profiles:
+            # Look up scores for last week if they played
+            league_score = data.local.user.get_achievement(
+                cls.game,
+                cls.version,
+                userid,
+                last_id,
+                'league',
+            )
+
+            # If they played, grab their total score so we can figure out if we should
+            # promote, demote or leave alone
+            if league_score is not None:
+                scores.append((
+                    userid,
+                    league_score['score'][0] +
+                    league_score['score'][1] +
+                    league_score['score'][2],
+                ))
+            else:
+                absentees.append(userid)
+
+        return scores, absentees
+
+    @classmethod
+    def __get_league_absentees(cls, data: Data, current_id: int, absentees: List[UserID]) -> List[UserID]:
+        """
+        Given a list of user IDs that didn't play for some number of weeks, return
+        a subset of those IDs that have been absent enough weeks to get a demotion.
+        Demotions happen for every two weeks without play.
+        """
+        delinquents = []
+        for userid in absentees:
+            # Figure out the last time they played, if its an even boundary
+            # and at least 2 weeks back, demote them (one demotion for every
+            # two weeks not played).
+            last_league_id = 0
+            for achievement in data.local.user.get_achievements(
+                cls.game,
+                cls.version,
+                userid,
+            ):
+                if achievement.type == 'league':
+                    last_league_id = max(achievement.id, last_league_id)
+
+            if last_league_id != 0:
+                # If they played mid-week two IDs ago, that's not quite
+                # two weeks back, so adjust by one.
+                weeks_different = (current_id - last_league_id) - 1
+
+                if weeks_different >= 2 and weeks_different % 2 == 0:
+                    # It's been at least two weeks (or four, or six), which means
+                    # there have been two weeks since the last time we did this,
+                    # demote this person.
+                    delinquents.append(userid)
+
+        return delinquents
+
+    @classmethod
+    def __modify_profile(cls, data: Data, userid: UserID, direction: str) -> None:
+        """
+        Given a user ID and a direction (promote or demote), load the user's profile,
+        make the necessary promotion/demotion, and set the profile to notify the user
+        on next play that they have lost/gained rank. If the user still hasn't checked
+        their rank since last time we changed it, make sure they know about multiple
+        promotions/demotions.
+        """
+        profile = data.local.user.get_profile(cls.game, cls.version, userid)
+        cur_class = profile.get_int('league_class', 1)
+        cur_subclass = profile.get_int('league_subclass', 5)
+
+        if direction == 'promote':
+            new_class, new_subclass = cls.__increment_class(cur_class, cur_subclass)
+        elif direction == 'demote':
+            new_class, new_subclass = cls.__decrement_class(cur_class, cur_subclass)
+        else:
+            raise Exception('Logic error, unknown direction {}!'.format(direction))
+
+        if new_class != cur_class or new_subclass != cur_subclass:
+            # If they've checked last time, set up the new old class.
+            if profile.get_bool('league_is_checked'):
+                last = profile.get_dict('last')
+                last.replace_int('league_class', cur_class)
+                last.replace_int('league_subclass', cur_subclass)
+                profile.replace_dict('last', last)
+            # We actually changed a level, let the user know!
+            profile.replace_int('league_class', new_class)
+            profile.replace_int('league_subclass', new_subclass)
+            profile.replace_bool('league_is_checked', False)
+            data.local.user.put_profile(cls.game, cls.version, userid, profile)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Once a week, insert a new league course. Every day, insert new FC challenge courses.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'league_course', 'weekly'):
+            # Generate a new league course list, save it to the DB.
+            start_time, end_time = data.local.network.get_schedule_duration('weekly')
+            all_songs = set(song.id for song in data.local.music.get_all_songs(cls.game, cls.version))
+            league_songs = random.sample(all_songs, 3)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'league',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': league_songs,
+                },
+            )
+            events.append((
+                'jubeat_league_course',
+                {
+                    'version': cls.version,
+                    'songs': league_songs,
+                },
+            ))
+
+            # League ID for the current league we just added.
+            leagueid = int(start_time / 604800)
+
+            # Evaluate player scores on previous courses and find players
+            # that didn't play last week.
+            all_profiles = data.local.user.get_all_profiles(cls.game, cls.version)
+            scores, absentees = cls.__get_league_scores(data, leagueid, all_profiles)
+
+            # Get user IDs to promote, demote and ignore based on scores.
+            promote, ignore, demote = cls.__get_league_buckets(scores)
+            demote.extend(cls.__get_league_absentees(data, leagueid, absentees))
+
+            # Actually modify the profiles so the game knows to tell the user.
+            for userid in promote:
+                cls.__modify_profile(data, userid, 'promote')
+            for userid in demote:
+                cls.__modify_profile(data, userid, 'demote')
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'league_course', 'weekly')
+
+        if data.local.network.should_schedule(cls.game, cls.version, 'fc_challenge', 'daily'):
+            # Generate a new list of two FC challenge songs.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = set(song.id for song in data.local.music.get_all_songs(cls.game, cls.version))
+            daily_songs = random.sample(all_songs, 2)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'fc_challenge',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            )
+            events.append((
+                'jubeat_fc_challenge_charts',
+                {
+                    'version': cls.version,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'fc_challenge', 'daily')
+
+        return events
+
+    def __get_global_info(self) -> Node:
+        info = Node.void('info')
+
+        # Event info. Valid event IDs are 5, 6, 9, 14, 15, 16, 17, 18, 19
+        event_info = Node.void('event_info')
+        info.add_child(event_info)
+        for event in self.EVENTS:
+            evt = Node.void('event')
+            event_info.add_child(evt)
+            evt.set_attribute('type', str(event))
+            evt.add_child(Node.u8('state', 0x1 if self.EVENTS[event]['enabled'] else 0x0))
+
+        # Each of the following three sections should have zero or more child nodes (no
+        # particular name) which look like the following:
+        #     <node>
+        #         <id __type="s32">songid</id>
+        #         <stime __type="str">start time?</stime>
+        #         <etime __type="str">end time?</etime>
+        #     </node>
+        # Share music?
+        share_music = Node.void('share_music')
+        info.add_child(share_music)
+
+        # Bonus music?
+        bonus_music = Node.void('bonus_music')
+        info.add_child(bonus_music)
+
+        # Only now music?
+        only_now_music = Node.void('only_now_music')
+        info.add_child(only_now_music)
+
+        # Full combo challenge?
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'fc_challenge')
+        if entry is None:
+            entry = ValidatedDict()
+
+        fc_challenge = Node.void('fc_challenge')
+        info.add_child(fc_challenge)
+        today = Node.void('today')
+        fc_challenge.add_child(today)
+        today.add_child(Node.s32('music_id', entry.get_int('today', -1)))
+
+        # Some sort of music DB whitelist
+        info.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'open_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        cabinet_survey = Node.void('cabinet_survey')
+        info.add_child(cabinet_survey)
+        cabinet_survey.add_child(Node.s32('id', -1))
+        cabinet_survey.add_child(Node.s32('status', 0))
+
+        kaitou_bisco = Node.void('kaitou_bisco')
+        info.add_child(kaitou_bisco)
+        kaitou_bisco.add_child(Node.s32('remaining_days', 0))
+
+        league = Node.void('league')
+        info.add_child(league)
+        league.add_child(Node.u8('status', 1))
+
+        bistro = Node.void('bistro')
+        info.add_child(bistro)
+        bistro.add_child(Node.u16('bistro_id', 0))
+
+        jbox = Node.void('jbox')
+        info.add_child(jbox)
+        jbox.add_child(Node.s32('point', 0))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        normal = Node.void('normal')
+        emblem.add_child(normal)
+        premium = Node.void('premium')
+        emblem.add_child(premium)
+        normal.add_child(Node.s16('index', 0))
+        premium.add_child(Node.s16('index', 0))
+
+        return info
+
+    def handle_shopinfo_regist_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('shop/name'))
+
+        shopinfo = Node.void('shopinfo')
+
+        data = Node.void('data')
+        shopinfo.add_child(data)
+        data.add_child(Node.u32('cabid', 1))
+        data.add_child(Node.string('locationid', 'nowhere'))
+        data.add_child(Node.u8('tax_phase', 1))
+
+        facility = Node.void('facility')
+        data.add_child(facility)
+        facility.add_child(Node.u32('exist', 1))
+
+        data.add_child(self.__get_global_info())
+
+        return shopinfo
+
+    def handle_gametop_regist_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        refid = player.child_value('refid')
+        name = player.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        return root
+
+    def handle_gametop_get_pdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        refid = player.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_mdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+        root = self.get_scores_by_extid(extid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_info_request(self, request: Node) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        data.add_child(self.__get_global_info())
+
+        return root
+
+    def handle_gametop_get_course_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+
+        gametop = Node.void('gametop')
+        data = Node.void('data')
+        gametop.add_child(data)
+
+        # Course list available
+        course_list = Node.void('course_list')
+        data.add_child(course_list)
+
+        validcourses: List[int] = []
+        courses = self.get_all_courses()
+        courses.extend([
+            {
+                'id': 31,
+                'name': 'Enjoy! The 5th KAC ~ tracks of prop ~',
+                'level': 5,
+                'music': [
+                    (60000065, 1),
+                    (60000008, 1),
+                    (60000001, 1),
+                    (60001009, 1),
+                    (60000010, 1),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                    self.COURSE_REQUIREMENT_FULL_COMBO: [1, 2, 4],
+                },
+            },
+            {
+                'id': 32,
+                'name': 'Challenge! The 5th KAC ~ tracks of prop ~',
+                'level': 7,
+                'music': [
+                    (60000065, 2),
+                    (60000008, 2),
+                    (60000001, 2),
+                    (60001009, 2),
+                    (60000010, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [900000, 950000, 980000],
+                },
+            },
+            {
+                'id': 33,
+                'name': 'The 5th KAC ~ tracks of prop ~',
+                'level': 10,
+                'music': [
+                    (60000065, 2),
+                    (60000008, 2),
+                    (60000001, 2),
+                    (60001009, 2),
+                    (60000010, 2),
+                ],
+                'requirements': {
+                    self.COURSE_REQUIREMENT_SCORE: [920000, 950000, 980000],
+                },
+            },
+        ])
+
+        for course in courses:
+            coursenode = Node.void('course')
+            course_list.add_child(coursenode)
+
+            # Basic course info
+            if course['id'] in validcourses:
+                raise Exception('Cannot have same course ID specified twice!')
+            validcourses.append(course['id'])
+            coursenode.add_child(Node.s32('id', course['id']))
+            coursenode.add_child(Node.string('name', course['name']))
+            coursenode.add_child(Node.u8('level', course['level']))
+
+            # Translate internal to game
+            def translate_req(internal_req: int) -> int:
+                return {
+                    self.COURSE_REQUIREMENT_SCORE: self.GAME_COURSE_REQUIREMENT_SCORE,
+                    self.COURSE_REQUIREMENT_FULL_COMBO: self.GAME_COURSE_REQUIREMENT_FULL_COMBO,
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: self.GAME_COURSE_REQUIREMENT_PERFECT_PERCENT,
+                }.get(internal_req, 0)
+
+            # Course bronze/silver/gold rules
+            ids = [0] * 3
+            bronze_values = [0] * 3
+            silver_values = [0] * 3
+            gold_values = [0] * 3
+            slot = 0
+            for req in course['requirements']:
+                req_values = course['requirements'][req]
+
+                ids[slot] = translate_req(req)
+                bronze_values[slot] = req_values[0]
+                silver_values[slot] = req_values[1]
+                gold_values[slot] = req_values[2]
+                slot = slot + 1
+
+            norma = Node.void('norma')
+            coursenode.add_child(norma)
+            norma.add_child(Node.s32_array('norma_id', ids))
+            norma.add_child(Node.s32_array('bronze_value', bronze_values))
+            norma.add_child(Node.s32_array('silver_value', silver_values))
+            norma.add_child(Node.s32_array('gold_value', gold_values))
+
+            # Music list for course
+            music_index = 0
+            music_list = Node.void('music_list')
+            coursenode.add_child(music_list)
+
+            for entry in course['music']:
+                music = Node.void('music')
+                music.set_attribute('index', str(music_index))
+                music_list.add_child(music)
+                music.add_child(Node.s32('music_id', entry[0]))
+                music.add_child(Node.u8('seq', entry[1]))
+                music_index = music_index + 1
+
+        # Look up profile so we can load the last course played
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            profile = ValidatedDict()
+
+        # Player scores for courses
+        player_list = Node.void('player_list')
+        data.add_child(player_list)
+        player = Node.void('player')
+        player_list.add_child(player)
+        player.add_child(Node.s32('jid', extid))
+
+        result_list = Node.void('result_list')
+        player.add_child(result_list)
+        playercourses = self.get_courses(userid)
+        for courseid in playercourses:
+            if courseid not in validcourses:
+                continue
+
+            rating = {
+                self.COURSE_RATING_FAILED: self.GAME_COURSE_RATING_FAILED,
+                self.COURSE_RATING_BRONZE: self.GAME_COURSE_RATING_BRONZE,
+                self.COURSE_RATING_SILVER: self.GAME_COURSE_RATING_SILVER,
+                self.COURSE_RATING_GOLD: self.GAME_COURSE_RATING_GOLD,
+            }[playercourses[courseid]['rating']]
+            scores = playercourses[courseid]['scores']
+
+            result = Node.void('result')
+            result_list.add_child(result)
+            result.add_child(Node.s32('id', courseid))
+            result.add_child(Node.u8('rating', rating))
+            result.add_child(Node.s32_array('score', scores))
+
+        # Last course ID
+        data.add_child(Node.s32('last_course_id', profile.get_dict('last').get_int('last_course_id', -1)))
+
+        return gametop
+
+    def handle_gametop_get_league_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+
+        # Look up profile so we can load the last course played
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            profile = ValidatedDict()
+
+        gametop = Node.void('gametop')
+        data = Node.void('data')
+        gametop.add_child(data)
+
+        league_list = Node.void('league_list')
+        data.add_child(league_list)
+
+        # Look up the current league charts in the DB
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'league')
+        if entry is not None:
+            # Just get the week number, use that as the ID
+            leagueid = int(entry['start_time'] / 604800)
+
+            league = Node.void('league')
+            league_list.add_child(league)
+            league.set_attribute('index', '0')
+
+            league.add_child(Node.s32('id', leagueid))
+            league.add_child(Node.u64('stime', entry['start_time'] * 1000))
+            league.add_child(Node.u64('etime', entry['end_time'] * 1000))
+
+            music_list = Node.void('music_list')
+            league.add_child(music_list)
+
+            # We need to know the player class so we can determine what chart to present.
+            current_class = profile.get_int('league_class', 1)
+
+            song_index = 0
+            for song in entry['music']:
+                music = Node.void('music')
+                music_list.add_child(music)
+                music.set_attribute('index', str(song_index))
+                song_index = song_index + 1
+
+                music.add_child(Node.s32('music_id', song))
+                music.add_child(Node.u8('seq', 1 if current_class == 1 else 2))
+
+            player_list = Node.void('player_list')
+            league.add_child(player_list)
+
+            player = Node.void('player')
+            player_list.add_child(player)
+            player.add_child(Node.s32('jid', extid))
+            result = Node.void('result')
+            player.add_child(result)
+
+            league_score = self.data.local.user.get_achievement(self.game, self.version, userid, leagueid, 'league')
+            if league_score is None:
+                league_score = ValidatedDict()
+
+            result.add_child(Node.s32_array('score', league_score.get_int_array('score', 3, [0] * 3)))
+            result.add_child(Node.s8_array('clear', league_score.get_int_array('clear', 3, [0] * 3)))
+
+        data.add_child(Node.s32('last_class', profile.get_dict('last').get_int('league_class', 1)))
+        data.add_child(Node.s32('last_subclass', profile.get_dict('last').get_int('league_subclass', 5)))
+        data.add_child(Node.bool('is_checked', profile.get_bool('league_is_checked')))
+
+        return gametop
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        # Jubeat Prop appears to allow full event overrides per-player
+        data.add_child(self.__get_global_info())
+
+        player = Node.void('player')
+        data.add_child(player)
+
+        # Basic profile info
+        player.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+
+        # Miscelaneous crap
+        player.add_child(Node.s32('session_id', 1))
+        player.add_child(Node.u64('event_flag', 0))
+
+        # Player info and statistics
+        info = Node.void('info')
+        player.add_child(info)
+        info.add_child(Node.s16('jubility', profile.get_int('jubility')))
+        info.add_child(Node.s16('jubility_yday', profile.get_int('jubility_yday')))
+        info.add_child(Node.s32('tune_cnt', profile.get_int('tune_cnt')))
+        info.add_child(Node.s32('save_cnt', profile.get_int('save_cnt')))
+        info.add_child(Node.s32('saved_cnt', profile.get_int('saved_cnt')))
+        info.add_child(Node.s32('fc_cnt', profile.get_int('fc_cnt')))
+        info.add_child(Node.s32('ex_cnt', profile.get_int('ex_cnt')))
+        info.add_child(Node.s32('clear_cnt', profile.get_int('clear_cnt')))
+        info.add_child(Node.s32('pf_cnt', profile.get_int('pf_cnt')))
+        info.add_child(Node.s32('match_cnt', profile.get_int('match_cnt')))
+        info.add_child(Node.s32('beat_cnt', profile.get_int('beat_cnt')))
+        info.add_child(Node.s32('mynews_cnt', profile.get_int('mynews_cnt')))
+        info.add_child(Node.s32('bonus_tune_points', profile.get_int('bonus_tune_points')))
+        info.add_child(Node.bool('is_bonus_tune_played', profile.get_bool('is_bonus_tune_played')))
+
+        # Looks to be set to true when there's an old profile, stops tutorial from
+        # happening on first load.
+        info.add_child(Node.bool('inherit', profile.get_bool('has_old_version')))
+
+        # Not saved, but loaded
+        info.add_child(Node.s32('mtg_entry_cnt', 123))
+        info.add_child(Node.s32('mtg_hold_cnt', 456))
+        info.add_child(Node.u8('mtg_result', 10))
+
+        # Last played data, for showing cursor and such
+        lastdict = profile.get_dict('last')
+        last = Node.void('last')
+        player.add_child(last)
+        last.add_child(Node.s64('play_time', lastdict.get_int('play_time')))
+        last.add_child(Node.string('shopname', lastdict.get_str('shopname')))
+        last.add_child(Node.string('areaname', lastdict.get_str('areaname')))
+        last.add_child(Node.s8('expert_option', lastdict.get_int('expert_option')))
+        last.add_child(Node.s8('category', lastdict.get_int('category')))
+        last.add_child(Node.s8('sort', lastdict.get_int('sort')))
+        last.add_child(Node.s32('music_id', lastdict.get_int('music_id')))
+        last.add_child(Node.s8('seq_id', lastdict.get_int('seq_id')))
+
+        settings = Node.void('settings')
+        last.add_child(settings)
+        settings.add_child(Node.s8('marker', lastdict.get_int('marker')))
+        settings.add_child(Node.s8('theme', lastdict.get_int('theme')))
+        settings.add_child(Node.s16('title', lastdict.get_int('title')))
+        settings.add_child(Node.s16('parts', lastdict.get_int('parts')))
+        settings.add_child(Node.s8('rank_sort', lastdict.get_int('rank_sort')))
+        settings.add_child(Node.s8('combo_disp', lastdict.get_int('combo_disp')))
+        settings.add_child(Node.s16_array('emblem', lastdict.get_int_array('emblem', 5)))
+        settings.add_child(Node.s8('matching', lastdict.get_int('matching')))
+        settings.add_child(Node.s8('hazard', lastdict.get_int('hazard')))
+        settings.add_child(Node.s8('hard', lastdict.get_int('hard')))
+
+        # Secret unlocks
+        item = Node.void('item')
+        player.add_child(item)
+        item.add_child(Node.s32_array('music_list', profile.get_int_array('music_list', 32, [-1] * 32)))
+        item.add_child(Node.s32_array('secret_list', profile.get_int_array('secret_list', 32, [-1] * 32)))
+        item.add_child(Node.s16('theme_list', profile.get_int('theme_list', -1)))
+        item.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list', 2, [-1] * 2)))
+        item.add_child(Node.s32_array('title_list', profile.get_int_array('title_list', 160, [-1] * 160)))
+        item.add_child(Node.s32_array('parts_list', profile.get_int_array('parts_list', 160, [-1] * 160)))
+        item.add_child(Node.s32_array('emblem_list', profile.get_int_array('emblem_list', 96, [-1] * 96)))
+
+        new = Node.void('new')
+        item.add_child(new)
+        new.add_child(Node.s32_array('secret_list', profile.get_int_array('secret_list_new', 32, [-1] * 32)))
+        new.add_child(Node.s16('theme_list', profile.get_int('theme_list_new', -1)))
+        new.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list_new', 2, [-1] * 2)))
+
+        # Sane defaults for unknown/who cares nodes
+        history = Node.void('history')
+        player.add_child(history)
+        history.set_attribute('count', '0')
+        lab_edit_seq = Node.void('lab_edit_seq')
+        player.add_child(lab_edit_seq)
+        lab_edit_seq.set_attribute('count', '0')
+        cabinet_survey = Node.void('cabinet_survey')
+        player.add_child(cabinet_survey)
+        cabinet_survey.add_child(Node.u32('read_flag', 0))
+        kaitou_bisco = Node.void('kaitou_bisco')
+        player.add_child(kaitou_bisco)
+        kaitou_bisco.add_child(Node.u32('read_flag', profile.get_int('kaitou_bisco_read_flag')))
+        navi = Node.void('navi')
+        player.add_child(navi)
+        navi.add_child(Node.u32('flag', profile.get_int('navi_flag')))
+
+        # Player status for events
+        event_info = Node.void('event_info')
+        player.add_child(event_info)
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for achievement in achievements:
+            if achievement.type == 'event':
+                # There are two significant bits here, 0x1 and 0x2, I think the first
+                # one is whether the event is started, second is if its finished?
+                event = Node.void('event')
+                event_info.add_child(event)
+                event.set_attribute('type', str(achievement.id))
+
+                state = 0x0
+                state = state + 0x2 if achievement.data.get_bool('is_completed') else 0x0
+                event.add_child(Node.u8('state', state))
+
+        # Full combo challenge
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'fc_challenge')
+        if entry is None:
+            entry = ValidatedDict()
+
+        # Figure out if we've played these songs
+        start_time, end_time = self.data.local.network.get_schedule_duration('daily')
+        today_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('today', -1), timelimit=start_time)
+        whim_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('whim', -1), timelimit=start_time)
+
+        fc_challenge = Node.void('fc_challenge')
+        player.add_child(fc_challenge)
+        today = Node.void('today')
+        fc_challenge.add_child(today)
+        today.add_child(Node.s32('music_id', entry.get_int('today', -1)))
+        today.add_child(Node.u8('state', 0x40 if len(today_attempts) > 0 else 0x0))
+        whim = Node.void('whim')
+        fc_challenge.add_child(whim)
+        whim.add_child(Node.s32('music_id', entry.get_int('whim', -1)))
+        whim.add_child(Node.u8('state', 0x40 if len(whim_attempts) > 0 else 0x0))
+
+        # No news, ever.
+        news = Node.void('news')
+        player.add_child(news)
+        news.add_child(Node.s16('checked', 0))
+        news.add_child(Node.u32('checked_flag', 0))
+
+        # No rival support, yet.
+        rivallist = Node.void('rivallist')
+        player.add_child(rivallist)
+        rivallist.set_attribute('count', '0')
+
+        # Nothing in life is free, WTF?
+        free_first_play = Node.void('free_first_play')
+        player.add_child(free_first_play)
+        free_first_play.add_child(Node.bool('is_available', False))
+        free_first_play.add_child(Node.s32('point', 0))
+        free_first_play.add_child(Node.s32('point_used', 0))
+        come_come_jbox = Node.void('come_come_jbox')
+        free_first_play.add_child(come_come_jbox)
+        come_come_jbox.add_child(Node.bool('is_valid', False))
+        come_come_jbox.add_child(Node.s64('end_time_if_paired', 0))
+
+        # JBox stuff
+        jbox = Node.void('jbox')
+        jboxdict = profile.get_dict('jbox')
+        player.add_child(jbox)
+        jbox.add_child(Node.s32('point', jboxdict.get_int('point')))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        normal = Node.void('normal')
+        emblem.add_child(normal)
+        premium = Node.void('premium')
+        emblem.add_child(premium)
+        normal.add_child(Node.s16('index', jboxdict.get_int('normal_index') + 1))
+        premium.add_child(Node.s16('index', jboxdict.get_int('premium_index') + 1))
+
+        # Career stuff
+        career = Node.void('career')
+        careerdict = profile.get_dict('career')
+        player.add_child(career)
+        career.add_child(Node.s16('level', careerdict.get_int('level', 1)))
+        career.add_child(Node.s32('point', careerdict.get_int('point')))
+        career.add_child(Node.s32_array('param', careerdict.get_int_array('param', 10, [-1] * 10)))
+        career.add_child(Node.bool('is_unlocked', careerdict.get_bool('is_unlocked')))
+
+        # League stuff
+        league = Node.void('league')
+        player.add_child(league)
+        league.add_child(Node.bool('is_first_play', profile.get_bool('league_is_first_play', True)))
+        league.add_child(Node.s32('class', profile.get_int('league_class', 1)))
+        league.add_child(Node.s32('subclass', profile.get_int('league_subclass', 5)))
+
+        # New Music stuff
+        new_music = Node.void('new_music')
+        player.add_child(new_music)
+
+        # Emblem list stuff?
+        eapass_privilege = Node.void('eapass_privilege')
+        player.add_child(eapass_privilege)
+        emblem_list = Node.void('emblem_list')
+        eapass_privilege.add_child(emblem_list)
+
+        # Bonus music stuff?
+        bonus_music = Node.void('bonus_music')
+        player.add_child(bonus_music)
+        bonus_music.add_child(Node.void('music'))
+        bonus_music.add_child(Node.s32('event_id', -1))
+        bonus_music.add_child(Node.string('till_time', ''))
+
+        # Bistro stuff is back?
+        bistro = Node.void('bistro')
+        player.add_child(bistro)
+        chef = Node.void('chef')
+        bistro.add_child(chef)
+        chef.add_child(Node.s32('id', 1))
+        bistro.add_child(Node.s32('carry_over', 0))
+        route_list = Node.void('route_list')
+        bistro.add_child(route_list)
+        route_list.add_child(Node.u8('route_count', 0))
+        # If we have routes, they look like this:
+        #     <route>
+        #         <no __type="u8">#</no>
+        #         <content kind="?">
+        #             <value __type="s32">??</value>
+        #         </content>
+        #         <gourmates>
+        #             <id __type="s32">??</id>
+        #         </gourmates>
+        bistro.add_child(Node.bool('extension', False))
+
+        # Gift list, maybe from other players?
+        gift_list = Node.void('gift_list')
+        player.add_child(gift_list)
+        # If we had gifts, they look like this:
+        #     <gift reason="??" kind="??">
+        #         <id __type="s32">??</id>
+        #     </gift>
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        data = request.child('data')
+
+        # Grab system information
+        sysinfo = data.child('info')
+
+        # Grab player information
+        player = data.child('player')
+
+        # Grab result information
+        result = data.child('result')
+
+        # Grab last information. Lots of this will be filled in while grabbing scores
+        last = newprofile.get_dict('last')
+        if sysinfo is not None:
+            last.replace_int('play_time', sysinfo.child_value('time_gameend'))
+            last.replace_str('shopname', sysinfo.child_value('shopname'))
+            last.replace_str('areaname', sysinfo.child_value('areaname'))
+
+        # Grab player info for echoing back
+        info = player.child('info')
+        if info is not None:
+            newprofile.replace_int('jubility', info.child_value('jubility'))
+            newprofile.replace_int('jubility_yday', info.child_value('jubility_yday'))
+            newprofile.replace_int('tune_cnt', info.child_value('tune_cnt'))
+            newprofile.replace_int('save_cnt', info.child_value('save_cnt'))
+            newprofile.replace_int('saved_cnt', info.child_value('saved_cnt'))
+            newprofile.replace_int('fc_cnt', info.child_value('fc_cnt'))
+            newprofile.replace_int('ex_cnt', info.child_value('ex_cnt'))
+            newprofile.replace_int('pf_cnt', info.child_value('pf_cnt'))
+            newprofile.replace_int('clear_cnt', info.child_value('clear_cnt'))
+            newprofile.replace_int('match_cnt', info.child_value('match_cnt'))
+            newprofile.replace_int('beat_cnt', info.child_value('beat_cnt'))
+            newprofile.replace_int('total_best_score', info.child_value('total_best_score'))
+            newprofile.replace_int('mynews_cnt', info.child_value('mynews_cnt'))
+
+            newprofile.replace_int('bonus_tune_points', info.child_value('bonus_tune_points'))
+            newprofile.replace_bool('is_bonus_tune_played', info.child_value('is_bonus_tune_played'))
+
+        # Grab last settings (finally mostly in its own node!)
+        lastnode = player.child('last')
+        if lastnode is not None:
+            last.replace_int('expert_option', lastnode.child_value('expert_option'))
+            last.replace_int('sort', lastnode.child_value('sort'))
+            last.replace_int('category', lastnode.child_value('category'))
+
+            settings = lastnode.child('settings')
+            if settings is not None:
+                last.replace_int('matching', settings.child_value('matching'))
+                last.replace_int('hazard', settings.child_value('hazard'))
+                last.replace_int('hard', settings.child_value('hard'))
+                last.replace_int('marker', settings.child_value('marker'))
+                last.replace_int('theme', settings.child_value('theme'))
+                last.replace_int('title', settings.child_value('title'))
+                last.replace_int('parts', settings.child_value('parts'))
+                last.replace_int('rank_sort', settings.child_value('rank_sort'))
+                last.replace_int('combo_disp', settings.child_value('combo_disp'))
+                last.replace_int_array('emblem', 5, settings.child_value('emblem'))
+
+        # Grab unlock progress
+        item = player.child('item')
+        if item is not None:
+            newprofile.replace_int_array('secret_list', 32, item.child_value('secret_list'))
+            newprofile.replace_int_array('title_list', 160, item.child_value('title_list'))
+            newprofile.replace_int('theme_list', item.child_value('theme_list'))
+            newprofile.replace_int_array('marker_list', 2, item.child_value('marker_list'))
+            newprofile.replace_int_array('parts_list', 160, item.child_value('parts_list'))
+            newprofile.replace_int_array('music_list', 32, item.child_value('music_list'))
+            newprofile.replace_int_array('emblem_list', 96, item.child_value('emblem_list'))
+
+            newitem = item.child('new')
+            if newitem is not None:
+                newprofile.replace_int_array('secret_list_new', 32, newitem.child_value('secret_list'))
+                newprofile.replace_int('theme_list_new', newitem.child_value('theme_list'))
+                newprofile.replace_int_array('marker_list_new', 2, newitem.child_value('marker_list'))
+
+        # Career progression
+        career = player.child('career')
+        careerdict = newprofile.get_dict('career')
+        if career is not None:
+            careerdict.replace_int('level', career.child_value('level'))
+            careerdict.replace_int('point', career.child_value('point'))
+            careerdict.replace_int_array('param', 10, career.child_value('param'))
+            careerdict.replace_bool('is_unlocked', career.child_value('is_unlocked'))
+        newprofile.replace_dict('career', careerdict)
+
+        # jbox stuff
+        jbox = player.child('jbox')
+        jboxdict = newprofile.get_dict('jbox')
+        if jbox is not None:
+            jboxdict.replace_int('point', jbox.child_value('point'))
+            emblemtype = jbox.child_value('emblem/type')
+            index = jbox.child_value('emblem/index')
+            if emblemtype == self.JBOX_EMBLEM_NORMAL:
+                jboxdict.replace_int('normal_index', index)
+            elif emblemtype == self.JBOX_EMBLEM_PREMIUM:
+                jboxdict.replace_int('premium_index', index)
+        newprofile.replace_dict('jbox', jboxdict)
+
+        # event stuff
+        event_info = player.child('event_info')
+        if event_info is not None:
+            for child in event_info.children:
+                try:
+                    eventid = int(child.attribute('type'))
+                except TypeError:
+                    # Event is empty
+                    continue
+                is_completed = child.child_value('is_completed')
+
+                # Figure out if we should update the rating/scores or not
+                oldevent = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    'event',
+                )
+
+                if oldevent is None:
+                    # Create a new event structure for this
+                    oldevent = ValidatedDict()
+
+                oldevent.replace_bool('is_completed', is_completed)
+
+                # Save it as an achievement
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    'event',
+                    oldevent,
+                )
+
+        # A whole bunch of miscelaneous shit
+        newprofile.replace_int('navi_flag', player.child_value('navi/flag'))
+        newprofile.replace_int('kaitou_bisco_read_flag', player.child_value('kaitou_bisco/read_flag'))
+
+        # Get timestamps for played songs
+        timestamps: Dict[int, int] = {}
+        history = player.child('history')
+        if history is not None:
+            for tune in history.children:
+                if tune.name != 'tune':
+                    continue
+                entry = int(tune.attribute('log_id'))
+                ts = int(tune.child_value('timestamp') / 1000)
+                timestamps[entry] = ts
+
+        # Grab scores and save those
+        if result is not None:
+            for tune in result.children:
+                if tune.name != 'tune':
+                    continue
+                result = tune.child('player')
+
+                entry = int(tune.attribute('id'))
+                songid = tune.child_value('music')
+                timestamp = timestamps.get(entry, Time.now())
+                chart = int(result.child('score').attribute('seq'))
+                points = result.child_value('score')
+                flags = int(result.child('score').attribute('clear'))
+                combo = int(result.child('score').attribute('combo'))
+                ghost = result.child_value('mbar')
+
+                # Miscelaneous last data for echoing to profile get
+                last.replace_int('music_id', songid)
+                last.replace_int('seq_id', chart)
+
+                mapping = {
+                    self.GAME_FLAG_BIT_CLEARED: self.PLAY_MEDAL_CLEARED,
+                    self.GAME_FLAG_BIT_FULL_COMBO: self.PLAY_MEDAL_FULL_COMBO,
+                    self.GAME_FLAG_BIT_EXCELLENT: self.PLAY_MEDAL_EXCELLENT,
+                    self.GAME_FLAG_BIT_NEARLY_FULL_COMBO: self.PLAY_MEDAL_NEARLY_FULL_COMBO,
+                    self.GAME_FLAG_BIT_NEARLY_EXCELLENT: self.PLAY_MEDAL_NEARLY_EXCELLENT,
+                }
+
+                # Figure out the highest medal based on bits passed in
+                medal = self.PLAY_MEDAL_FAILED
+                for bit in mapping:
+                    if flags & bit > 0:
+                        medal = max(medal, mapping[bit])
+
+                self.update_score(userid, timestamp, songid, chart, points, medal, combo, ghost)
+
+        # If this was a course save, grab and save that info too
+        course = player.child('course')
+        if course is not None:
+            courseid = course.child_value('course_id')
+            rating = {
+                self.GAME_COURSE_RATING_FAILED: self.COURSE_RATING_FAILED,
+                self.GAME_COURSE_RATING_BRONZE: self.COURSE_RATING_BRONZE,
+                self.GAME_COURSE_RATING_SILVER: self.COURSE_RATING_SILVER,
+                self.GAME_COURSE_RATING_GOLD: self.COURSE_RATING_GOLD,
+            }[course.child_value('rating')]
+            scores = [0] * 5
+            for music in course.children:
+                if music.name != 'music':
+                    continue
+                index = int(music.attribute('index'))
+                scores[index] = music.child_value('score')
+
+            # Save course itself
+            self.save_course(userid, courseid, rating, scores)
+
+            # Save the last course ID
+            last.replace_int('last_course_id', courseid)
+
+        # If this was a league save, grab and save that info too
+        league = player.child('league')
+        if league is not None:
+            leagueid = league.child_value('league_id')
+            newprofile.replace_bool('league_is_checked', league.child_value('is_checked'))
+            newprofile.replace_bool('league_is_first_play', league.child_value('is_first_play'))
+
+            # Extract scores
+            score = [0] * 3
+            clear = [0] * 3
+            for music in league.children:
+                if music.name != 'music':
+                    continue
+                index = int(music.attribute('index'))
+                scorenode = music.child('score')
+                clear[index] = int(scorenode.attribute('clear'))
+                score[index] = scorenode.value
+
+            # Update score if it is higher
+            oldleague = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                leagueid,
+                'league',
+            )
+            if oldleague is None:
+                oldleague = ValidatedDict()
+            oldscore = oldleague.get_int_array('score', 3)
+            if sum(oldscore) < sum(score):
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    leagueid,
+                    'league',
+                    {'score': score, 'clear': clear},
+                )
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', last)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('gametop')
+        datanode = Node.void('data')
+        root.add_child(datanode)
+        player = Node.void('player')
+        datanode.add_child(player)
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+        playdata = Node.void('mdata_list')
+        player.add_child(playdata)
+
+        music = ValidatedDict()
+        for score in scores:
+            data = music.get_dict(str(score.id))
+            play_cnt = data.get_int_array('play_cnt', 3)
+            clear_cnt = data.get_int_array('clear_cnt', 3)
+            clear_flags = data.get_int_array('clear_flags', 3)
+            fc_cnt = data.get_int_array('fc_cnt', 3)
+            ex_cnt = data.get_int_array('ex_cnt', 3)
+            points = data.get_int_array('points', 3)
+
+            # Replace data for this chart type
+            play_cnt[score.chart] = score.plays
+            clear_cnt[score.chart] = score.data.get_int('clear_count')
+            fc_cnt[score.chart] = score.data.get_int('full_combo_count')
+            ex_cnt[score.chart] = score.data.get_int('excellent_count')
+            points[score.chart] = score.points
+
+            # Format the clear flags
+            clear_flags[score.chart] = self.GAME_FLAG_BIT_PLAYED
+            if score.data.get_int('clear_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_CLEARED
+            if score.data.get_int('full_combo_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_FULL_COMBO
+            if score.data.get_int('excellent_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_EXCELLENT
+
+            # Save chart data back
+            data.replace_int_array('play_cnt', 3, play_cnt)
+            data.replace_int_array('clear_cnt', 3, clear_cnt)
+            data.replace_int_array('clear_flags', 3, clear_flags)
+            data.replace_int_array('fc_cnt', 3, fc_cnt)
+            data.replace_int_array('ex_cnt', 3, ex_cnt)
+            data.replace_int_array('points', 3, points)
+
+            # Update the ghost (untyped)
+            ghost = data.get('ghost', [None, None, None])
+            ghost[score.chart] = score.data.get('ghost')
+            data['ghost'] = ghost
+
+            # Save it back
+            music.replace_dict(str(score.id), data)
+
+        for scoreid in music:
+            scoredata = music[scoreid]
+            musicdata = Node.void('musicdata')
+            playdata.add_child(musicdata)
+
+            musicdata.set_attribute('music_id', scoreid)
+            musicdata.add_child(Node.s32_array('play_cnt', scoredata.get_int_array('play_cnt', 3)))
+            musicdata.add_child(Node.s32_array('clear_cnt', scoredata.get_int_array('clear_cnt', 3)))
+            musicdata.add_child(Node.s32_array('fc_cnt', scoredata.get_int_array('fc_cnt', 3)))
+            musicdata.add_child(Node.s32_array('ex_cnt', scoredata.get_int_array('ex_cnt', 3)))
+            musicdata.add_child(Node.s32_array('score', scoredata.get_int_array('points', 3)))
+            musicdata.add_child(Node.s8_array('clear', scoredata.get_int_array('clear_flags', 3)))
+
+            ghosts = scoredata.get('ghost', [None, None, None])
+            for i in range(len(ghosts)):
+                ghost = ghosts[i]
+                if ghost is None:
+                    continue
+
+                bar = Node.u8_array('bar', ghost)
+                musicdata.add_child(bar)
+                bar.set_attribute('seq', str(i))
+
+        return root
diff --git a/bemani/backend/jubeat/qubell.py b/bemani/backend/jubeat/qubell.py
new file mode 100644
index 0000000..92a822d
--- /dev/null
+++ b/bemani/backend/jubeat/qubell.py
@@ -0,0 +1,1127 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+from typing import Any, Dict, List, Optional, Tuple
+
+from bemani.backend.base import Status
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.backend.jubeat.common import (
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+)
+from bemani.backend.jubeat.prop import JubeatProp
+
+from bemani.common import ValidatedDict, VersionConstants
+from bemani.data import Data, Score, UserID
+from bemani.protocol import Node
+
+
+class JubeatQubell(
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+    JubeatBase,
+):
+
+    name = 'Jubeat Qubell'
+    version = VersionConstants.JUBEAT_QUBELL
+
+    JBOX_EMBLEM_NORMAL = 1
+    JBOX_EMBLEM_PREMIUM = 2
+
+    ENABLE_GARNET = False
+
+    EVENTS = {
+        5: {
+            'enabled': False,
+        },
+        6: {
+            'enabled': False,
+        },
+        15: {
+            'enabled': False,
+        },
+        19: {
+            'enabled': False,
+        },
+    }
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatProp(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert daily FC challenges into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'fc_challenge', 'daily'):
+            # Generate a new list of two FC challenge songs.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = set(song.id for song in data.local.music.get_all_songs(cls.game, cls.version))
+            daily_songs = random.sample(all_songs, 2)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'fc_challenge',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            )
+            events.append((
+                'jubeat_fc_challenge_charts',
+                {
+                    'version': cls.version,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'fc_challenge', 'daily')
+        return events
+
+    def __get_global_info(self) -> Node:
+        info = Node.void('info')
+
+        # Event info. Valid event IDs are 5, 6, 15, 19
+        event_info = Node.void('event_info')
+        info.add_child(event_info)
+        for event in self.EVENTS:
+            evt = Node.void('event')
+            event_info.add_child(evt)
+            evt.set_attribute('type', str(event))
+            evt.add_child(Node.u8('state', 0x1 if self.EVENTS[event]['enabled'] else 0x0))
+
+        # Each of the following two sections should have zero or more child nodes (no
+        # particular name) which look like the following:
+        #     <node>
+        #         <id __type="s32">songid</id>
+        #         <stime __type="str">start time?</stime>
+        #         <etime __type="str">end time?</etime>
+        #     </node>
+        # Share music?
+        share_music = Node.void('share_music')
+        info.add_child(share_music)
+
+        # Bonus music?
+        bonus_music = Node.void('bonus_music')
+        info.add_child(bonus_music)
+
+        # Some sort of music DB whitelist
+        info.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'white_marker_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'white_theme_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'open_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        info.add_child(Node.s32_array(
+            'shareable_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+
+        jbox = Node.void('jbox')
+        info.add_child(jbox)
+        jbox.add_child(Node.s32('point', 0))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        normal = Node.void('normal')
+        emblem.add_child(normal)
+        premium = Node.void('premium')
+        emblem.add_child(premium)
+        normal.add_child(Node.s16('index', 0))
+        premium.add_child(Node.s16('index', 0))
+
+        born = Node.void('born')
+        info.add_child(born)
+        born.add_child(Node.s8('status', 0))
+        born.add_child(Node.s16('year', 0))
+
+        digdig = Node.void('digdig')
+        info.add_child(digdig)
+        stage_list = Node.void('stage_list')
+        digdig.add_child(stage_list)
+        # Stage numbers are between 1 and 13 inclusive.
+        for i in range(1, 14):
+            stage = Node.void('stage')
+            stage_list.add_child(stage)
+            stage.set_attribute('number', str(i))
+            stage.add_child(Node.u8('state', 0x1))
+
+        # Collection list values should look like:
+        #     <rating>
+        #         <id __type="s32">songid</id>
+        #         <stime __type="str">start time?</stime>
+        #         <etime __type="str">end time?</etime>
+        #     </node>
+        collection = Node.void('collection')
+        info.add_child(collection)
+        collection.add_child(Node.void('rating_s'))
+
+        # Additional digdig nodes that aren't the main event
+        generic_dig = Node.void('generic_dig')
+        info.add_child(generic_dig)
+        map_list = Node.void('map_list')
+        generic_dig.add_child(map_list)
+        # DigDig nodes here have the following format:
+        # <map release_code='somecode' dataversion='someversion' id='someid' client_map_kind='somekind'>
+        #     <stime __type="str">start time?</stime>
+        #     <etime __type="str">end time?</etime>
+        #     <stage_list>
+        #         <!-- stage number is between 1 and 14 inclusive here -->
+        #         <stage number='number'>
+        #             <need_point __type="s32">point</need_point>
+        #             <need_norma_num __type="s32">norma num</need_point>
+        #             <norma_list>
+        #                 <norma>
+        #                     <point __type="s32">point</point>
+        #                     <!-- between 1 and 15 inclusive -->
+        #                     <type __type="s32">type</type>
+        #                     <music_id __type="s32">music_id</music_id>
+        #                     <seq_difficulty __type="s32">seq_difficulty</seq_difficulty>
+        #                     <rating __type="s32">rating</rating>
+        #                     <stage_level __type="s32">stage_level</stage_level>
+        #                     <goal __type="s32">goal</goalpoint>
+        #                     <title_line_list>
+        #                         <!-- there can be up to 4 of these -->
+        #                         <title type="str">32 bytes long title</title>
+        #                     </title_line_list>
+        #                 </norma>
+        #             </norma_list>
+        #             <item_list>
+        #                 <item>
+        #                     <point __type="s32">point</point>
+        #                     <!-- between 1 and 7 inclusive -->
+        #                     <type __type="s32">type</type>
+        #                     <music_id __type="s32">music_id</music_id>
+        #                     <bonus_tune_point __type="s32">bonus_tune_point</bonus_tune_point>
+        #                     <title_id __type="s32">title_id</title_id>
+        #                     <marker_id __type="s32">marker_id</marker_id>
+        #                     <background_id __type="s32">background_id</background_id>
+        #                 </item>
+        #             </item_list>
+        #             <!-- unlock challenge -->
+        #             <unlock>
+        #                 <tune_list>
+        #                     <!-- between 1 and 3 inclusive -->
+        #                     <tune no='number'>
+        #                         <seq_list>
+        #                             <seq>
+        #                                 <music_id __type="s32">music_id</music_id>
+        #                                 <seq_difficulty __type="s32">seq_difficulty</seq_difficulty>
+        #                                 <!-- flags are optional -->
+        #                                 <flags __type="str">SECRET|empty</flags>
+        #                             </seq>
+        #                         </seq_list>
+        #                     </tune>
+        #                 </tune_list>
+        #                 <flags __type="str">RISKY|empty</flags>
+        #                 <!-- requirements for normal clear -->
+        #                 <clear>
+        #                     <type __type="s32">type</type>
+        #                     <!-- between 0 and 8 inclusive -->
+        #                     <rating __type="s32">rating</rating>
+        #                     <score __type="s32">score</score>
+        #                     <ex_option>
+        #                         <is_hard __type="bool">true/false</is_hard>
+        #                         <!-- between 0 and 6 inclusive -->
+        #                         <hazard_type __type="s32">type</hazard_type>
+        #                     </ex_option>
+        #                 </clear>
+        #                 <!-- requirements for gold clear -->
+        #                 <gold>
+        #                     <type __type="s32">type</type>
+        #                     <!-- between 0 and 8 inclusive -->
+        #                     <rating __type="s32">rating</rating>
+        #                     <score __type="s32">score</score>
+        #                     <ex_option>
+        #                         <is_hard __type="bool">true/false</is_hard>
+        #                         <!-- between 0 and 6 inclusive -->
+        #                         <hazard_type __type="s32">type</hazard_type>
+        #                     </ex_option>
+        #                 </gold>
+        #             </unlock>
+        #             <serif_list>
+        #                 <!-- kind should be between 1 and 6 inclusive -->
+        #                 <serif kind='kind'>
+        #                     <line_list>
+        #                         <!-- there can be up to four of these -->
+        #                         <line __type="str">64 byte string</str>
+        #                     </line_list>
+        #                 </serif>
+        #             </serif_list>
+        #             <bgm_list>
+        #                 <!-- kind can be between 1 and 2 inclusive -->
+        #                 <bgm kind='kind' id='id' />
+        #             </bgm_list>
+        #             <se_list>
+        #                 <!-- kind can be between 1 and 20 inclusive -->
+        #                 <se kind='kind' id='id' />
+        #             </se_list>
+        #             <!-- optional node -->
+        #             <tex_number __type="s32">unknown</tex_number>
+        #         </stage>
+        #     </stage_list>
+        # </map>
+
+        expert_option = Node.void('expert_option')
+        info.add_child(expert_option)
+        expert_option.add_child(Node.bool('is_available', True))
+
+        tsumtsum = Node.void('tsumtsum')
+        info.add_child(tsumtsum)
+        tsumtsum.add_child(Node.bool('is_available', True))
+
+        nagatanien = Node.void('nagatanien')
+        info.add_child(nagatanien)
+        nagatanien.add_child(Node.bool('is_available', True))
+
+        all_music_matching = Node.void('all_music_matching')
+        info.add_child(all_music_matching)
+        all_music_matching.add_child(Node.bool('is_available', True))
+
+        question_list = Node.void('question_list')
+        info.add_child(question_list)
+
+        return info
+
+    def handle_shopinfo_regist_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('shop/name'))
+
+        shopinfo = Node.void('shopinfo')
+
+        data = Node.void('data')
+        shopinfo.add_child(data)
+        data.add_child(Node.u32('cabid', 1))
+        data.add_child(Node.string('locationid', 'nowhere'))
+        data.add_child(Node.u8('tax_phase', 1))
+
+        facility = Node.void('facility')
+        data.add_child(facility)
+        facility.add_child(Node.u32('exist', 1))
+
+        data.add_child(self.__get_global_info())
+
+        return shopinfo
+
+    def handle_recommend_get_recommend_request(self, request: Node) -> Node:
+        recommend = Node.void('recommend')
+        data = Node.void('data')
+        recommend.add_child(data)
+
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.void('music_list'))
+        # Music list should contain nodes like this (12 of them
+        # in total for a recommended list). If it isn't provided,
+        # the game will substitute a default. The order valid range
+        # is 0-11 inclusive (12 total).
+        # <music order="order">
+        #     <music_id __type="s32">id</music_id>
+        #     <seq __type="s8">chart</seq>
+        # </music>
+
+        return recommend
+
+    def handle_gametop_regist_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        refid = player.child_value('refid')
+        name = player.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        return root
+
+    def handle_gametop_get_pdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        refid = player.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_mdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+        root = self.get_scores_by_extid(extid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_info_request(self, request: Node) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        data.add_child(self.__get_global_info())
+
+        return root
+
+    def handle_gameend_final_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+
+        if player is not None:
+            refid = player.child_value('refid')
+        else:
+            refid = None
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            profile = self.get_profile(userid)
+
+            # Grab unlock progress
+            item = player.child('item')
+            if item is not None:
+                profile.replace_int_array('emblem_list', 96, item.child_value('emblem_list'))
+
+            # jbox stuff
+            jbox = player.child('jbox')
+            jboxdict = profile.get_dict('jbox')
+            if jbox is not None:
+                jboxdict.replace_int('point', jbox.child_value('point'))
+                emblemtype = jbox.child_value('emblem/type')
+                index = jbox.child_value('emblem/index')
+                if emblemtype == self.JBOX_EMBLEM_NORMAL:
+                    jboxdict.replace_int('normal_index', index)
+                elif emblemtype == self.JBOX_EMBLEM_PREMIUM:
+                    jboxdict.replace_int('premium_index', index)
+            profile.replace_dict('jbox', jboxdict)
+
+            # Born stuff
+            born = player.child('born')
+            if born is not None:
+                profile.replace_int('born_status', born.child_value('status'))
+                profile.replace_int('born_year', born.child_value('year'))
+        else:
+            profile = None
+
+        if userid is not None and profile is not None:
+            self.put_profile(userid, profile)
+
+        return Node.void('gameend')
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        # Jubeat Prop appears to allow full event overrides per-player
+        data.add_child(self.__get_global_info())
+
+        player = Node.void('player')
+        data.add_child(player)
+
+        # Some server node
+        server = Node.void('server')
+        player.add_child(server)
+
+        # Basic profile info
+        player.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+
+        # Miscelaneous crap
+        player.add_child(Node.s32('session_id', 1))
+        player.add_child(Node.u64('event_flag', 0))
+
+        # Player info and statistics
+        info = Node.void('info')
+        player.add_child(info)
+        info.add_child(Node.s16('jubility', profile.get_int('jubility')))
+        info.add_child(Node.s16('jubility_yday', profile.get_int('jubility_yday')))
+        info.add_child(Node.s32('tune_cnt', profile.get_int('tune_cnt')))
+        info.add_child(Node.s32('save_cnt', profile.get_int('save_cnt')))
+        info.add_child(Node.s32('saved_cnt', profile.get_int('saved_cnt')))
+        info.add_child(Node.s32('fc_cnt', profile.get_int('fc_cnt')))
+        info.add_child(Node.s32('ex_cnt', profile.get_int('ex_cnt')))
+        info.add_child(Node.s32('clear_cnt', profile.get_int('clear_cnt')))
+        info.add_child(Node.s32('match_cnt', profile.get_int('match_cnt')))
+        info.add_child(Node.s32('beat_cnt', profile.get_int('beat_cnt')))
+        info.add_child(Node.s32('mynews_cnt', profile.get_int('mynews_cnt')))
+        info.add_child(Node.s32('bonus_tune_points', profile.get_int('bonus_tune_points')))
+        info.add_child(Node.bool('is_bonus_tune_played', profile.get_bool('is_bonus_tune_played')))
+
+        # Looks to be set to true when there's an old profile, stops tutorial from
+        # happening on first load.
+        info.add_child(Node.bool('inherit', profile.get_bool('has_old_version')))
+
+        # Not saved, but loaded
+        info.add_child(Node.s32('mtg_entry_cnt', 123))
+        info.add_child(Node.s32('mtg_hold_cnt', 456))
+        info.add_child(Node.u8('mtg_result', 10))
+
+        # Last played data, for showing cursor and such
+        lastdict = profile.get_dict('last')
+        last = Node.void('last')
+        player.add_child(last)
+        last.add_child(Node.s64('play_time', lastdict.get_int('play_time')))
+        last.add_child(Node.string('shopname', lastdict.get_str('shopname')))
+        last.add_child(Node.string('areaname', lastdict.get_str('areaname')))
+        last.add_child(Node.s32('music_id', lastdict.get_int('music_id')))
+        last.add_child(Node.s8('seq_id', lastdict.get_int('seq_id')))
+        last.add_child(Node.s8('sort', lastdict.get_int('sort')))
+        last.add_child(Node.s8('category', lastdict.get_int('category')))
+        last.add_child(Node.s8('expert_option', lastdict.get_int('expert_option')))
+        last.add_child(Node.s32('dig_select', lastdict.get_int('dig_select')))
+
+        settings = Node.void('settings')
+        last.add_child(settings)
+        settings.add_child(Node.s8('marker', lastdict.get_int('marker')))
+        settings.add_child(Node.s8('theme', lastdict.get_int('theme')))
+        settings.add_child(Node.s16('title', lastdict.get_int('title')))
+        settings.add_child(Node.s16('parts', lastdict.get_int('parts')))
+        settings.add_child(Node.s8('rank_sort', lastdict.get_int('rank_sort')))
+        settings.add_child(Node.s8('combo_disp', lastdict.get_int('combo_disp')))
+        settings.add_child(Node.s16_array('emblem', lastdict.get_int_array('emblem', 5)))
+        settings.add_child(Node.s8('matching', lastdict.get_int('matching')))
+        settings.add_child(Node.s8('hazard', lastdict.get_int('hazard')))
+        settings.add_child(Node.s8('hard', lastdict.get_int('hard')))
+
+        # Secret unlocks
+        item = Node.void('item')
+        player.add_child(item)
+        item.add_child(Node.s32_array('music_list', profile.get_int_array('music_list', 64, [-1] * 64)))
+        item.add_child(Node.s32_array('secret_list', profile.get_int_array('secret_list', 64, [-1] * 64)))
+        item.add_child(Node.s32_array('theme_list', profile.get_int_array('theme_list', 16, [-1] * 16)))
+        item.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list', 16, [-1] * 16)))
+        item.add_child(Node.s32_array('title_list', profile.get_int_array('title_list', 160, [-1] * 160)))
+        item.add_child(Node.s32_array('parts_list', profile.get_int_array('parts_list', 160, [-1] * 160)))
+        item.add_child(Node.s32_array('emblem_list', profile.get_int_array('emblem_list', 96, [-1] * 96)))
+
+        new = Node.void('new')
+        item.add_child(new)
+        new.add_child(Node.s32_array('secret_list', profile.get_int_array('secret_list_new', 64, [-1] * 64)))
+        new.add_child(Node.s32_array('theme_list', profile.get_int_array('theme_list_new', 16, [-1] * 16)))
+        new.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list_new', 16, [-1] * 16)))
+
+        # No rival support, yet.
+        rivallist = Node.void('rivallist')
+        player.add_child(rivallist)
+        rivallist.set_attribute('count', '0')
+
+        lab_edit_seq = Node.void('lab_edit_seq')
+        player.add_child(lab_edit_seq)
+        lab_edit_seq.set_attribute('count', '0')
+
+        # Full combo challenge
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'fc_challenge')
+        if entry is None:
+            entry = ValidatedDict()
+
+        # Figure out if we've played these songs
+        start_time, end_time = self.data.local.network.get_schedule_duration('daily')
+        today_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('today', -1), timelimit=start_time)
+        whim_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('whim', -1), timelimit=start_time)
+
+        fc_challenge = Node.void('fc_challenge')
+        player.add_child(fc_challenge)
+        today = Node.void('today')
+        fc_challenge.add_child(today)
+        today.add_child(Node.s32('music_id', entry.get_int('today', -1)))
+        today.add_child(Node.u8('state', 0x40 if len(today_attempts) > 0 else 0x0))
+        whim = Node.void('whim')
+        fc_challenge.add_child(whim)
+        whim.add_child(Node.s32('music_id', entry.get_int('whim', -1)))
+        whim.add_child(Node.u8('state', 0x40 if len(whim_attempts) > 0 else 0x0))
+
+        # No news, ever.
+        news = Node.void('news')
+        player.add_child(news)
+        news.add_child(Node.s16('checked', 0))
+        news.add_child(Node.u32('checked_flag', 0))
+
+        # Sane defaults for unknown/who cares nodes
+        history = Node.void('history')
+        player.add_child(history)
+        history.set_attribute('count', '0')
+        free_first_play = Node.void('free_first_play')
+        player.add_child(free_first_play)
+        free_first_play.add_child(Node.bool('is_available', False))
+        navi = Node.void('navi')
+        player.add_child(navi)
+        navi.add_child(Node.u64('flag', profile.get_int('navi_flag')))
+
+        # Player status for events
+        event_info = Node.void('event_info')
+        player.add_child(event_info)
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for achievement in achievements:
+            if achievement.type == 'event':
+                # There are two significant bits here, 0x1 and 0x2, I think the first
+                # one is whether the event is started, second is if its finished?
+                event = Node.void('event')
+                event_info.add_child(event)
+                event.set_attribute('type', str(achievement.id))
+
+                state = 0x0
+                state = state + 0x2 if achievement.data.get_bool('is_completed') else 0x0
+                event.add_child(Node.u8('state', state))
+
+        # JBox stuff
+        jbox = Node.void('jbox')
+        jboxdict = profile.get_dict('jbox')
+        player.add_child(jbox)
+        jbox.add_child(Node.s32('point', jboxdict.get_int('point')))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        normal = Node.void('normal')
+        emblem.add_child(normal)
+        premium = Node.void('premium')
+        emblem.add_child(premium)
+        normal.add_child(Node.s16('index', jboxdict.get_int('normal_index') + 1))
+        premium.add_child(Node.s16('index', jboxdict.get_int('premium_index') + 1))
+
+        # Digdig stuff
+        digdig = Node.void('digdig')
+        digdigdict = profile.get_dict('digdig')
+        eternaldict = digdigdict.get_dict('eternal')
+        olddict = digdigdict.get_dict('old')
+        player.add_child(digdig)
+        digdig.add_child(Node.u64('flag', digdigdict.get_int('flag')))
+
+        # Emerald main stages
+        main = Node.void('main')
+        digdig.add_child(main)
+        stage = Node.void('stage')
+        main.add_child(stage)
+        stage.set_attribute('number', str(digdigdict.get_int('stage_number', 1)))
+        stage.add_child(Node.s32('point', digdigdict.get_int('point')))
+        stage.add_child(Node.s32_array('param', digdigdict.get_int_array('param', 12, [0] * 12)))
+
+        # Emerald eternal stages
+        eternal = Node.void('eternal')
+        digdig.add_child(eternal)
+        eternal.add_child(Node.s32('ratio', 1))
+        eternal.add_child(Node.s64('used_point', eternaldict.get_int('used_point')))
+        eternal.add_child(Node.s64('point', eternaldict.get_int('point')))
+        eternal.add_child(Node.s64('excavated_point', eternaldict.get_int('excavated_point')))
+        cube = Node.void('cube')
+        eternal.add_child(cube)
+        cube.add_child(Node.s8_array('state', eternaldict.get_int_array('state', 12, [0] * 12)))
+        item = Node.void('item')
+        cube.add_child(item)
+        item.add_child(Node.s32_array('kind', eternaldict.get_int_array('item_kind', 12, [0] * 12)))
+        item.add_child(Node.s32_array('value', eternaldict.get_int_array('item_value', 12, [0] * 12)))
+        norma = Node.void('norma')
+        cube.add_child(norma)
+        norma.add_child(Node.s64_array('till_time', [0] * 12))
+        norma.add_child(Node.s32_array('kind', eternaldict.get_int_array('norma_kind', 12, [0] * 12)))
+        norma.add_child(Node.s32_array('value', eternaldict.get_int_array('norma_value', 12, [0] * 12)))
+        norma.add_child(Node.s32_array('param', eternaldict.get_int_array('norma_param', 12, [0] * 12)))
+
+        if self.ENABLE_GARNET:
+            # Garnet
+            old = Node.void('old')
+            digdig.add_child(old)
+            old.add_child(Node.s32('need_point', olddict.get_int('need_point')))
+            old.add_child(Node.s32('point', olddict.get_int('point')))
+            old.add_child(Node.s32_array('excavated_point', olddict.get_int_array('excavated_point', 5, [0] * 5)))
+            old.add_child(Node.s32_array('excavated', olddict.get_int_array('excavated', 5, [0] * 5)))
+            old.add_child(Node.s32_array('param', olddict.get_int_array('param', 5, [0] * 5)))
+            # This should have a bunch of sub-nodes with the following format. Note that only
+            # the first ten nodes are saved even if more are read. Presumably this is the list
+            # of old songs we are allowing the player to unlock? Doesn't matter, we're disabling
+            # Garnet anyway.:
+            # <music>
+            #     <music_id __type="s32">id</music_id>
+            # </music>
+            old.add_child(Node.void('music_list'))
+
+        # Unlock event, turns on unlock challenge for a particular stage.
+        unlock = Node.void('unlock')
+        player.add_child(unlock)
+        main = Node.void('main')
+        unlock.add_child(main)
+        stage_list = Node.void('stage_list')
+        main.add_child(stage_list)
+        # Stage numbers are between 1 and 13 inclusive.
+        for i in range(1, 14):
+            stage_flags = self.data.local.user.get_achievement(self.game, self.version, userid, i, 'stage')
+            if stage_flags is None:
+                stage_flags = ValidatedDict()
+
+            stage = Node.void('stage')
+            stage_list.add_child(stage)
+            stage.set_attribute('number', str(i))
+            stage.add_child(Node.u8('state', stage_flags.get_int('state')))
+
+        # DigDig event for server-controlled cubes (basically anything not Garnet or Emerald)
+        generic_dig = Node.void('generic_dig')
+        player.add_child(generic_dig)
+        map_list = Node.void('map_list')
+        generic_dig.add_child(map_list)
+        # Map list consists of up to 9 of the following structures:
+        # <map id="id of map as defined in info node above">
+        #     <point __type="s32">points</point>
+        #     <used_point __type="s32">points</used_point>
+        #     <stage_num __type="s32">stage</stage_num>
+        #     <stage_list>
+        #         <stage number="number matching a stage number from info node above:"">
+        #             <norma>
+        #                 <param __type="s32">0 0 0 0 0 0 0 0 0 0 0 0</param>
+        #             </norma>
+        #             <unlock>
+        #                 <state __type="u8">0</state>
+        #             </unlock>
+        #         </stage>
+        #     </stage_list>
+        # </map>
+
+        # New Music stuff
+        new_music = Node.void('new_music')
+        player.add_child(new_music)
+
+        # Gift list, maybe from other players?
+        gift_list = Node.void('gift_list')
+        player.add_child(gift_list)
+        # If we had gifts, they look like this:
+        #     <gift reason="??" kind="??">
+        #         <id __type="s32">??</id>
+        #     </gift>
+
+        # Birthday event?
+        born = Node.void('born')
+        player.add_child(born)
+        born.add_child(Node.s8('status', profile.get_int('born_status')))
+        born.add_child(Node.s16('year', profile.get_int('born_year')))
+
+        # More crap
+        question_list = Node.void('question_list')
+        player.add_child(question_list)
+
+        return root
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('gametop')
+        datanode = Node.void('data')
+        root.add_child(datanode)
+        player = Node.void('player')
+        datanode.add_child(player)
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+        playdata = Node.void('mdata_list')
+        player.add_child(playdata)
+
+        music = ValidatedDict()
+        for score in scores:
+            data = music.get_dict(str(score.id))
+            play_cnt = data.get_int_array('play_cnt', 3)
+            clear_cnt = data.get_int_array('clear_cnt', 3)
+            clear_flags = data.get_int_array('clear_flags', 3)
+            fc_cnt = data.get_int_array('fc_cnt', 3)
+            ex_cnt = data.get_int_array('ex_cnt', 3)
+            points = data.get_int_array('points', 3)
+
+            # Replace data for this chart type
+            play_cnt[score.chart] = score.plays
+            clear_cnt[score.chart] = score.data.get_int('clear_count')
+            fc_cnt[score.chart] = score.data.get_int('full_combo_count')
+            ex_cnt[score.chart] = score.data.get_int('excellent_count')
+            points[score.chart] = score.points
+
+            # Format the clear flags
+            clear_flags[score.chart] = self.GAME_FLAG_BIT_PLAYED
+            if score.data.get_int('clear_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_CLEARED
+            if score.data.get_int('full_combo_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_FULL_COMBO
+            if score.data.get_int('excellent_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_EXCELLENT
+
+            # Save chart data back
+            data.replace_int_array('play_cnt', 3, play_cnt)
+            data.replace_int_array('clear_cnt', 3, clear_cnt)
+            data.replace_int_array('clear_flags', 3, clear_flags)
+            data.replace_int_array('fc_cnt', 3, fc_cnt)
+            data.replace_int_array('ex_cnt', 3, ex_cnt)
+            data.replace_int_array('points', 3, points)
+
+            # Update the ghost (untyped)
+            ghost = data.get('ghost', [None, None, None])
+            ghost[score.chart] = score.data.get('ghost')
+            data['ghost'] = ghost
+
+            # Save it back
+            music.replace_dict(str(score.id), data)
+
+        for scoreid in music:
+            scoredata = music[scoreid]
+            musicdata = Node.void('musicdata')
+            playdata.add_child(musicdata)
+
+            musicdata.set_attribute('music_id', scoreid)
+            musicdata.add_child(Node.s32_array('play_cnt', scoredata.get_int_array('play_cnt', 3)))
+            musicdata.add_child(Node.s32_array('clear_cnt', scoredata.get_int_array('clear_cnt', 3)))
+            musicdata.add_child(Node.s32_array('fc_cnt', scoredata.get_int_array('fc_cnt', 3)))
+            musicdata.add_child(Node.s32_array('ex_cnt', scoredata.get_int_array('ex_cnt', 3)))
+            musicdata.add_child(Node.s32_array('score', scoredata.get_int_array('points', 3)))
+            musicdata.add_child(Node.s8_array('clear', scoredata.get_int_array('clear_flags', 3)))
+
+            ghosts = scoredata.get('ghost', [None, None, None])
+            for i in range(len(ghosts)):
+                ghost = ghosts[i]
+                if ghost is None:
+                    continue
+
+                bar = Node.u8_array('bar', ghost)
+                musicdata.add_child(bar)
+                bar.set_attribute('seq', str(i))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        data = request.child('data')
+
+        # Grab system information
+        sysinfo = data.child('info')
+
+        # Grab player information
+        player = data.child('player')
+
+        # Grab result information
+        result = data.child('result')
+
+        # Grab last information. Lots of this will be filled in while grabbing scores
+        last = newprofile.get_dict('last')
+        if sysinfo is not None:
+            last.replace_int('play_time', sysinfo.child_value('time_gameend'))
+            last.replace_str('shopname', sysinfo.child_value('shopname'))
+            last.replace_str('areaname', sysinfo.child_value('areaname'))
+
+        # Grab player info for echoing back
+        info = player.child('info')
+        if info is not None:
+            newprofile.replace_int('jubility', info.child_value('jubility'))
+            newprofile.replace_int('jubility_yday', info.child_value('jubility_yday'))
+            newprofile.replace_int('tune_cnt', info.child_value('tune_cnt'))
+            newprofile.replace_int('save_cnt', info.child_value('save_cnt'))
+            newprofile.replace_int('saved_cnt', info.child_value('saved_cnt'))
+            newprofile.replace_int('fc_cnt', info.child_value('fc_cnt'))
+            newprofile.replace_int('ex_cnt', info.child_value('ex_cnt'))
+            newprofile.replace_int('clear_cnt', info.child_value('clear_cnt'))
+            newprofile.replace_int('match_cnt', info.child_value('match_cnt'))
+            newprofile.replace_int('beat_cnt', info.child_value('beat_cnt'))
+            newprofile.replace_int('mynews_cnt', info.child_value('mynews_cnt'))
+
+            newprofile.replace_int('bonus_tune_points', info.child_value('bonus_tune_points'))
+            newprofile.replace_bool('is_bonus_tune_played', info.child_value('is_bonus_tune_played'))
+
+        # Grab last settings
+        lastnode = player.child('last')
+        if lastnode is not None:
+            last.replace_int('expert_option', lastnode.child_value('expert_option'))
+            last.replace_int('dig_select', lastnode.child_value('dig_select'))
+            last.replace_int('sort', lastnode.child_value('sort'))
+            last.replace_int('category', lastnode.child_value('category'))
+
+            settings = lastnode.child('settings')
+            if settings is not None:
+                last.replace_int('matching', settings.child_value('matching'))
+                last.replace_int('hazard', settings.child_value('hazard'))
+                last.replace_int('hard', settings.child_value('hard'))
+                last.replace_int('marker', settings.child_value('marker'))
+                last.replace_int('theme', settings.child_value('theme'))
+                last.replace_int('title', settings.child_value('title'))
+                last.replace_int('parts', settings.child_value('parts'))
+                last.replace_int('rank_sort', settings.child_value('rank_sort'))
+                last.replace_int('combo_disp', settings.child_value('combo_disp'))
+                last.replace_int_array('emblem', 5, settings.child_value('emblem'))
+
+        # Grab unlock progress
+        item = player.child('item')
+        if item is not None:
+            newprofile.replace_int_array('music_list', 64, item.child_value('music_list'))
+            newprofile.replace_int_array('secret_list', 64, item.child_value('secret_list'))
+            newprofile.replace_int_array('theme_list', 16, item.child_value('theme_list'))
+            newprofile.replace_int_array('marker_list', 16, item.child_value('marker_list'))
+            newprofile.replace_int_array('title_list', 160, item.child_value('title_list'))
+            newprofile.replace_int_array('parts_list', 160, item.child_value('parts_list'))
+            newprofile.replace_int_array('emblem_list', 96, item.child_value('emblem_list'))
+
+            newitem = item.child('new')
+            if newitem is not None:
+                newprofile.replace_int_array('secret_list_new', 64, newitem.child_value('secret_list'))
+                newprofile.replace_int_array('theme_list_new', 16, newitem.child_value('theme_list'))
+                newprofile.replace_int_array('marker_list_new', 16, newitem.child_value('marker_list'))
+
+        # jbox stuff
+        jbox = player.child('jbox')
+        jboxdict = newprofile.get_dict('jbox')
+        if jbox is not None:
+            jboxdict.replace_int('point', jbox.child_value('point'))
+            emblemtype = jbox.child_value('emblem/type')
+            index = jbox.child_value('emblem/index')
+            if emblemtype == self.JBOX_EMBLEM_NORMAL:
+                jboxdict.replace_int('normal_index', index)
+            elif emblemtype == self.JBOX_EMBLEM_PREMIUM:
+                jboxdict.replace_int('premium_index', index)
+        newprofile.replace_dict('jbox', jboxdict)
+
+        # event stuff
+        event_info = player.child('event_info')
+        if event_info is not None:
+            for child in event_info.children:
+                try:
+                    eventid = int(child.attribute('type'))
+                except TypeError:
+                    # Event is empty
+                    continue
+                is_completed = child.child_value('is_completed')
+
+                # Figure out if we should update the rating/scores or not
+                oldevent = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    'event',
+                )
+
+                if oldevent is None:
+                    # Create a new event structure for this
+                    oldevent = ValidatedDict()
+
+                oldevent.replace_bool('is_completed', is_completed)
+
+                # Save it as an achievement
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventid,
+                    'event',
+                    oldevent,
+                )
+
+        # DigDig stuff
+        digdig = player.child('digdig')
+        digdigdict = newprofile.get_dict('digdig')
+        if digdig is not None:
+            digdigdict.replace_int('flag', digdig.child_value('flag'))
+
+            main = digdig.child('main')
+            if main is not None:
+                stage = main.child('stage')
+                stage_num = int(stage.attribute('number'))
+                digdigdict.replace_int('stage_number', stage_num)
+                digdigdict.replace_int('point', stage.child_value('point'))
+                digdigdict.replace_int_array('param', 12, stage.child_value('param'))
+
+                if stage.child_value('uc_available') is True:
+                    # We should enable unlock challenge for this node because the game
+                    # doesn't do it for us automatically.
+                    stage_flags = self.data.local.user.get_achievement(self.game, self.version, userid, stage_num, 'stage')
+                    if stage_flags is None:
+                        stage_flags = ValidatedDict()
+                    stage_flags.replace_int('state', stage_flags.get_int('state') | 0x2)
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        stage_num,
+                        'stage',
+                        stage_flags,
+                    )
+
+            eternal = digdig.child('eternal')
+            eternaldict = digdigdict.get_dict('eternal')
+            if eternal is not None:
+                eternaldict.replace_int('used_point', eternal.child_value('used_point'))
+                eternaldict.replace_int('point', eternal.child_value('point'))
+                eternaldict.replace_int('excavated_point', eternal.child_value('excavated_point'))
+                eternaldict.replace_int_array('state', 12, eternal.child_value('cube/state'))
+                eternaldict.replace_int_array('item_kind', 12, eternal.child_value('cube/item/kind'))
+                eternaldict.replace_int_array('item_value', 12, eternal.child_value('cube/item/value'))
+                eternaldict.replace_int_array('norma_kind', 12, eternal.child_value('cube/norma/kind'))
+                eternaldict.replace_int_array('norma_value', 12, eternal.child_value('cube/norma/value'))
+                eternaldict.replace_int_array('norma_param', 12, eternal.child_value('cube/norma/param'))
+            digdigdict.replace_dict('eternal', eternaldict)
+
+            if self.ENABLE_GARNET:
+                old = digdig.child('old')
+                olddict = digdigdict.get_dict('old')
+                if old is not None:
+                    olddict.replace_int('need_point', old.child_value('need_point'))
+                    olddict.replace_int('point', old.child_value('point'))
+                    olddict.replace_int_array('excavated_point', 5, old.child_value('excavated_point'))
+                    olddict.replace_int_array('excavated', 5, old.child_value('excavated'))
+                    olddict.replace_int_array('param', 5, old.child_value('param'))
+                digdigdict.replace_dict('old', olddict)
+
+        # DigDig unlock event
+        unlock = player.child('unlock')
+        if unlock is not None:
+            stage = unlock.child('main/stage')
+            if stage is not None:
+                stage_num = int(stage.attribute('number'))
+                state = stage.child_value('state')
+
+                # Just overwrite the state with this value
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    stage_num,
+                    'stage',
+                    {'state': state},
+                )
+
+                # If they cleared stage 13, we need to unlock eternal mode
+                if stage_num == 13 and (state & 0x18) > 0:
+                    digdigdict.replace_int('flag', digdigdict.get_int('flag') | 0x2)
+
+        # Save this back now that we've parsed everything
+        newprofile.replace_dict('digdig', digdigdict)
+
+        # Still don't know what this is for lol
+        newprofile.replace_int('navi_flag', player.child_value('navi/flag'))
+
+        # Grab scores and save those
+        if result is not None:
+            for tune in result.children:
+                if tune.name != 'tune':
+                    continue
+                result = tune.child('player')
+
+                songid = tune.child_value('music')
+                timestamp = tune.child_value('timestamp') / 1000
+                chart = int(result.child('score').attribute('seq'))
+                points = result.child_value('score')
+                flags = int(result.child('score').attribute('clear'))
+                combo = int(result.child('score').attribute('combo'))
+                ghost = result.child_value('mbar')
+
+                stats = {
+                    'perfect': result.child_value('nr_perfect'),
+                    'great': result.child_value('nr_great'),
+                    'good': result.child_value('nr_good'),
+                    'poor': result.child_value('nr_poor'),
+                    'miss': result.child_value('nr_miss'),
+                }
+
+                # Miscelaneous last data for echoing to profile get
+                last.replace_int('music_id', songid)
+                last.replace_int('seq_id', chart)
+
+                mapping = {
+                    self.GAME_FLAG_BIT_CLEARED: self.PLAY_MEDAL_CLEARED,
+                    self.GAME_FLAG_BIT_FULL_COMBO: self.PLAY_MEDAL_FULL_COMBO,
+                    self.GAME_FLAG_BIT_EXCELLENT: self.PLAY_MEDAL_EXCELLENT,
+                    self.GAME_FLAG_BIT_NEARLY_FULL_COMBO: self.PLAY_MEDAL_NEARLY_FULL_COMBO,
+                    self.GAME_FLAG_BIT_NEARLY_EXCELLENT: self.PLAY_MEDAL_NEARLY_EXCELLENT,
+                }
+
+                # Figure out the highest medal based on bits passed in
+                medal = self.PLAY_MEDAL_FAILED
+                for bit in mapping:
+                    if flags & bit > 0:
+                        medal = max(medal, mapping[bit])
+
+                self.update_score(userid, timestamp, songid, chart, points, medal, combo, ghost, stats)
+
+        # Born stuff
+        born = player.child('born')
+        if born is not None:
+            newprofile.replace_int('born_status', born.child_value('status'))
+            newprofile.replace_int('born_year', born.child_value('year'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', last)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/jubeat/saucer.py b/bemani/backend/jubeat/saucer.py
new file mode 100644
index 0000000..99c0b09
--- /dev/null
+++ b/bemani/backend/jubeat/saucer.py
@@ -0,0 +1,688 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+from typing import Any, Dict, List, Optional, Tuple
+
+from bemani.backend.base import Status
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.backend.jubeat.common import (
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+)
+from bemani.backend.jubeat.stubs import JubeatCopiousAppend
+from bemani.common import ValidatedDict, VersionConstants, Time
+from bemani.data import Data, Score, UserID
+from bemani.protocol import Node
+
+
+class JubeatSaucer(
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+    JubeatBase,
+):
+
+    name = 'Jubeat Saucer'
+    version = VersionConstants.JUBEAT_SAUCER
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatCopiousAppend(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert daily FC challenges into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'fc_challenge', 'daily'):
+            # Generate a new list of two FC challenge songs.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = set(song.id for song in data.local.music.get_all_songs(cls.game, cls.version))
+            today_song = random.sample(all_songs, 1)[0]
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'fc_challenge',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'today': today_song,
+                },
+            )
+            events.append((
+                'jubeat_fc_challenge_charts',
+                {
+                    'version': cls.version,
+                    'today': today_song,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'fc_challenge', 'daily')
+        return events
+
+    def handle_shopinfo_regist_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('shop/name'))
+
+        shopinfo = Node.void('shopinfo')
+
+        data = Node.void('data')
+        shopinfo.add_child(data)
+        data.add_child(Node.u32('cabid', 1))
+        data.add_child(Node.string('locationid', 'nowhere'))
+        data.add_child(Node.u8('is_send', 1))
+        data.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -16385, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1,
+            ],
+        ))
+        data.add_child(Node.u8('tax_phase', 1))
+
+        lab = Node.void('lab')
+        data.add_child(lab)
+        lab.add_child(Node.bool('is_open', False))
+
+        vocaloid_event = Node.void('vocaloid_event')
+        data.add_child(vocaloid_event)
+        vocaloid_event.add_child(Node.u8('state', 0))
+        vocaloid_event.add_child(Node.s32('music_id', 0))
+
+        matching_off = Node.void('matching_off')
+        data.add_child(matching_off)
+        matching_off.add_child(Node.bool('is_open', True))
+
+        return shopinfo
+
+    def handle_gametop_regist_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        passnode = player.child('pass')
+        refid = passnode.child_value('refid')
+        name = player.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        return root
+
+    def handle_gametop_get_pdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        passnode = player.child('pass')
+        refid = passnode.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_mdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+        root = self.get_scores_by_extid(extid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+
+        # Player info and statistics
+        info = Node.void('info')
+        player.add_child(info)
+        info.add_child(Node.s16('jubility', profile.get_int('jubility')))
+        info.add_child(Node.s16('jubility_yday', profile.get_int('jubility_yday')))
+        info.add_child(Node.s32('tune_cnt', profile.get_int('tune_cnt')))
+        info.add_child(Node.s32('save_cnt', profile.get_int('save_cnt')))
+        info.add_child(Node.s32('saved_cnt', profile.get_int('saved_cnt')))
+        info.add_child(Node.s32('fc_cnt', profile.get_int('fc_cnt')))
+        info.add_child(Node.s32('ex_cnt', profile.get_int('ex_cnt')))
+        info.add_child(Node.s32('pf_cnt', profile.get_int('pf_cnt')))
+        info.add_child(Node.s32('clear_cnt', profile.get_int('clear_cnt')))
+        info.add_child(Node.s32('match_cnt', profile.get_int('match_cnt')))
+        info.add_child(Node.s32('beat_cnt', profile.get_int('beat_cnt')))
+        info.add_child(Node.s32('mynews_cnt', profile.get_int('mynews_cnt')))
+        if 'total_best_score' in profile:
+            info.add_child(Node.s32('total_best_score', profile.get_int('total_best_score')))
+
+        # Looks to be set to true when there's an old profile, stops tutorial from
+        # happening on first load.
+        info.add_child(Node.bool('inherit', profile.get_bool('has_old_version')))
+
+        # Not saved, but loaded
+        info.add_child(Node.s32('mtg_entry_cnt', 123))
+        info.add_child(Node.s32('mtg_hold_cnt', 456))
+        info.add_child(Node.u8('mtg_result', 10))
+
+        # Secret unlocks
+        item = Node.void('item')
+        player.add_child(item)
+        item.add_child(Node.s32_array(
+            'secret_list',
+            profile.get_int_array(
+                'secret_list',
+                32,
+                [-1] * 32,
+            ),
+        ))
+        item.add_child(Node.s32_array(
+            'title_list',
+            profile.get_int_array(
+                'title_list',
+                96,
+                [-1] * 96,
+            ),
+        ))
+        item.add_child(Node.s16('theme_list', profile.get_int('theme_list', -1)))
+        item.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list', 2, [-1] * 2)))
+        item.add_child(Node.s32_array('parts_list', profile.get_int_array('parts_list', 96, [-1] * 96)))
+
+        new = Node.void('new')
+        item.add_child(new)
+        new.add_child(Node.s32_array(
+            'secret_list',
+            profile.get_int_array(
+                'secret_list_new',
+                32,
+                [-1] * 32,
+            ),
+        ))
+        new.add_child(Node.s32_array(
+            'title_list',
+            profile.get_int_array(
+                'title_list_new',
+                96,
+                [-1] * 96,
+            ),
+        ))
+        new.add_child(Node.s16('theme_list', profile.get_int('theme_list_new', -1)))
+        new.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list_new', 2, [-1] * 2)))
+
+        # Last played data, for showing cursor and such
+        lastdict = profile.get_dict('last')
+        last = Node.void('last')
+        player.add_child(last)
+        last.add_child(Node.s32('music_id', lastdict.get_int('music_id')))
+        last.add_child(Node.s8('marker', lastdict.get_int('marker')))
+        last.add_child(Node.s16('title', lastdict.get_int('title')))
+        last.add_child(Node.s8('theme', lastdict.get_int('theme')))
+        last.add_child(Node.s8('sort', lastdict.get_int('sort')))
+        last.add_child(Node.s8('rank_sort', lastdict.get_int('rank_sort')))
+        last.add_child(Node.s8('combo_disp', lastdict.get_int('combo_disp')))
+        last.add_child(Node.s8('seq_id', lastdict.get_int('seq_id')))
+        last.add_child(Node.s16('parts', lastdict.get_int('parts')))
+        last.add_child(Node.s8('category', lastdict.get_int('category')))
+        last.add_child(Node.s64('play_time', lastdict.get_int('play_time')))
+        last.add_child(Node.string('shopname', lastdict.get_str('shopname')))
+        last.add_child(Node.string('areaname', lastdict.get_str('areaname')))
+
+        # Miscelaneous crap
+        player.add_child(Node.s32('session_id', 1))
+
+        # Maybe hook this up? Unsure what it does, is it like IIDX dailies?
+        today_music = Node.void('today_music')
+        player.add_child(today_music)
+        today_music.add_child(Node.s32('music_id', 0))
+
+        # No news, ever.
+        news = Node.void('news')
+        player.add_child(news)
+        news.add_child(Node.s16('checked', 0))
+
+        # No rival support, yet.
+        rivallist = Node.void('rivallist')
+        player.add_child(rivallist)
+        rivallist.set_attribute('count', '0')
+        mylist = Node.void('mylist')
+        player.add_child(mylist)
+        mylist.set_attribute('count', '0')
+
+        # No collaboration support yet.
+        collabo = Node.void('collabo')
+        player.add_child(collabo)
+        collabo.add_child(Node.bool('success', False))
+        collabo.add_child(Node.bool('completed', False))
+
+        # Daily FC challenge.
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'fc_challenge')
+        if entry is None:
+            entry = ValidatedDict()
+
+        # Figure out if we've played these songs
+        start_time, end_time = self.data.local.network.get_schedule_duration('daily')
+        today_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('today', -1), timelimit=start_time)
+
+        challenge = Node.void('challenge')
+        player.add_child(challenge)
+        today = Node.void('today')
+        challenge.add_child(today)
+        today.add_child(Node.s32('music_id', entry.get_int('today', -1)))
+        today.add_child(Node.u8('state', 0x40 if len(today_attempts) > 0 else 0x0))
+        onlynow = Node.void('onlynow')
+        challenge.add_child(onlynow)
+        onlynow.add_child(Node.s32('magic_no', 0))
+        onlynow.add_child(Node.s16('cycle', 0))
+
+        # Bistro event
+        bistro = Node.void('bistro')
+        player.add_child(bistro)
+
+        # Presumably these can affect the speed of the event
+        info_1 = Node.void('info')
+        bistro.add_child(info_1)
+        info_1.add_child(Node.float('delicious_rate', 1.0))
+        info_1.add_child(Node.float('favorite_rate', 1.0))
+        bistro.add_child(Node.s32('carry_over', profile.get_int('bistro_carry_over')))
+
+        # Your chef dude, I guess?
+        chefdict = profile.get_dict('chef')
+        chef = Node.void('chef')
+        bistro.add_child(chef)
+        chef.add_child(Node.s32('id', chefdict.get_int('id', 1)))
+        chef.add_child(Node.u8('ability', chefdict.get_int('ability', 2)))
+        chef.add_child(Node.u8('remain', chefdict.get_int('remain', 30)))
+        chef.add_child(Node.u8('rate', chefdict.get_int('rate', 1)))
+
+        # Routes, similar to story mode in Pop'n I guess?
+        routes = [
+            {
+                'id': 50000284,
+                'price': 20,
+                'satisfaction': 10,
+                'favorite': True,
+            },
+            {
+                'id': 50000283,
+                'price': 20,
+                'satisfaction': 20,
+                'favorite': False,
+            },
+            {
+                'id': 50000282,
+                'price': 30,
+                'satisfaction': 10,
+                'favorite': False,
+            },
+            {
+                'id': 50000275,
+                'price': 10,
+                'satisfaction': 55,
+                'favorite': False,
+            },
+            {
+                'id': 50000274,
+                'price': 40,
+                'satisfaction': 40,
+                'favorite': False,
+            },
+            {
+                'id': 50000273,
+                'price': 80,
+                'satisfaction': 60,
+                'favorite': False,
+            },
+            {
+                'id': 50000272,
+                'price': 70,
+                'satisfaction': 60,
+                'favorite': False,
+            },
+            {
+                'id': 50000271,
+                'price': 90,
+                'satisfaction': 80,
+                'favorite': False,
+            },
+            {
+                'id': 50000270,
+                'price': 90,
+                'satisfaction': 20,
+                'favorite': False,
+            },
+        ]
+        for route_no in range(len(routes)):
+            routedata = routes[route_no]
+            route = Node.void('route')
+            bistro.add_child(route)
+            route.set_attribute('no', str(route_no))
+
+            music = Node.void('music')
+            route.add_child(music)
+            music.add_child(Node.s32('id', routedata['id']))
+            music.add_child(Node.u16('price', routedata['price']))
+            music.add_child(Node.s32('price_s32', routedata['price']))
+
+            # Look up any updated satisfaction stored by the game
+            routesaved = self.data.local.user.get_achievement(self.game, self.version, userid, route_no + 1, 'route')
+            if routesaved is None:
+                routesaved = ValidatedDict()
+            satisfaction = routesaved.get_int('satisfaction', routedata['satisfaction'])
+
+            gourmates = Node.void('gourmates')
+            route.add_child(gourmates)
+            gourmates.add_child(Node.s32('id', route_no + 1))
+            gourmates.add_child(Node.u8('favorite', 1 if routedata['favorite'] else 0))
+            gourmates.add_child(Node.u16('satisfaction', satisfaction))
+            gourmates.add_child(Node.s32('satisfaction_s32', satisfaction))
+
+        # Sane defaults for unknown nodes
+        only_now_music = Node.void('only_now_music')
+        player.add_child(only_now_music)
+        only_now_music.set_attribute('count', '0')
+        requested_music = Node.void('requested_music')
+        player.add_child(requested_music)
+        requested_music.set_attribute('count', '0')
+        kac_music = Node.void('kac_music')
+        player.add_child(kac_music)
+        kac_music.set_attribute('count', '0')
+        history = Node.void('history')
+        player.add_child(history)
+        history.set_attribute('count', '0')
+
+        # Basic profile info
+        player.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+        player.add_child(Node.string('refid', profile.get_str('refid')))
+
+        # Miscelaneous history stuff
+        data.add_child(Node.u8('termver', 16))
+        data.add_child(Node.u32('season_etime', 0))
+        data.add_child(Node.s32('bistro_last_music_id', 0))
+        data.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+            ],
+        ))
+        data.add_child(Node.s32_array(
+            'old_music_list',
+            [
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+            ],
+        ))
+        data.add_child(Node.s32_array(
+            'open_music_list',
+            [
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+            ],
+        ))
+
+        # Unsupported collaboration events with other games
+        collabo_info = Node.void('collabo_info')
+        data.add_child(collabo_info)
+
+        # Unsupported marathon stuff
+        run_run_marathon = Node.void('run_run_marathon')
+        collabo_info.add_child(run_run_marathon)
+        run_run_marathon.set_attribute('type', '1')
+        run_run_marathon.add_child(Node.u8('state', 1))
+        run_run_marathon.add_child(Node.bool('is_report_end', True))
+
+        # Unsupported policy break stuff
+        policy_break = Node.void('policy_break')
+        collabo_info.add_child(policy_break)
+        policy_break.set_attribute('type', '1')
+        policy_break.add_child(Node.u8('state', 1))
+        policy_break.add_child(Node.bool('is_report_end', False))
+
+        # Unsupported vocaloid stuff
+        vocaloid_event = Node.void('vocaloid_event')
+        collabo_info.add_child(vocaloid_event)
+        vocaloid_event.set_attribute('type', '1')
+        vocaloid_event.add_child(Node.u8('state', 0))
+        vocaloid_event.add_child(Node.s32('music_id', 0))
+
+        # No obnoxious 30 second wait to play.
+        matching_off = Node.void('matching_off')
+        data.add_child(matching_off)
+        matching_off.add_child(Node.bool('is_open', True))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        data = request.child('data')
+
+        # Grab player information
+        player = data.child('player')
+
+        # Grab last information. Lots of this will be filled in while grabbing scores
+        last = newprofile.get_dict('last')
+        last.replace_int('play_time', player.child_value('time_gameend'))
+        last.replace_str('shopname', player.child_value('shopname'))
+        last.replace_str('areaname', player.child_value('areaname'))
+
+        # Grab player info for echoing back
+        info = player.child('info')
+        if info is not None:
+            newprofile.replace_int('jubility', info.child_value('jubility'))
+            newprofile.replace_int('jubility_yday', info.child_value('jubility_yday'))
+            newprofile.replace_int('tune_cnt', info.child_value('tune_cnt'))
+            newprofile.replace_int('save_cnt', info.child_value('save_cnt'))
+            newprofile.replace_int('saved_cnt', info.child_value('saved_cnt'))
+            newprofile.replace_int('fc_cnt', info.child_value('fc_cnt'))
+            newprofile.replace_int('ex_cnt', info.child_value('exc_cnt'))  # Not a mistake, Jubeat is weird
+            newprofile.replace_int('pf_cnt', info.child_value('pf_cnt'))
+            newprofile.replace_int('clear_cnt', info.child_value('clear_cnt'))
+            newprofile.replace_int('match_cnt', info.child_value('match_cnt'))
+            newprofile.replace_int('beat_cnt', info.child_value('beat_cnt'))
+            newprofile.replace_int('total_best_score', info.child_value('total_best_score'))
+            newprofile.replace_int('mynews_cnt', info.child_value('mynews_cnt'))
+
+        # Grab unlock progress
+        item = player.child('item')
+        if item is not None:
+            newprofile.replace_int_array('secret_list', 32, item.child_value('secret_list'))
+            newprofile.replace_int_array('title_list', 96, item.child_value('title_list'))
+            newprofile.replace_int('theme_list', item.child_value('theme_list'))
+            newprofile.replace_int_array('marker_list', 2, item.child_value('marker_list'))
+            newprofile.replace_int_array('parts_list', 96, item.child_value('parts_list'))
+            newprofile.replace_int_array('secret_list_new', 32, item.child_value('secret_new'))
+            newprofile.replace_int_array('title_list_new', 96, item.child_value('title_new'))
+            newprofile.replace_int('theme_list_new', item.child_value('theme_new'))
+            newprofile.replace_int_array('marker_list_new', 2, item.child_value('marker_new'))
+
+        # Grab bistro progress
+        bistro = player.child('bistro')
+        if bistro is not None:
+            newprofile.replace_int('bistro_carry_over', bistro.child_value('carry_over'))
+
+            chefdata = newprofile.get_dict('chef')
+            chef = bistro.child('chef')
+            if chef is not None:
+                chefdata.replace_int('id', chef.child_value('id'))
+                chefdata.replace_int('ability', chef.child_value('ability'))
+                chefdata.replace_int('remain', chef.child_value('remain'))
+                chefdata.replace_int('rate', chef.child_value('rate'))
+            newprofile.replace_dict('chef', chefdata)
+
+            for route in bistro.children:
+                if route.name != 'route':
+                    continue
+
+                gourmates = route.child('gourmates')
+                routeid = gourmates.child_value('id')
+                satisfaction = gourmates.child_value('satisfaction_s32')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    routeid,
+                    'route',
+                    {
+                        'satisfaction': satisfaction,
+                    },
+                )
+
+        # Get timestamps for played songs
+        timestamps: Dict[int, int] = {}
+        history = player.child('history')
+        if history is not None:
+            for tune in history.children:
+                if tune.name != 'tune':
+                    continue
+                entry = int(tune.attribute('log_id'))
+                ts = int(tune.child_value('timestamp') / 1000)
+                timestamps[entry] = ts
+
+        # Grab scores and save those
+        result = data.child('result')
+        if result is not None:
+            for tune in result.children:
+                if tune.name != 'tune':
+                    continue
+                result = tune.child('player')
+
+                last.replace_int('marker', tune.child_value('marker'))
+                last.replace_int('title', tune.child_value('title'))
+                last.replace_int('parts', tune.child_value('parts'))
+                last.replace_int('theme', tune.child_value('theme'))
+                last.replace_int('sort', tune.child_value('sort'))
+                last.replace_int('category', tune.child_value('category'))
+                last.replace_int('rank_sort', tune.child_value('rank_sort'))
+                last.replace_int('combo_disp', tune.child_value('combo_disp'))
+
+                songid = tune.child_value('music')
+                entry = int(tune.attribute('id'))
+                timestamp = timestamps.get(entry, Time.now())
+                chart = int(result.child('score').attribute('seq'))
+                points = result.child_value('score')
+                flags = int(result.child('score').attribute('clear'))
+                combo = int(result.child('score').attribute('combo'))
+                ghost = result.child_value('mbar')
+
+                # Miscelaneous last data for echoing to profile get
+                last.replace_int('music_id', songid)
+                last.replace_int('seq_id', chart)
+
+                mapping = {
+                    self.GAME_FLAG_BIT_CLEARED: self.PLAY_MEDAL_CLEARED,
+                    self.GAME_FLAG_BIT_FULL_COMBO: self.PLAY_MEDAL_FULL_COMBO,
+                    self.GAME_FLAG_BIT_EXCELLENT: self.PLAY_MEDAL_EXCELLENT,
+                    self.GAME_FLAG_BIT_NEARLY_FULL_COMBO: self.PLAY_MEDAL_NEARLY_FULL_COMBO,
+                    self.GAME_FLAG_BIT_NEARLY_EXCELLENT: self.PLAY_MEDAL_NEARLY_EXCELLENT,
+                }
+
+                # Figure out the highest medal based on bits passed in
+                medal = self.PLAY_MEDAL_FAILED
+                for bit in mapping:
+                    if flags & bit > 0:
+                        medal = max(medal, mapping[bit])
+
+                self.update_score(userid, timestamp, songid, chart, points, medal, combo, ghost)
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', last)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('gametop')
+        datanode = Node.void('data')
+        root.add_child(datanode)
+        player = Node.void('player')
+        datanode.add_child(player)
+        playdata = Node.void('playdata')
+        player.add_child(playdata)
+        playdata.set_attribute('count', str(len(scores)))
+
+        music = ValidatedDict()
+        for score in scores:
+            data = music.get_dict(str(score.id))
+            play_cnt = data.get_int_array('play_cnt', 3)
+            clear_cnt = data.get_int_array('clear_cnt', 3)
+            clear_flags = data.get_int_array('clear_flags', 3)
+            fc_cnt = data.get_int_array('fc_cnt', 3)
+            ex_cnt = data.get_int_array('ex_cnt', 3)
+            points = data.get_int_array('points', 3)
+
+            # Replace data for this chart type
+            play_cnt[score.chart] = score.plays
+            clear_cnt[score.chart] = score.data.get_int('clear_count')
+            fc_cnt[score.chart] = score.data.get_int('full_combo_count')
+            ex_cnt[score.chart] = score.data.get_int('excellent_count')
+            points[score.chart] = score.points
+
+            # Format the clear flags
+            clear_flags[score.chart] = self.GAME_FLAG_BIT_PLAYED
+            if score.data.get_int('clear_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_CLEARED
+            if score.data.get_int('full_combo_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_FULL_COMBO
+            if score.data.get_int('excellent_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_EXCELLENT
+
+            # Save chart data back
+            data.replace_int_array('play_cnt', 3, play_cnt)
+            data.replace_int_array('clear_cnt', 3, clear_cnt)
+            data.replace_int_array('clear_flags', 3, clear_flags)
+            data.replace_int_array('fc_cnt', 3, fc_cnt)
+            data.replace_int_array('ex_cnt', 3, ex_cnt)
+            data.replace_int_array('points', 3, points)
+
+            # Update the ghost (untyped)
+            ghost = data.get('ghost', [None, None, None])
+            ghost[score.chart] = score.data.get('ghost')
+            data['ghost'] = ghost
+
+            # Save it back
+            music.replace_dict(str(score.id), data)
+
+        for scoreid in music:
+            scoredata = music[scoreid]
+            musicdata = Node.void('musicdata')
+            playdata.add_child(musicdata)
+
+            musicdata.set_attribute('music_id', scoreid)
+            musicdata.add_child(Node.s32_array('play_cnt', scoredata.get_int_array('play_cnt', 3)))
+            musicdata.add_child(Node.s32_array('clear_cnt', scoredata.get_int_array('clear_cnt', 3)))
+            musicdata.add_child(Node.s32_array('fc_cnt', scoredata.get_int_array('fc_cnt', 3)))
+            musicdata.add_child(Node.s32_array('ex_cnt', scoredata.get_int_array('ex_cnt', 3)))
+            musicdata.add_child(Node.s32_array('score', scoredata.get_int_array('points', 3)))
+            musicdata.add_child(Node.s8_array('clear', scoredata.get_int_array('clear_flags', 3)))
+
+            ghosts = scoredata.get('ghost', [None, None, None])
+            for i in range(len(ghosts)):
+                ghost = ghosts[i]
+                if ghost is None:
+                    continue
+
+                bar = Node.u8_array('bar', ghost)
+                musicdata.add_child(bar)
+                bar.set_attribute('seq', str(i))
+
+        return root
diff --git a/bemani/backend/jubeat/saucerfulfill.py b/bemani/backend/jubeat/saucerfulfill.py
new file mode 100644
index 0000000..935b07c
--- /dev/null
+++ b/bemani/backend/jubeat/saucerfulfill.py
@@ -0,0 +1,787 @@
+# vim: set fileencoding=utf-8
+import copy
+import random
+from typing import Any, Dict, List, Optional, Tuple
+
+from bemani.backend.base import Status
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.backend.jubeat.common import (
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+)
+from bemani.backend.jubeat.course import JubeatCourse
+from bemani.backend.jubeat.saucer import JubeatSaucer
+from bemani.common import ValidatedDict, VersionConstants, Time
+from bemani.data import Data, Score, UserID
+from bemani.protocol import Node
+
+
+class JubeatSaucerFulfill(
+    JubeatDemodataGetHitchartHandler,
+    JubeatDemodataGetNewsHandler,
+    JubeatGamendRegisterHandler,
+    JubeatGametopGetMeetingHandler,
+    JubeatLobbyCheckHandler,
+    JubeatLoggerReportHandler,
+    JubeatCourse,
+    JubeatBase,
+):
+
+    name = 'Jubeat Saucer Fulfill'
+    version = VersionConstants.JUBEAT_SAUCER_FULFILL
+
+    GAME_COURSE_REQUIREMENT_SCORE = 1
+    GAME_COURSE_REQUIREMENT_FULL_COMBO = 2
+    GAME_COURSE_REQUIREMENT_PERFECT_PERCENT = 3
+
+    GAME_COURSE_RATING_FAILED = 1
+    GAME_COURSE_RATING_BRONZE = 2
+    GAME_COURSE_RATING_SILVER = 3
+    GAME_COURSE_RATING_GOLD = 4
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatSaucer(self.data, self.config, self.model)
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Insert daily FC challenges into the DB.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'fc_challenge', 'daily'):
+            # Generate a new list of two FC challenge songs.
+            start_time, end_time = data.local.network.get_schedule_duration('daily')
+            all_songs = set(song.id for song in data.local.music.get_all_songs(cls.game, cls.version))
+            daily_songs = random.sample(all_songs, 2)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'fc_challenge',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            )
+            events.append((
+                'jubeat_fc_challenge_charts',
+                {
+                    'version': cls.version,
+                    'today': daily_songs[0],
+                    'whim': daily_songs[1],
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'fc_challenge', 'daily')
+        return events
+
+    def handle_shopinfo_regist_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('shop/name'))
+
+        shopinfo = Node.void('shopinfo')
+
+        data = Node.void('data')
+        shopinfo.add_child(data)
+        data.add_child(Node.u32('cabid', 1))
+        data.add_child(Node.string('locationid', 'nowhere'))
+        data.add_child(Node.u8('is_send', 1))
+        data.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+                -1, -1, -1, -1,
+            ],
+        ))
+        data.add_child(Node.u8('tax_phase', 1))
+
+        lab = Node.void('lab')
+        data.add_child(lab)
+        lab.add_child(Node.bool('is_open', False))
+
+        vocaloid_event = Node.void('vocaloid_event')
+        data.add_child(vocaloid_event)
+        vocaloid_event.add_child(Node.u8('state', 0))
+        vocaloid_event.add_child(Node.s32('music_id', 0))
+
+        vocaloid_event2 = Node.void('vocaloid_event2')
+        data.add_child(vocaloid_event2)
+        vocaloid_event2.add_child(Node.u8('state', 0))
+        vocaloid_event2.add_child(Node.s32('music_id', 0))
+
+        # No obnoxious 30 second wait to play.
+        matching_off = Node.void('matching_off')
+        data.add_child(matching_off)
+        matching_off.add_child(Node.bool('is_open', True))
+
+        tenka = Node.void('tenka')
+        data.add_child(tenka)
+        tenka.add_child(Node.bool('is_participant', False))
+
+        return shopinfo
+
+    def handle_gametop_get_course_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+
+        gametop = Node.void('gametop')
+        data = Node.void('data')
+        gametop.add_child(data)
+
+        # Course list available
+        course_list = Node.void('course_list')
+        data.add_child(course_list)
+
+        validcourses: List[int] = []
+        for course in self.get_all_courses():
+            coursenode = Node.void('course')
+            course_list.add_child(coursenode)
+
+            # Basic course info
+            if course['id'] in validcourses:
+                raise Exception('Cannot have same course ID specified twice!')
+            validcourses.append(course['id'])
+            coursenode.add_child(Node.s32('id', course['id']))
+            coursenode.add_child(Node.string('name', course['name']))
+            coursenode.add_child(Node.u8('level', course['level']))
+
+            # Translate internal to game
+            def translate_req(internal_req: int) -> int:
+                return {
+                    self.COURSE_REQUIREMENT_SCORE: self.GAME_COURSE_REQUIREMENT_SCORE,
+                    self.COURSE_REQUIREMENT_FULL_COMBO: self.GAME_COURSE_REQUIREMENT_FULL_COMBO,
+                    self.COURSE_REQUIREMENT_PERFECT_PERCENT: self.GAME_COURSE_REQUIREMENT_PERFECT_PERCENT,
+                }.get(internal_req, 0)
+
+            # Course bronze/silver/gold rules
+            ids = [0] * 3
+            bronze_values = [0] * 3
+            silver_values = [0] * 3
+            gold_values = [0] * 3
+            slot = 0
+            for req in course['requirements']:
+                req_values = course['requirements'][req]
+
+                ids[slot] = translate_req(req)
+                bronze_values[slot] = req_values[0]
+                silver_values[slot] = req_values[1]
+                gold_values[slot] = req_values[2]
+                slot = slot + 1
+
+            norma = Node.void('norma')
+            coursenode.add_child(norma)
+            norma.add_child(Node.s32_array('norma_id', ids))
+            norma.add_child(Node.s32_array('bronze_value', bronze_values))
+            norma.add_child(Node.s32_array('silver_value', silver_values))
+            norma.add_child(Node.s32_array('gold_value', gold_values))
+
+            # Music list for course
+            music_index = 0
+            music_list = Node.void('music_list')
+            coursenode.add_child(music_list)
+
+            for entry in course['music']:
+                music = Node.void('music')
+                music.set_attribute('index', str(music_index))
+                music_list.add_child(music)
+                music.add_child(Node.s32('music_id', entry[0]))
+                music.add_child(Node.u8('seq', entry[1]))
+                music_index = music_index + 1
+
+        # Look up profile so we can load the last course played
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            profile = ValidatedDict()
+
+        # Player scores for courses
+        player_list = Node.void('player_list')
+        data.add_child(player_list)
+        player = Node.void('player')
+        player_list.add_child(player)
+        player.add_child(Node.s32('jid', extid))
+
+        result_list = Node.void('result_list')
+        player.add_child(result_list)
+        playercourses = self.get_courses(userid)
+        for courseid in playercourses:
+            if courseid not in validcourses:
+                continue
+
+            rating = {
+                self.COURSE_RATING_FAILED: self.GAME_COURSE_RATING_FAILED,
+                self.COURSE_RATING_BRONZE: self.GAME_COURSE_RATING_BRONZE,
+                self.COURSE_RATING_SILVER: self.GAME_COURSE_RATING_SILVER,
+                self.COURSE_RATING_GOLD: self.GAME_COURSE_RATING_GOLD,
+            }[playercourses[courseid]['rating']]
+            scores = playercourses[courseid]['scores']
+
+            result = Node.void('result')
+            result_list.add_child(result)
+            result.add_child(Node.s32('id', courseid))
+            result.add_child(Node.u8('rating', rating))
+            result.add_child(Node.s32_array('score', scores))
+
+        # Last course ID
+        last_course_id = Node.s32('last_course_id', profile.get_dict('last').get_int('last_course_id', -1))
+        data.add_child(last_course_id)
+
+        return gametop
+
+    def handle_gametop_regist_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        passnode = player.child('pass')
+        refid = passnode.child_value('refid')
+        name = player.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        return root
+
+    def handle_gametop_get_pdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        passnode = player.child('pass')
+        refid = passnode.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def handle_gametop_get_mdata_request(self, request: Node) -> Node:
+        data = request.child('data')
+        player = data.child('player')
+        extid = player.child_value('jid')
+        root = self.get_scores_by_extid(extid)
+        if root is None:
+            root = Node.void('gametop')
+            root.set_attribute('status', str(Status.NO_PROFILE))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('gametop')
+        data = Node.void('data')
+        root.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+
+        # Player info and statistics
+        info = Node.void('info')
+        player.add_child(info)
+        info.add_child(Node.s16('jubility', profile.get_int('jubility')))
+        info.add_child(Node.s16('jubility_yday', profile.get_int('jubility_yday')))
+        info.add_child(Node.s32('tune_cnt', profile.get_int('tune_cnt')))
+        info.add_child(Node.s32('save_cnt', profile.get_int('save_cnt')))
+        info.add_child(Node.s32('saved_cnt', profile.get_int('saved_cnt')))
+        info.add_child(Node.s32('fc_cnt', profile.get_int('fc_cnt')))
+        info.add_child(Node.s32('ex_cnt', profile.get_int('ex_cnt')))
+        info.add_child(Node.s32('pf_cnt', profile.get_int('pf_cnt')))
+        info.add_child(Node.s32('clear_cnt', profile.get_int('clear_cnt')))
+        info.add_child(Node.s32('match_cnt', profile.get_int('match_cnt')))
+        info.add_child(Node.s32('beat_cnt', profile.get_int('beat_cnt')))
+        info.add_child(Node.s32('mynews_cnt', profile.get_int('mynews_cnt')))
+        info.add_child(Node.s32('extra_point', profile.get_int('extra_point')))
+        info.add_child(Node.bool('is_extra_played', profile.get_bool('is_extra_played')))
+        if 'total_best_score' in profile:
+            info.add_child(Node.s32('total_best_score', profile.get_int('total_best_score')))
+
+        # Looks to be set to true when there's an old profile, stops tutorial from
+        # happening on first load.
+        info.add_child(Node.bool('inherit', profile.get_bool('has_old_version')))
+
+        # Not saved, but loaded
+        info.add_child(Node.s32('mtg_entry_cnt', 123))
+        info.add_child(Node.s32('mtg_hold_cnt', 456))
+        info.add_child(Node.u8('mtg_result', 10))
+
+        # First play stuff we don't support
+        free_first_play = Node.void('free_first_play')
+        player.add_child(free_first_play)
+        free_first_play.add_child(Node.bool('is_available', False))
+        free_first_play.add_child(Node.s32('point', 0))
+        free_first_play.add_child(Node.s32('point_used', 0))
+
+        # Secret unlocks
+        item = Node.void('item')
+        player.add_child(item)
+        item.add_child(Node.s32_array(
+            'secret_list',
+            profile.get_int_array(
+                'secret_list',
+                32,
+                [-1] * 32,
+            ),
+        ))
+        item.add_child(Node.s32_array(
+            'title_list',
+            profile.get_int_array(
+                'title_list',
+                96,
+                [-1] * 96,
+            ),
+        ))
+        item.add_child(Node.s16('theme_list', profile.get_int('theme_list', -1)))
+        item.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list', 2, [-1] * 2)))
+        item.add_child(Node.s32_array('parts_list', profile.get_int_array('parts_list', 96, [-1] * 96)))
+
+        new = Node.void('new')
+        item.add_child(new)
+        new.add_child(Node.s32_array(
+            'secret_list',
+            profile.get_int_array(
+                'secret_list_new',
+                32,
+                [-1] * 32,
+            ),
+        ))
+        new.add_child(Node.s32_array(
+            'title_list',
+            profile.get_int_array(
+                'title_list_new',
+                96,
+                [-1] * 96,
+            ),
+        ))
+        new.add_child(Node.s16('theme_list', profile.get_int('theme_list_new', -1)))
+        new.add_child(Node.s32_array('marker_list', profile.get_int_array('marker_list_new', 2, [-1] * 2)))
+
+        # Last played data, for showing cursor and such
+        lastdict = profile.get_dict('last')
+        last = Node.void('last')
+        player.add_child(last)
+        last.add_child(Node.s32('music_id', lastdict.get_int('music_id')))
+        last.add_child(Node.s8('marker', lastdict.get_int('marker')))
+        last.add_child(Node.s16('title', lastdict.get_int('title')))
+        last.add_child(Node.s8('theme', lastdict.get_int('theme')))
+        last.add_child(Node.s8('sort', lastdict.get_int('sort')))
+        last.add_child(Node.s8('rank_sort', lastdict.get_int('rank_sort')))
+        last.add_child(Node.s8('combo_disp', lastdict.get_int('combo_disp')))
+        last.add_child(Node.s8('seq_id', lastdict.get_int('seq_id')))
+        last.add_child(Node.s16('parts', lastdict.get_int('parts')))
+        last.add_child(Node.s8('category', lastdict.get_int('category')))
+        last.add_child(Node.s64('play_time', lastdict.get_int('play_time')))
+        last.add_child(Node.string('shopname', lastdict.get_str('shopname')))
+        last.add_child(Node.string('areaname', lastdict.get_str('areaname')))
+        last.add_child(Node.s8('expert_option', lastdict.get_int('expert_option')))
+        last.add_child(Node.s8('matching', lastdict.get_int('matching')))
+        last.add_child(Node.s8('hazard', lastdict.get_int('hazard')))
+        last.add_child(Node.s8('hard', lastdict.get_int('hard')))
+
+        # Miscelaneous crap
+        player.add_child(Node.s32('session_id', 1))
+        player.add_child(Node.u64('event_flag', 0))
+
+        # Macchiato event
+        macchiatodict = profile.get_dict('macchiato')
+        macchiato = Node.void('macchiato')
+        player.add_child(macchiato)
+        macchiato.add_child(Node.s32('pack_id', macchiatodict.get_int('pack_id')))
+        macchiato.add_child(Node.u16('bean_num', macchiatodict.get_int('bean_num')))
+        macchiato.add_child(Node.s32('daily_milk_num', macchiatodict.get_int('daily_milk_num')))
+        macchiato.add_child(Node.bool('is_received_daily_milk', macchiatodict.get_bool('is_received_daily_milk')))
+        macchiato.add_child(Node.s32('today_tune_cnt', macchiatodict.get_int('today_tune_cnt')))
+        macchiato.add_child(Node.s32_array(
+            'daily_milk_bonus',
+            macchiatodict.get_int_array('daily_milk_bonus', 9, [-1, -1, -1, -1, -1, -1, -1, -1, -1]),
+        ))
+        macchiato.add_child(Node.s32('daily_play_burst', macchiatodict.get_int('daily_play_burst')))
+        macchiato.add_child(Node.bool('sub_menu_is_completed', macchiatodict.get_bool('sub_menu_is_completed')))
+        macchiato.add_child(Node.s32('compensation_milk', macchiatodict.get_int('compensation_milk')))
+        macchiato.add_child(Node.s32('match_cnt', macchiatodict.get_int('match_cnt')))
+
+        # Probably never will support this
+        macchiato_music_list = Node.void('macchiato_music_list')
+        macchiato.add_child(macchiato_music_list)
+        macchiato_music_list.set_attribute('count', '0')
+
+        # Same with this comment
+        macchiato.add_child(Node.s32('sub_pack_id', 0))
+        sub_macchiato_music_list = Node.void('sub_macchiato_music_list')
+        macchiato.add_child(sub_macchiato_music_list)
+        sub_macchiato_music_list.set_attribute('count', '0')
+
+        # And this
+        season_music_list = Node.void('season_music_list')
+        macchiato.add_child(season_music_list)
+        season_music_list.set_attribute('count', '0')
+
+        # Weird, this is sent as a void with a bunch of subnodes, but returned as an int array.
+        achievement_list = Node.void('achievement_list')
+        macchiato.add_child(achievement_list)
+        achievement_list.set_attribute('count', '0')
+
+        # Also probably never supporting this either
+        cow_list = Node.void('cow_list')
+        macchiato.add_child(cow_list)
+        cow_list.set_attribute('count', '0')
+
+        # No news, ever.
+        news = Node.void('news')
+        player.add_child(news)
+        news.add_child(Node.s16('checked', 0))
+
+        # No rival support, yet.
+        rivallist = Node.void('rivallist')
+        player.add_child(rivallist)
+        rivallist.set_attribute('count', '0')
+
+        # Full combo daily challenge.
+        entry = self.data.local.game.get_time_sensitive_settings(self.game, self.version, 'fc_challenge')
+        if entry is None:
+            entry = ValidatedDict()
+
+        # Figure out if we've played these songs
+        start_time, end_time = self.data.local.network.get_schedule_duration('daily')
+        today_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('today', -1), timelimit=start_time)
+        whim_attempts = self.data.local.music.get_all_attempts(self.game, self.version, userid, entry.get_int('whim', -1), timelimit=start_time)
+
+        challenge = Node.void('challenge')
+        player.add_child(challenge)
+        today = Node.void('today')
+        challenge.add_child(today)
+        today.add_child(Node.s32('music_id', entry.get_int('today', -1)))
+        today.add_child(Node.u8('state', 0x40 if len(today_attempts) > 0 else 0x0))
+        whim = Node.void('whim')
+        challenge.add_child(whim)
+        whim.add_child(Node.s32('music_id', entry.get_int('whim', -1)))
+        whim.add_child(Node.u8('state', 0x40 if len(whim_attempts) > 0 else 0x0))
+
+        # Sane defaults for unknown nodes
+        only_now_music = Node.void('only_now_music')
+        player.add_child(only_now_music)
+        only_now_music.set_attribute('count', '0')
+        lab_edit_seq = Node.void('lab_edit_seq')
+        player.add_child(lab_edit_seq)
+        lab_edit_seq.set_attribute('count', '0')
+        kac_music = Node.void('kac_music')
+        player.add_child(kac_music)
+        kac_music.set_attribute('count', '0')
+        history = Node.void('history')
+        player.add_child(history)
+        history.set_attribute('count', '0')
+        share_music = Node.void('share_music')
+        player.add_child(share_music)
+        share_music.set_attribute('count', '0')
+        bonus_music = Node.void('bonus_music')
+        player.add_child(bonus_music)
+        bonus_music.set_attribute('count', '0')
+
+        bingo = Node.void('bingo')
+        player.add_child(bingo)
+        reward = Node.void('reward')
+        bingo.add_child(reward)
+        reward.add_child(Node.s32('total', 0))
+        reward.add_child(Node.s32('point', 0))
+        group = Node.void('group')
+        player.add_child(group)
+        group.add_child(Node.s32('group_id', 0))
+
+        # Basic profile info
+        player.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        player.add_child(Node.s32('jid', profile.get_int('extid')))
+        player.add_child(Node.string('refid', profile.get_str('refid')))
+
+        # Miscelaneous history stuff
+        data.add_child(Node.u8('termver', 16))
+        data.add_child(Node.u32('season_etime', 0))
+        data.add_child(Node.s32_array(
+            'white_music_list',
+            [
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+            ],
+        ))
+        data.add_child(Node.s32_array(
+            'open_music_list',
+            [
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+                -1, -1, -1, -1, -1, -1, -1, -1,
+            ],
+        ))
+
+        # Unsupported collaboration events with other games
+        collabo_info = Node.void('collabo_info')
+        data.add_child(collabo_info)
+
+        # Unsupported policy break stuff
+        policy_break = Node.void('policy_break')
+        collabo_info.add_child(policy_break)
+        policy_break.set_attribute('type', '1')
+        policy_break.add_child(Node.u8('state', 1))
+        policy_break.add_child(Node.bool('is_report_end', False))
+
+        # Unsupported vocaloid stuff
+        vocaloid_event = Node.void('vocaloid_event')
+        collabo_info.add_child(vocaloid_event)
+        vocaloid_event.set_attribute('type', '1')
+        vocaloid_event.add_child(Node.u8('state', 0))
+        vocaloid_event.add_child(Node.s32('music_id', 0))
+
+        # Unsupported vocaloid stuff
+        vocaloid_event2 = Node.void('vocaloid_event2')
+        collabo_info.add_child(vocaloid_event2)
+        vocaloid_event2.set_attribute('type', '1')
+        vocaloid_event2.add_child(Node.u8('state', 0))
+        vocaloid_event2.add_child(Node.s32('music_id', 0))
+
+        # Maybe it is possible to turn off internet matching here?
+        lab = Node.void('lab')
+        data.add_child(lab)
+        lab.add_child(Node.bool('is_open', False))
+        matching_off = Node.void('matching_off')
+        data.add_child(matching_off)
+        matching_off.add_child(Node.bool('is_open', True))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        data = request.child('data')
+
+        # Grab player information
+        player = data.child('player')
+
+        # Grab last information. Lots of this will be filled in while grabbing scores
+        last = newprofile.get_dict('last')
+        last.replace_int('play_time', player.child_value('time_gameend'))
+        last.replace_str('shopname', player.child_value('shopname'))
+        last.replace_str('areaname', player.child_value('areaname'))
+
+        # Grab player info for echoing back
+        info = player.child('info')
+        if info is not None:
+            newprofile.replace_int('jubility', info.child_value('jubility'))
+            newprofile.replace_int('jubility_yday', info.child_value('jubility_yday'))
+            newprofile.replace_int('tune_cnt', info.child_value('tune_cnt'))
+            newprofile.replace_int('save_cnt', info.child_value('save_cnt'))
+            newprofile.replace_int('saved_cnt', info.child_value('saved_cnt'))
+            newprofile.replace_int('fc_cnt', info.child_value('fc_cnt'))
+            newprofile.replace_int('ex_cnt', info.child_value('exc_cnt'))  # Not a mistake, Jubeat is weird
+            newprofile.replace_int('pf_cnt', info.child_value('pf_cnt'))
+            newprofile.replace_int('clear_cnt', info.child_value('clear_cnt'))
+            newprofile.replace_int('match_cnt', info.child_value('match_cnt'))
+            newprofile.replace_int('beat_cnt', info.child_value('beat_cnt'))
+            newprofile.replace_int('total_best_score', info.child_value('total_best_score'))
+            newprofile.replace_int('mynews_cnt', info.child_value('mynews_cnt'))
+            newprofile.replace_int('extra_point', info.child_value('extra_point'))
+            newprofile.replace_bool('is_extra_played', info.child_value('is_extra_played'))
+
+            last.replace_int('expert_option', info.child_value('expert_option'))
+            last.replace_int('matching', info.child_value('matching'))
+            last.replace_int('hazard', info.child_value('hazard'))
+            last.replace_int('hard', info.child_value('hard'))
+
+        # Grab unlock progress
+        item = player.child('item')
+        if item is not None:
+            newprofile.replace_int_array('secret_list', 32, item.child_value('secret_list'))
+            newprofile.replace_int_array('title_list', 96, item.child_value('title_list'))
+            newprofile.replace_int('theme_list', item.child_value('theme_list'))
+            newprofile.replace_int_array('marker_list', 2, item.child_value('marker_list'))
+            newprofile.replace_int_array('parts_list', 96, item.child_value('parts_list'))
+            newprofile.replace_int_array('secret_list_new', 32, item.child_value('secret_new'))
+            newprofile.replace_int_array('title_list_new', 96, item.child_value('title_new'))
+            newprofile.replace_int('theme_list_new', item.child_value('theme_new'))
+            newprofile.replace_int_array('marker_list_new', 2, item.child_value('marker_new'))
+
+        # Grab macchiato event
+        macchiatodict = newprofile.get_dict('macchiato')
+        macchiato = player.child('macchiato')
+        if macchiato is not None:
+            macchiatodict.replace_int('pack_id', macchiato.child_value('pack_id'))
+            macchiatodict.replace_int('bean_num', macchiato.child_value('bean_num'))
+            macchiatodict.replace_int('daily_milk_num', macchiato.child_value('daily_milk_num'))
+            macchiatodict.replace_bool('is_received_daily_milk', macchiato.child_value('is_received_daily_milk'))
+            macchiatodict.replace_bool('sub_menu_is_completed', macchiato.child_value('sub_menu_is_completed'))
+            macchiatodict.replace_int('today_tune_cnt', macchiato.child_value('today_tune_cnt'))
+            macchiatodict.replace_int_array('daily_milk_bonus', 9, macchiato.child_value('daily_milk_bonus'))
+            macchiatodict.replace_int('compensation_milk', macchiato.child_value('compensation_milk'))
+            macchiatodict.replace_int('match_cnt', macchiato.child_value('match_cnt'))
+            macchiatodict.replace_int('used_bean', macchiato.child_value('used_bean'))
+            macchiatodict.replace_int('used_milk', macchiato.child_value('used_milk'))
+            macchiatodict.replace_int('daily_play_burst', macchiato.child_value('daily_play_burst'))
+        newprofile.replace_dict('macchiato', macchiatodict)
+
+        # Get timestamps for played songs
+        timestamps: Dict[int, int] = {}
+        history = player.child('history')
+        if history is not None:
+            for tune in history.children:
+                if tune.name != 'tune':
+                    continue
+                entry = int(tune.attribute('log_id'))
+                ts = int(tune.child_value('timestamp') / 1000)
+                timestamps[entry] = ts
+
+        # Grab scores and save those
+        result = data.child('result')
+        if result is not None:
+            for tune in result.children:
+                if tune.name != 'tune':
+                    continue
+                result = tune.child('player')
+
+                last.replace_int('marker', tune.child_value('marker'))
+                last.replace_int('title', tune.child_value('title'))
+                last.replace_int('parts', tune.child_value('parts'))
+                last.replace_int('theme', tune.child_value('theme'))
+                last.replace_int('sort', tune.child_value('sort'))
+                last.replace_int('category', tune.child_value('category'))
+                last.replace_int('rank_sort', tune.child_value('rank_sort'))
+                last.replace_int('combo_disp', tune.child_value('combo_disp'))
+
+                songid = tune.child_value('music')
+                entry = int(tune.attribute('id'))
+                timestamp = timestamps.get(entry, Time.now())
+                chart = int(result.child('score').attribute('seq'))
+                points = result.child_value('score')
+                flags = int(result.child('score').attribute('clear'))
+                combo = int(result.child('score').attribute('combo'))
+                ghost = result.child_value('mbar')
+
+                # Miscelaneous last data for echoing to profile get
+                last.replace_int('music_id', songid)
+                last.replace_int('seq_id', chart)
+
+                mapping = {
+                    self.GAME_FLAG_BIT_CLEARED: self.PLAY_MEDAL_CLEARED,
+                    self.GAME_FLAG_BIT_FULL_COMBO: self.PLAY_MEDAL_FULL_COMBO,
+                    self.GAME_FLAG_BIT_EXCELLENT: self.PLAY_MEDAL_EXCELLENT,
+                    self.GAME_FLAG_BIT_NEARLY_FULL_COMBO: self.PLAY_MEDAL_NEARLY_FULL_COMBO,
+                    self.GAME_FLAG_BIT_NEARLY_EXCELLENT: self.PLAY_MEDAL_NEARLY_EXCELLENT,
+                }
+
+                # Figure out the highest medal based on bits passed in
+                medal = self.PLAY_MEDAL_FAILED
+                for bit in mapping:
+                    if flags & bit > 0:
+                        medal = max(medal, mapping[bit])
+
+                self.update_score(userid, timestamp, songid, chart, points, medal, combo, ghost)
+
+        # Grab the course results as well
+        course = data.child('course')
+        if course is not None:
+            courseid = course.child_value('course_id')
+            rating = {
+                self.GAME_COURSE_RATING_FAILED: self.COURSE_RATING_FAILED,
+                self.GAME_COURSE_RATING_BRONZE: self.COURSE_RATING_BRONZE,
+                self.GAME_COURSE_RATING_SILVER: self.COURSE_RATING_SILVER,
+                self.GAME_COURSE_RATING_GOLD: self.COURSE_RATING_GOLD,
+            }[course.child_value('rating')]
+            scores = [0] * 5
+            for music in course.children:
+                if music.name != 'music':
+                    continue
+                index = int(music.attribute('index'))
+                scores[index] = music.child_value('score')
+
+            # Save course itself
+            self.save_course(userid, courseid, rating, scores)
+
+            # Save the last course ID
+            last.replace_int('last_course_id', courseid)
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', last)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
+
+    def format_scores(self, userid: UserID, profile: ValidatedDict, scores: List[Score]) -> Node:
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('gametop')
+        datanode = Node.void('data')
+        root.add_child(datanode)
+        player = Node.void('player')
+        datanode.add_child(player)
+        playdata = Node.void('playdata')
+        player.add_child(playdata)
+        playdata.set_attribute('count', str(len(scores)))
+
+        music = ValidatedDict()
+        for score in scores:
+            data = music.get_dict(str(score.id))
+            play_cnt = data.get_int_array('play_cnt', 3)
+            clear_cnt = data.get_int_array('clear_cnt', 3)
+            clear_flags = data.get_int_array('clear_flags', 3)
+            fc_cnt = data.get_int_array('fc_cnt', 3)
+            ex_cnt = data.get_int_array('ex_cnt', 3)
+            points = data.get_int_array('points', 3)
+
+            # Replace data for this chart type
+            play_cnt[score.chart] = score.plays
+            clear_cnt[score.chart] = score.data.get_int('clear_count')
+            fc_cnt[score.chart] = score.data.get_int('full_combo_count')
+            ex_cnt[score.chart] = score.data.get_int('excellent_count')
+            points[score.chart] = score.points
+
+            # Format the clear flags
+            clear_flags[score.chart] = self.GAME_FLAG_BIT_PLAYED
+            if score.data.get_int('clear_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_CLEARED
+            if score.data.get_int('full_combo_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_FULL_COMBO
+            if score.data.get_int('excellent_count') > 0:
+                clear_flags[score.chart] |= self.GAME_FLAG_BIT_EXCELLENT
+
+            # Save chart data back
+            data.replace_int_array('play_cnt', 3, play_cnt)
+            data.replace_int_array('clear_cnt', 3, clear_cnt)
+            data.replace_int_array('clear_flags', 3, clear_flags)
+            data.replace_int_array('fc_cnt', 3, fc_cnt)
+            data.replace_int_array('ex_cnt', 3, ex_cnt)
+            data.replace_int_array('points', 3, points)
+
+            # Update the ghost (untyped)
+            ghost = data.get('ghost', [None, None, None])
+            ghost[score.chart] = score.data.get('ghost')
+            data['ghost'] = ghost
+
+            # Save it back
+            music.replace_dict(str(score.id), data)
+
+        for scoreid in music:
+            scoredata = music[scoreid]
+            musicdata = Node.void('musicdata')
+            playdata.add_child(musicdata)
+
+            musicdata.set_attribute('music_id', scoreid)
+            musicdata.add_child(Node.s32_array('play_cnt', scoredata.get_int_array('play_cnt', 3)))
+            musicdata.add_child(Node.s32_array('clear_cnt', scoredata.get_int_array('clear_cnt', 3)))
+            musicdata.add_child(Node.s32_array('fc_cnt', scoredata.get_int_array('fc_cnt', 3)))
+            musicdata.add_child(Node.s32_array('ex_cnt', scoredata.get_int_array('ex_cnt', 3)))
+            musicdata.add_child(Node.s32_array('score', scoredata.get_int_array('points', 3)))
+            musicdata.add_child(Node.s8_array('clear', scoredata.get_int_array('clear_flags', 3)))
+
+            ghosts = scoredata.get('ghost', [None, None, None])
+            for i in range(len(ghosts)):
+                ghost = ghosts[i]
+                if ghost is None:
+                    continue
+
+                bar = Node.u8_array('bar', ghost)
+                musicdata.add_child(bar)
+                bar.set_attribute('seq', str(i))
+
+        return root
diff --git a/bemani/backend/jubeat/stubs.py b/bemani/backend/jubeat/stubs.py
new file mode 100644
index 0000000..e3a67bc
--- /dev/null
+++ b/bemani/backend/jubeat/stubs.py
@@ -0,0 +1,65 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.jubeat.base import JubeatBase
+from bemani.common import VersionConstants
+
+
+class Jubeat(JubeatBase):
+
+    name = 'Jubeat'
+    version = VersionConstants.JUBEAT
+
+
+class JubeatRipples(JubeatBase):
+
+    name = 'Jubeat Ripples'
+    version = VersionConstants.JUBEAT_RIPPLES
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return Jubeat(self.data, self.config, self.model)
+
+
+class JubeatRipplesAppend(JubeatBase):
+
+    name = 'Jubeat Ripples Append'
+    version = VersionConstants.JUBEAT_RIPPLES_APPEND
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatRipples(self.data, self.config, self.model)
+
+
+class JubeatKnit(JubeatBase):
+
+    name = 'Jubeat Knit'
+    version = VersionConstants.JUBEAT_KNIT
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatRipplesAppend(self.data, self.config, self.model)
+
+
+class JubeatKnitAppend(JubeatBase):
+
+    name = 'Jubeat Knit Append'
+    version = VersionConstants.JUBEAT_KNIT_APPEND
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatKnit(self.data, self.config, self.model)
+
+
+class JubeatCopious(JubeatBase):
+
+    name = 'Jubeat Copious'
+    version = VersionConstants.JUBEAT_COPIOUS
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatKnitAppend(self.data, self.config, self.model)
+
+
+class JubeatCopiousAppend(JubeatBase):
+
+    name = 'Jubeat Copious Append'
+    version = VersionConstants.JUBEAT_COPIOUS_APPEND
+
+    def previous_version(self) -> Optional[JubeatBase]:
+        return JubeatCopious(self.data, self.config, self.model)
diff --git a/bemani/backend/museca/__init__.py b/bemani/backend/museca/__init__.py
new file mode 100644
index 0000000..7473d32
--- /dev/null
+++ b/bemani/backend/museca/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.museca.factory import MusecaFactory
+from bemani.backend.museca.base import MusecaBase
diff --git a/bemani/backend/museca/base.py b/bemani/backend/museca/base.py
new file mode 100644
index 0000000..d4a6382
--- /dev/null
+++ b/bemani/backend/museca/base.py
@@ -0,0 +1,286 @@
+# vim: set fileencoding=utf-8
+from typing import Dict, Optional
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import ValidatedDict, GameConstants, DBConstants, Parallel
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class MusecaBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all Museca version that we support.
+    """
+
+    game = GameConstants.MUSECA
+
+    CHART_TYPE_GREEN = 0
+    CHART_TYPE_ORANGE = 1
+    CHART_TYPE_RED = 2
+
+    GRADE_DEATH = DBConstants.MUSECA_GRADE_DEATH
+    GRADE_POOR = DBConstants.MUSECA_GRADE_POOR
+    GRADE_MEDIOCRE = DBConstants.MUSECA_GRADE_MEDIOCRE
+    GRADE_GOOD = DBConstants.MUSECA_GRADE_GOOD
+    GRADE_GREAT = DBConstants.MUSECA_GRADE_GREAT
+    GRADE_EXCELLENT = DBConstants.MUSECA_GRADE_EXCELLENT
+    GRADE_SUPERB = DBConstants.MUSECA_GRADE_SUPERB
+    GRADE_MASTERPIECE = DBConstants.MUSECA_GRADE_MASTERPIECE
+    GRADE_PERFECT = DBConstants.MUSECA_GRADE_PERFECT
+
+    CLEAR_TYPE_FAILED = DBConstants.MUSECA_CLEAR_TYPE_FAILED
+    CLEAR_TYPE_CLEARED = DBConstants.MUSECA_CLEAR_TYPE_CLEARED
+    CLEAR_TYPE_FULL_COMBO = DBConstants.MUSECA_CLEAR_TYPE_FULL_COMBO
+
+    def previous_version(self) -> Optional['MusecaBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def game_to_db_clear_type(self, clear_type: int) -> int:
+        # Given a game clear type, return the canonical database identifier.
+        raise Exception('Implement in subclass!')
+
+    def db_to_game_clear_type(self, clear_type: int) -> int:
+        # Given a database clear type, return the game's identifier.
+        raise Exception('Implement in subclass!')
+
+    def game_to_db_grade(self, grade: int) -> int:
+        # Given a game grade, return the canonical database identifier.
+        raise Exception('Implement in subclass!')
+
+    def db_to_game_grade(self, grade: int) -> int:
+        # Given a database grade, return the game's identifier.
+        raise Exception('Implement in subclass!')
+
+    def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication.
+        """
+        if refid is None:
+            return None
+
+        # First try to load the actual profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+
+        # Now, return it
+        return self.format_profile(userid, profile)
+
+    def new_profile_by_refid(self, refid: Optional[str], name: Optional[str], locid: Optional[int]) -> Node:
+        """
+        Given a RefID and an optional name, create a profile and then return
+        a formatted profile node. Similar rationale to get_profile_by_refid.
+        """
+        if refid is None:
+            return None
+
+        if name is None:
+            name = 'NONAME'
+
+        # First, create and save the default profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        defaultprofile = ValidatedDict({
+            'name': name,
+            'loc': locid,
+        })
+        self.put_profile(userid, defaultprofile)
+
+        # Now, reload and format the profile, looking up the has old version flag
+        profile = self.get_profile(userid)
+        return self.format_profile(userid, profile)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('game')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_clear_rates(self) -> Dict[int, Dict[int, Dict[str, int]]]:
+        """
+        Returns a dictionary similar to the following:
+
+        {
+            musicid: {
+                chart: {
+                    total: total plays,
+                    clears: total clears,
+                },
+            },
+        }
+        """
+        all_attempts, remote_attempts = Parallel.execute([
+            lambda: self.data.local.music.get_all_attempts(
+                game=self.game,
+                version=self.version,
+            ),
+            lambda: self.data.remote.music.get_clear_rates(
+                game=self.game,
+                version=self.version,
+            )
+        ])
+        attempts: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for (_, attempt) in all_attempts:
+            # Terrible temporary structure is terrible.
+            if attempt.id not in attempts:
+                attempts[attempt.id] = {}
+            if attempt.chart not in attempts[attempt.id]:
+                attempts[attempt.id][attempt.chart] = {
+                    'total': 0,
+                    'clears': 0,
+                }
+
+            # We saw an attempt, keep the total attempts in sync.
+            attempts[attempt.id][attempt.chart]['total'] = attempts[attempt.id][attempt.chart]['total'] + 1
+
+            if attempt.data.get_int('clear_type', self.CLEAR_TYPE_FAILED) != self.CLEAR_TYPE_FAILED:
+                # This attempt was a failure, so don't count it against clears of full combos
+                continue
+
+            # It was at least a clear
+            attempts[attempt.id][attempt.chart]['clears'] = attempts[attempt.id][attempt.chart]['clears'] + 1
+
+        # Merge in remote attempts
+        for songid in remote_attempts:
+            if songid not in attempts:
+                attempts[songid] = {}
+
+            for songchart in remote_attempts[songid]:
+                if songchart not in attempts[songid]:
+                    attempts[songid][songchart] = {
+                        'total': 0,
+                        'clears': 0,
+                    }
+
+                attempts[songid][songchart]['total'] += remote_attempts[songid][songchart]['plays']
+                attempts[songid][songchart]['clears'] += remote_attempts[songid][songchart]['clears']
+
+        return attempts
+
+    def update_score(
+        self,
+        userid: Optional[UserID],
+        songid: int,
+        chart: int,
+        points: int,
+        clear_type: int,
+        grade: int,
+        combo: int,
+        stats: Optional[Dict[str, int]]=None,
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in SDVX series can expect
+        the same attributes in a score.
+        """
+        # Range check clear type
+        if clear_type not in [
+            self.CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_FULL_COMBO,
+        ]:
+            raise Exception("Invalid clear type value {}".format(clear_type))
+
+        # Range check grade
+        if grade not in [
+            self.GRADE_DEATH,
+            self.GRADE_POOR,
+            self.GRADE_MEDIOCRE,
+            self.GRADE_GOOD,
+            self.GRADE_GREAT,
+            self.GRADE_EXCELLENT,
+            self.GRADE_SUPERB,
+            self.GRADE_MASTERPIECE,
+            self.GRADE_PERFECT,
+        ]:
+            raise Exception("Invalid grade value {}".format(grade))
+
+        if userid is not None:
+            oldscore = self.data.local.music.get_score(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                chart,
+            )
+        else:
+            oldscore = None
+
+        # Score history is verbatum, instead of highest score
+        history = ValidatedDict({})
+        oldpoints = points
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({})
+            raised = True
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            raised = points > oldscore.points
+            highscore = points >= oldscore.points
+            points = max(oldscore.points, points)
+            scoredata = oldscore.data
+
+        # Replace grade and clear type
+        scoredata.replace_int('clear_type', max(scoredata.get_int('clear_type'), clear_type))
+        history.replace_int('clear_type', clear_type)
+        scoredata.replace_int('grade', max(scoredata.get_int('grade'), grade))
+        history.replace_int('grade', grade)
+
+        # If we have a combo, replace it
+        scoredata.replace_int('combo', max(scoredata.get_int('combo'), combo))
+        history.replace_int('combo', combo)
+
+        # If we have play stats, replace it
+        if stats is not None:
+            if raised:
+                # We have stats, and there's a new high score, update the stats
+                scoredata.replace_dict('stats', stats)
+            history.replace_dict('stats', stats)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        if userid is not None:
+            # Write the new score back
+            self.data.local.music.put_score(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                chart,
+                lid,
+                points,
+                scoredata,
+                highscore,
+            )
+
+        # Save the history of this score too
+        self.data.local.music.put_attempt(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+            lid,
+            oldpoints,
+            history,
+            raised,
+        )
diff --git a/bemani/backend/museca/common.py b/bemani/backend/museca/common.py
new file mode 100644
index 0000000..8adbed1
--- /dev/null
+++ b/bemani/backend/museca/common.py
@@ -0,0 +1,203 @@
+
+from bemani.backend.museca.base import MusecaBase
+from bemani.common import ID
+from bemani.protocol import Node
+
+
+class MusecaGameShopHandler(MusecaBase):
+
+    def handle_game_3_shop_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('shopname'))
+
+        # Respond with number of milliseconds until next request
+        game = Node.void('game_3')
+        game.add_child(Node.u32('nxt_time', 1000 * 5 * 60))
+        return game
+
+
+class MusecaGameHiscoreHandler(MusecaBase):
+
+    def handle_game_3_hiscore_request(self, request: Node) -> Node:
+        # Grab location for local scores
+        locid = ID.parse_machine_id(request.child_value('locid'))
+
+        # Start the response packet
+        game = Node.void('game_3')
+
+        # First, grab hit chart
+        playcounts = self.data.local.music.get_hit_chart(self.game, self.version, 1024)
+
+        hitchart = Node.void('hitchart')
+        game.add_child(hitchart)
+        for (songid, count) in playcounts:
+            info = Node.void('info')
+            hitchart.add_child(info)
+            info.add_child(Node.u32('id', songid))
+            info.add_child(Node.u32('cnt', count))
+
+        # Now, grab user records
+        records = self.data.remote.music.get_all_records(self.game, self.version)
+        users = {
+            uid: prof for (uid, prof) in
+            self.get_any_profiles([r[0] for r in records])
+        }
+
+        hiscore_allover = Node.void('hiscore_allover')
+        game.add_child(hiscore_allover)
+
+        # Output records
+        for (userid, score) in records:
+            info = Node.void('info')
+
+            if userid not in users:
+                raise Exception('Logic error, could not find profile for user!')
+            profile = users[userid]
+
+            info.add_child(Node.u32('id', score.id))
+            info.add_child(Node.u32('type', score.chart))
+            info.add_child(Node.string('name', profile.get_str('name')))
+            info.add_child(Node.string('seq', ID.format_extid(profile.get_int('extid'))))
+            info.add_child(Node.u32('score', score.points))
+
+            # Add to global scores
+            hiscore_allover.add_child(info)
+
+        # Now, grab local records
+        area_users = [
+            uid for (uid, prof) in self.data.local.user.get_all_profiles(self.game, self.version)
+            if prof.get_int('loc', -1) == locid
+        ]
+        records = self.data.local.music.get_all_records(self.game, self.version, userlist=area_users)
+        missing_players = [
+            uid for (uid, _) in records
+            if uid not in users
+        ]
+        for (uid, prof) in self.get_any_profiles(missing_players):
+            users[uid] = prof
+
+        hiscore_location = Node.void('hiscore_location')
+        game.add_child(hiscore_location)
+
+        # Output records
+        for (userid, score) in records:
+            info = Node.void('info')
+
+            if userid not in users:
+                raise Exception('Logic error, could not find profile for user!')
+            profile = users[userid]
+
+            info.add_child(Node.u32('id', score.id))
+            info.add_child(Node.u32('type', score.chart))
+            info.add_child(Node.string('name', profile.get_str('name')))
+            info.add_child(Node.string('seq', ID.format_extid(profile.get_int('extid'))))
+            info.add_child(Node.u32('score', score.points))
+
+            # Add to global scores
+            hiscore_location.add_child(info)
+
+        # Now, grab clear rates
+        clear_rate = Node.void('clear_rate')
+        game.add_child(clear_rate)
+
+        clears = self.get_clear_rates()
+        for songid in clears:
+            for chart in clears[songid]:
+                if clears[songid][chart]['total'] > 0:
+                    rate = float(clears[songid][chart]['clears']) / float(clears[songid][chart]['total'])
+                    dnode = Node.void('d')
+                    clear_rate.add_child(dnode)
+                    dnode.add_child(Node.u32('id', songid))
+                    dnode.add_child(Node.u32('type', chart))
+                    dnode.add_child(Node.s16('cr', int(rate * 10000)))
+
+        return game
+
+
+class MusecaGameFrozenHandler(MusecaBase):
+
+    def handle_game_3_frozen_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        game.add_child(Node.u8('result', 0))
+        return game
+
+
+class MusecaGameNewHandler(MusecaBase):
+
+    def handle_game_3_new_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        name = request.child_value('name')
+        loc = ID.parse_machine_id(request.child_value('locid'))
+        self.new_profile_by_refid(refid, name, loc)
+
+        root = Node.void('game_3')
+        return root
+
+
+class MusecaGameSaveMusicHandler(MusecaBase):
+
+    def handle_game_3_save_m_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        # Doesn't matter if userid is None here, that's an anonymous score
+        musicid = request.child_value('music_id')
+        chart = request.child_value('music_type')
+        points = request.child_value('score')
+        combo = request.child_value('max_chain')
+        clear_type = self.game_to_db_clear_type(request.child_value('clear_type'))
+        grade = self.game_to_db_grade(request.child_value('score_grade'))
+        stats = {
+            'btn_rate': request.child_value('btn_rate'),
+            'long_rate': request.child_value('long_rate'),
+            'vol_rate': request.child_value('vol_rate'),
+            'critical': request.child_value('critical'),
+            'near': request.child_value('near'),
+            'error': request.child_value('error'),
+        }
+
+        # Save the score
+        self.update_score(
+            userid,
+            musicid,
+            chart,
+            points,
+            clear_type,
+            grade,
+            combo,
+            stats,
+        )
+
+        # Return a blank response
+        return Node.void('game_3')
+
+
+class MusecaGamePlayEndHandler(MusecaBase):
+
+    def handle_game_3_play_e_request(self, request: Node) -> Node:
+        return Node.void('game_3')
+
+
+class MusecaGameSaveHandler(MusecaBase):
+
+    def handle_game_3_save_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid)
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+        else:
+            newprofile = None
+
+        if userid is not None and newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+        return Node.void('game_3')
diff --git a/bemani/backend/museca/factory.py b/bemani/backend/museca/factory.py
new file mode 100644
index 0000000..924b420
--- /dev/null
+++ b/bemani/backend/museca/factory.py
@@ -0,0 +1,40 @@
+from typing import Any, Dict, List, Optional, Type
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.museca.museca1 import Museca1
+from bemani.backend.museca.museca1plus import Museca1Plus
+from bemani.common import Model, VersionConstants
+from bemani.data import Data
+
+
+class MusecaFactory(Factory):
+
+    MANAGED_CLASSES: List[Type[Base]] = [
+        Museca1,
+        Museca1Plus,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['PIX']:
+            Base.register(game, MusecaFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        def version_from_date(date: int) -> Optional[int]:
+            if date <= 2016072600:
+                return VersionConstants.MUSECA
+            if date > 2016072600:
+                return VersionConstants.MUSECA_1_PLUS
+            return None
+
+        if model.game == 'PIX':
+            version = version_from_date(model.version)
+            if version == VersionConstants.MUSECA:
+                return Museca1(data, config, model)
+            if version == VersionConstants.MUSECA_1_PLUS:
+                return Museca1Plus(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/museca/museca1.py b/bemani/backend/museca/museca1.py
new file mode 100644
index 0000000..a077bf5
--- /dev/null
+++ b/bemani/backend/museca/museca1.py
@@ -0,0 +1,364 @@
+import copy
+from typing import Any, Dict
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.museca.base import MusecaBase
+from bemani.backend.museca.common import (
+    MusecaGameFrozenHandler,
+    MusecaGameHiscoreHandler,
+    MusecaGameNewHandler,
+    MusecaGamePlayEndHandler,
+    MusecaGameSaveHandler,
+    MusecaGameSaveMusicHandler,
+    MusecaGameShopHandler,
+)
+from bemani.common import Time, VersionConstants, ValidatedDict, ID
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class Museca1(
+    EventLogHandler,
+    MusecaGameFrozenHandler,
+    MusecaGameHiscoreHandler,
+    MusecaGameNewHandler,
+    MusecaGamePlayEndHandler,
+    MusecaGameSaveHandler,
+    MusecaGameSaveMusicHandler,
+    MusecaGameShopHandler,
+    MusecaBase,
+):
+
+    name = "MÚSECA"
+    version = VersionConstants.MUSECA
+
+    GAME_LIMITED_LOCKED = 1
+    GAME_LIMITED_UNLOCKABLE = 2
+    GAME_LIMITED_UNLOCKED = 3
+
+    GAME_CATALOG_TYPE_SONG = 0
+    GAME_CATALOG_TYPE_GRAFICA = 15
+    GAME_CATALOG_TYPE_MISSION = 16
+
+    GAME_GRADE_DEATH = 0
+    GAME_GRADE_POOR = 1
+    GAME_GRADE_MEDIOCRE = 2
+    GAME_GRADE_GOOD = 3
+    GAME_GRADE_GREAT = 4
+    GAME_GRADE_EXCELLENT = 5
+    GAME_GRADE_SUPERB = 6
+    GAME_GRADE_MASTERPIECE = 7
+
+    GAME_CLEAR_TYPE_FAILED = 1
+    GAME_CLEAR_TYPE_CLEARED = 2
+    GAME_CLEAR_TYPE_FULL_COMBO = 4
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+        }
+
+    def game_to_db_clear_type(self, clear_type: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEARED: self.CLEAR_TYPE_CLEARED,
+            self.GAME_CLEAR_TYPE_FULL_COMBO: self.CLEAR_TYPE_FULL_COMBO,
+        }[clear_type]
+
+    def db_to_game_clear_type(self, clear_type: int) -> int:
+        return {
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEARED: self.GAME_CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_FULL_COMBO: self.GAME_CLEAR_TYPE_FULL_COMBO,
+        }[clear_type]
+
+    def game_to_db_grade(self, grade: int) -> int:
+        return {
+            self.GAME_GRADE_DEATH: self.GRADE_DEATH,
+            self.GAME_GRADE_POOR: self.GRADE_POOR,
+            self.GAME_GRADE_MEDIOCRE: self.GRADE_MEDIOCRE,
+            self.GAME_GRADE_GOOD: self.GRADE_GOOD,
+            self.GAME_GRADE_GREAT: self.GRADE_GREAT,
+            self.GAME_GRADE_EXCELLENT: self.GRADE_EXCELLENT,
+            self.GAME_GRADE_SUPERB: self.GRADE_SUPERB,
+            self.GAME_GRADE_MASTERPIECE: self.GRADE_MASTERPIECE,
+        }[grade]
+
+    def db_to_game_grade(self, grade: int) -> int:
+        return {
+            self.GRADE_DEATH: self.GAME_GRADE_DEATH,
+            self.GRADE_POOR: self.GAME_GRADE_POOR,
+            self.GRADE_MEDIOCRE: self.GAME_GRADE_MEDIOCRE,
+            self.GRADE_GOOD: self.GAME_GRADE_GOOD,
+            self.GRADE_GREAT: self.GAME_GRADE_GREAT,
+            self.GRADE_EXCELLENT: self.GAME_GRADE_EXCELLENT,
+            self.GRADE_SUPERB: self.GAME_GRADE_SUPERB,
+            self.GRADE_MASTERPIECE: self.GAME_GRADE_MASTERPIECE,
+            self.GRADE_PERFECT: self.GAME_GRADE_MASTERPIECE,
+        }[grade]
+
+    def handle_game_3_common_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        limited = Node.void('music_limited')
+        game.add_child(limited)
+
+        # Song unlock config
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_songs'):
+            ids = set()
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.data.get_int('limited') in (self.GAME_LIMITED_LOCKED, self.GAME_LIMITED_UNLOCKABLE):
+                    ids.add((song.id, song.chart))
+
+            for (songid, chart) in ids:
+                info = Node.void('info')
+                limited.add_child(info)
+                info.add_child(Node.s32('music_id', songid))
+                info.add_child(Node.u8('music_type', chart))
+                info.add_child(Node.u8('limited', self.GAME_LIMITED_UNLOCKED))
+
+        # Event config
+        event = Node.void('event')
+        game.add_child(event)
+
+        def enable_event(eid: int) -> None:
+            evt = Node.void('info')
+            event.add_child(evt)
+            evt.add_child(Node.u32('event_id', eid))
+
+        # Allow PASELI light start
+        enable_event(83)
+
+        # If you want song unlock news to show up, enable one of the following:
+        # 94 - 5/25/2016 unlocks
+        # 95 - 4/27/2016 second unlocks
+        # 89 - 4/27/2016 unlocks
+        # 87 - 4/13/2016 unlocks
+        # 82 - 3/23/2016 second unlocks
+        # 80 - 3/23/2016 unlocks
+        # 76 - 12/22/2016 unlocks
+
+        return game
+
+    def handle_game_3_exception_request(self, request: Node) -> Node:
+        return Node.void('game_3')
+
+    def handle_game_3_load_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is not None:
+            return root
+
+        # No data succession, there's nothing older than this!
+        root = Node.void('game_3')
+        root.add_child(Node.u8('result', 1))
+        return root
+
+    def handle_game_3_load_m_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        # Output to the game
+        game = Node.void('game_3')
+        new = Node.void('new')
+        game.add_child(new)
+
+        for score in scores:
+            music = Node.void('music')
+            new.add_child(music)
+            music.add_child(Node.u32('music_id', score.id))
+            music.add_child(Node.u32('music_type', score.chart))
+            music.add_child(Node.u32('score', score.points))
+            music.add_child(Node.u32('cnt', score.plays))
+            music.add_child(Node.u32('clear_type', self.db_to_game_clear_type(score.data.get_int('clear_type'))))
+            music.add_child(Node.u32('score_grade', self.db_to_game_grade(score.data.get_int('grade'))))
+            stats = score.data.get_dict('stats')
+            music.add_child(Node.u32('btn_rate', stats.get_int('btn_rate')))
+            music.add_child(Node.u32('long_rate', stats.get_int('long_rate')))
+            music.add_child(Node.u32('vol_rate', stats.get_int('vol_rate')))
+
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game_3')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.s16('skill_name_id', profile.get_int('skill_name_id', -1)))
+        game.add_child(Node.s32_array('hidden_param', profile.get_int_array('hidden_param', 20)))
+        game.add_child(Node.u32('blaster_energy', profile.get_int('blaster_energy')))
+        game.add_child(Node.u32('blaster_count', profile.get_int('blaster_count')))
+
+        # Play statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        game.add_child(Node.u32('play_count', statistics.get_int('total_plays', 0)))
+        game.add_child(Node.u32('daily_count', today_count))
+        game.add_child(Node.u32('play_chain', statistics.get_int('consecutive_days', 0)))
+
+        # Last played stuff
+        if 'last' in profile:
+            lastdict = profile.get_dict('last')
+            last = Node.void('last')
+            game.add_child(last)
+            last.add_child(Node.s32('music_id', lastdict.get_int('music_id', -1)))
+            last.add_child(Node.u8('music_type', lastdict.get_int('music_type')))
+            last.add_child(Node.u8('sort_type', lastdict.get_int('sort_type')))
+            last.add_child(Node.u8('narrow_down', lastdict.get_int('narrow_down')))
+            last.add_child(Node.u8('headphone', lastdict.get_int('headphone')))
+            last.add_child(Node.u16('appeal_id', lastdict.get_int('appeal_id', 1001)))
+            last.add_child(Node.u16('comment_id', lastdict.get_int('comment_id')))
+            last.add_child(Node.u8('gauge_option', lastdict.get_int('gauge_option')))
+
+        # Item unlocks
+        itemnode = Node.void('item')
+        game.add_child(itemnode)
+
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+
+            if game_config.get_bool('force_unlock_songs') and itemtype == self.GAME_CATALOG_TYPE_SONG:
+                # Don't echo unlocked songs, we will add all of them later
+                continue
+
+            info = Node.void('info')
+            itemnode.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u32('id', item.id))
+            info.add_child(Node.u32('param', item.data.get_int('param')))
+            if 'diff_param' in item.data:
+                info.add_child(Node.s32('diff_param', item.data.get_int('diff_param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for itemid in ids:
+                if ids[itemid] == 0:
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('id', itemid))
+                info.add_child(Node.u32('param', ids[itemid]))
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update blaster energy and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        earned_blaster_energy = request.child_value('earned_blaster_energy')
+        if earned_blaster_energy is not None:
+            newprofile.replace_int('blaster_energy', newprofile.get_int('blaster_energy') + earned_blaster_energy)
+
+        # Miscelaneous stuff
+        newprofile.replace_int('blaster_count', request.child_value('blaster_count'))
+        newprofile.replace_int('skill_name_id', request.child_value('skill_name_id'))
+        newprofile.replace_int_array('hidden_param', 20, request.child_value('hidden_param'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+
+        if request.child('item') is not None:
+            for child in request.child('item').children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                diff_param = child.child_value('diff_param')
+
+                if game_config.get_bool('force_unlock_songs') and item_type == self.GAME_CATALOG_TYPE_SONG:
+                    # Don't save back songs, because they were force unlocked
+                    continue
+
+                if diff_param is not None:
+                    paramvals = {
+                        'diff_param': diff_param,
+                        'param': param,
+                    }
+                else:
+                    paramvals = {
+                        'param': param,
+                    }
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    paramvals,
+                )
+
+        # Grab last information.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('appeal_id', request.child_value('appeal_id'))
+        lastdict.replace_int('comment_id', request.child_value('comment_id'))
+        lastdict.replace_int('music_id', request.child_value('music_id'))
+        lastdict.replace_int('music_type', request.child_value('music_type'))
+        lastdict.replace_int('sort_type', request.child_value('sort_type'))
+        lastdict.replace_int('narrow_down', request.child_value('narrow_down'))
+        lastdict.replace_int('gauge_option', request.child_value('gauge_option'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/museca/museca1plus.py b/bemani/backend/museca/museca1plus.py
new file mode 100644
index 0000000..e998882
--- /dev/null
+++ b/bemani/backend/museca/museca1plus.py
@@ -0,0 +1,405 @@
+import copy
+from typing import Optional, Dict, Any
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.museca.base import MusecaBase
+from bemani.backend.museca.common import (
+    MusecaGameFrozenHandler,
+    MusecaGameHiscoreHandler,
+    MusecaGameNewHandler,
+    MusecaGamePlayEndHandler,
+    MusecaGameSaveHandler,
+    MusecaGameSaveMusicHandler,
+    MusecaGameShopHandler,
+)
+from bemani.backend.museca.museca1 import Museca1
+from bemani.common import Time, VersionConstants, ValidatedDict, ID
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class Museca1Plus(
+    EventLogHandler,
+    MusecaGameFrozenHandler,
+    MusecaGameHiscoreHandler,
+    MusecaGameNewHandler,
+    MusecaGamePlayEndHandler,
+    MusecaGameSaveHandler,
+    MusecaGameSaveMusicHandler,
+    MusecaGameShopHandler,
+    MusecaBase,
+):
+
+    name = "MÚSECA 1+1/2"
+    version = VersionConstants.MUSECA_1_PLUS
+
+    GAME_LIMITED_LOCKED = 1
+    GAME_LIMITED_UNLOCKABLE = 2
+    GAME_LIMITED_UNLOCKED = 3
+
+    GAME_CATALOG_TYPE_SONG = 0
+    GAME_CATALOG_TYPE_GRAFICA = 15
+    GAME_CATALOG_TYPE_MISSION = 16
+
+    GAME_GRADE_DEATH = 0
+    GAME_GRADE_POOR = 1
+    GAME_GRADE_MEDIOCRE = 2
+    GAME_GRADE_GOOD = 3
+    GAME_GRADE_GREAT = 4
+    GAME_GRADE_EXCELLENT = 5
+    GAME_GRADE_SUPERB = 6
+    GAME_GRADE_MASTERPIECE = 7
+    GAME_GRADE_PERFECT = 8
+
+    GAME_CLEAR_TYPE_FAILED = 1
+    GAME_CLEAR_TYPE_CLEARED = 2
+    GAME_CLEAR_TYPE_FULL_COMBO = 4
+
+    def previous_version(self) -> Optional[MusecaBase]:
+        return Museca1(self.data, self.config, self.model)
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Disable Online Matching',
+                    'tip': 'Disable online matching between games.',
+                    'category': 'game_config',
+                    'setting': 'disable_matching',
+                },
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+        }
+
+    def game_to_db_clear_type(self, clear_type: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEARED: self.CLEAR_TYPE_CLEARED,
+            self.GAME_CLEAR_TYPE_FULL_COMBO: self.CLEAR_TYPE_FULL_COMBO,
+        }[clear_type]
+
+    def db_to_game_clear_type(self, clear_type: int) -> int:
+        return {
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEARED: self.GAME_CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_FULL_COMBO: self.GAME_CLEAR_TYPE_FULL_COMBO,
+        }[clear_type]
+
+    def game_to_db_grade(self, grade: int) -> int:
+        return {
+            self.GAME_GRADE_DEATH: self.GRADE_DEATH,
+            self.GAME_GRADE_POOR: self.GRADE_POOR,
+            self.GAME_GRADE_MEDIOCRE: self.GRADE_MEDIOCRE,
+            self.GAME_GRADE_GOOD: self.GRADE_GOOD,
+            self.GAME_GRADE_GREAT: self.GRADE_GREAT,
+            self.GAME_GRADE_EXCELLENT: self.GRADE_EXCELLENT,
+            self.GAME_GRADE_SUPERB: self.GRADE_SUPERB,
+            self.GAME_GRADE_MASTERPIECE: self.GRADE_MASTERPIECE,
+            self.GAME_GRADE_PERFECT: self.GRADE_PERFECT,
+        }[grade]
+
+    def db_to_game_grade(self, grade: int) -> int:
+        return {
+            self.GRADE_DEATH: self.GAME_GRADE_DEATH,
+            self.GRADE_POOR: self.GAME_GRADE_POOR,
+            self.GRADE_MEDIOCRE: self.GAME_GRADE_MEDIOCRE,
+            self.GRADE_GOOD: self.GAME_GRADE_GOOD,
+            self.GRADE_GREAT: self.GAME_GRADE_GREAT,
+            self.GRADE_EXCELLENT: self.GAME_GRADE_EXCELLENT,
+            self.GRADE_SUPERB: self.GAME_GRADE_SUPERB,
+            self.GRADE_MASTERPIECE: self.GAME_GRADE_MASTERPIECE,
+            self.GRADE_PERFECT: self.GAME_GRADE_PERFECT,
+        }[grade]
+
+    def handle_game_3_common_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        limited = Node.void('music_limited')
+        game.add_child(limited)
+
+        # Song unlock config
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_songs'):
+            ids = set()
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.data.get_int('limited') in (self.GAME_LIMITED_LOCKED, self.GAME_LIMITED_UNLOCKABLE):
+                    ids.add((song.id, song.chart))
+
+            for (songid, chart) in ids:
+                info = Node.void('info')
+                limited.add_child(info)
+                info.add_child(Node.s32('music_id', songid))
+                info.add_child(Node.u8('music_type', chart))
+                info.add_child(Node.u8('limited', self.GAME_LIMITED_UNLOCKED))
+
+        # Event config
+        event = Node.void('event')
+        game.add_child(event)
+
+        def enable_event(eid: int) -> None:
+            evt = Node.void('info')
+            event.add_child(evt)
+            evt.add_child(Node.u32('event_id', eid))
+
+        if not game_config.get_bool('disable_matching'):
+            enable_event(143)  # Matching enabled
+
+        enable_event(1)  # Extended pedal options
+        enable_event(83)  # Light start
+        enable_event(130)  # Curator rank
+        enable_event(195)  # Fictional curator
+        # Event 194 is continuation mode, but it doesn't seem to work on latest data.
+
+        enable_event(98)  # Mission mode
+        for evtid in [145, 146, 147, 148, 149]:
+            enable_event(evtid)  # Mission stuff
+
+        return game
+
+    def handle_game_3_lounge_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        # Refresh interval in seconds.
+        game.add_child(Node.u32('interval', 10))
+        return game
+
+    def handle_game_3_exception_request(self, request: Node) -> Node:
+        return Node.void('game_3')
+
+    def handle_game_3_load_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is not None:
+            return root
+
+        # Figure out if this user has an older profile or not
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            previous_game = self.previous_version()
+        else:
+            previous_game = None
+
+        if previous_game is not None:
+            profile = previous_game.get_profile(userid)
+        else:
+            profile = None
+
+        if profile is not None:
+            # Return the previous formatted profile to the game.
+            return previous_game.format_profile(userid, profile)
+        else:
+            root = Node.void('game_3')
+            root.add_child(Node.u8('result', 1))
+            return root
+
+    def handle_game_3_load_m_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        # Output to the game
+        game = Node.void('game_3')
+        new = Node.void('new')
+        game.add_child(new)
+
+        for score in scores:
+            music = Node.void('music')
+            new.add_child(music)
+            music.add_child(Node.u32('music_id', score.id))
+            music.add_child(Node.u32('music_type', score.chart))
+            music.add_child(Node.u32('score', score.points))
+            music.add_child(Node.u32('cnt', score.plays))
+            music.add_child(Node.u32('combo', score.data.get_int('combo')))
+            music.add_child(Node.u32('clear_type', self.db_to_game_clear_type(score.data.get_int('clear_type'))))
+            music.add_child(Node.u32('score_grade', self.db_to_game_grade(score.data.get_int('grade'))))
+            stats = score.data.get_dict('stats')
+            music.add_child(Node.u32('btn_rate', stats.get_int('btn_rate')))
+            music.add_child(Node.u32('long_rate', stats.get_int('long_rate')))
+            music.add_child(Node.u32('vol_rate', stats.get_int('vol_rate')))
+
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game_3')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.s16('skill_name_id', profile.get_int('skill_name_id', -1)))
+        game.add_child(Node.s32_array('hidden_param', profile.get_int_array('hidden_param', 20)))
+        game.add_child(Node.u32('blaster_energy', profile.get_int('blaster_energy')))
+        game.add_child(Node.u32('blaster_count', profile.get_int('blaster_count')))
+
+        # Enable Ryusei Festa
+        ryusei_festa = Node.void('ryusei_festa')
+        game.add_child(ryusei_festa)
+        ryusei_festa.add_child(Node.bool('ryusei_festa_trigger', True))
+
+        # Play statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        game.add_child(Node.u32('play_count', statistics.get_int('total_plays', 0)))
+        game.add_child(Node.u32('daily_count', today_count))
+        game.add_child(Node.u32('play_chain', statistics.get_int('consecutive_days', 0)))
+
+        # Last played stuff
+        if 'last' in profile:
+            lastdict = profile.get_dict('last')
+            last = Node.void('last')
+            game.add_child(last)
+            last.add_child(Node.s32('music_id', lastdict.get_int('music_id', -1)))
+            last.add_child(Node.u8('music_type', lastdict.get_int('music_type')))
+            last.add_child(Node.u8('sort_type', lastdict.get_int('sort_type')))
+            last.add_child(Node.u8('narrow_down', lastdict.get_int('narrow_down')))
+            last.add_child(Node.u8('headphone', lastdict.get_int('headphone')))
+            last.add_child(Node.u16('appeal_id', lastdict.get_int('appeal_id', 1001)))
+            last.add_child(Node.u16('comment_id', lastdict.get_int('comment_id')))
+            last.add_child(Node.u8('gauge_option', lastdict.get_int('gauge_option')))
+
+        # Item unlocks
+        itemnode = Node.void('item')
+        game.add_child(itemnode)
+
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+
+            if game_config.get_bool('force_unlock_songs') and itemtype == self.GAME_CATALOG_TYPE_SONG:
+                # Don't echo unlocked songs, we will add all of them later
+                continue
+
+            info = Node.void('info')
+            itemnode.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u32('id', item.id))
+            info.add_child(Node.u32('param', item.data.get_int('param')))
+            if 'diff_param' in item.data:
+                info.add_child(Node.s32('diff_param', item.data.get_int('diff_param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for itemid in ids:
+                if ids[itemid] == 0:
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('id', itemid))
+                info.add_child(Node.u32('param', ids[itemid]))
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update blaster energy and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        earned_blaster_energy = request.child_value('earned_blaster_energy')
+        if earned_blaster_energy is not None:
+            newprofile.replace_int('blaster_energy', newprofile.get_int('blaster_energy') + earned_blaster_energy)
+
+        # Miscelaneous stuff
+        newprofile.replace_int('blaster_count', request.child_value('blaster_count'))
+        newprofile.replace_int('skill_name_id', request.child_value('skill_name_id'))
+        newprofile.replace_int_array('hidden_param', 20, request.child_value('hidden_param'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+
+        if request.child('item') is not None:
+            for child in request.child('item').children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                diff_param = child.child_value('diff_param')
+
+                if game_config.get_bool('force_unlock_songs') and item_type == self.GAME_CATALOG_TYPE_SONG:
+                    # Don't save back songs, because they were force unlocked
+                    continue
+
+                if diff_param is not None:
+                    paramvals = {
+                        'diff_param': diff_param,
+                        'param': param,
+                    }
+                else:
+                    paramvals = {
+                        'param': param,
+                    }
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    paramvals,
+                )
+
+        # Grab last information.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('appeal_id', request.child_value('appeal_id'))
+        lastdict.replace_int('comment_id', request.child_value('comment_id'))
+        lastdict.replace_int('music_id', request.child_value('music_id'))
+        lastdict.replace_int('music_type', request.child_value('music_type'))
+        lastdict.replace_int('sort_type', request.child_value('sort_type'))
+        lastdict.replace_int('narrow_down', request.child_value('narrow_down'))
+        lastdict.replace_int('gauge_option', request.child_value('gauge_option'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/popn/__init__.py b/bemani/backend/popn/__init__.py
new file mode 100644
index 0000000..d5dd4b0
--- /dev/null
+++ b/bemani/backend/popn/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.popn.factory import PopnMusicFactory
+from bemani.backend.popn.base import PopnMusicBase
diff --git a/bemani/backend/popn/base.py b/bemani/backend/popn/base.py
new file mode 100644
index 0000000..37b5eb3
--- /dev/null
+++ b/bemani/backend/popn/base.py
@@ -0,0 +1,282 @@
+# vim: set fileencoding=utf-8
+from typing import Dict, Optional, Sequence
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import ValidatedDict, Time, GameConstants, DBConstants
+from bemani.data import UserID, Achievement, ScoreSaveException
+from bemani.protocol import Node
+
+
+class PopnMusicBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all Pop'n Music versions. Handles common functionality for
+    getting profiles based on refid, creating new profiles, looking up and saving
+    scores.
+    """
+
+    game = GameConstants.POPN_MUSIC
+
+    # Play medals, as saved into/loaded from the DB
+    PLAY_MEDAL_CIRCLE_FAILED = DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED
+    PLAY_MEDAL_DIAMOND_FAILED = DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FAILED
+    PLAY_MEDAL_STAR_FAILED = DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FAILED
+    PLAY_MEDAL_EASY_CLEAR = DBConstants.POPN_MUSIC_PLAY_MEDAL_EASY_CLEAR
+    PLAY_MEDAL_CIRCLE_CLEARED = DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_CLEARED
+    PLAY_MEDAL_DIAMOND_CLEARED = DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_CLEARED
+    PLAY_MEDAL_STAR_CLEARED = DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_CLEARED
+    PLAY_MEDAL_CIRCLE_FULL_COMBO = DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FULL_COMBO
+    PLAY_MEDAL_DIAMOND_FULL_COMBO = DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FULL_COMBO
+    PLAY_MEDAL_STAR_FULL_COMBO = DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FULL_COMBO
+    PLAY_MEDAL_PERFECT = DBConstants.POPN_MUSIC_PLAY_MEDAL_PERFECT
+
+    # Chart type, as saved into/loaded from the DB, and returned to game
+    CHART_TYPE_EASY = 0
+    CHART_TYPE_NORMAL = 1
+    CHART_TYPE_HYPER = 2
+    CHART_TYPE_EX = 3
+
+    # Old profile lookup type, for loading profile by ID
+    NEW_PROFILE_ONLY = 0
+    OLD_PROFILE_ONLY = 1
+    OLD_PROFILE_FALLTHROUGH = 2
+
+    def previous_version(self) -> Optional['PopnMusicBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('playerdata')
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for profile conversion. Given a userid and a profile
+        dictionary, return a node which represents the converted profile for
+        the next version of this game. Games will call previous_version to get
+        a game class of their previous game version, and then will call
+        format_conversion on that previous version to get the profile to
+        migrate.
+        """
+        return Node.void('playerdata')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_profile_by_refid(self, refid: Optional[str], load_mode: int) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication. This
+        method handles delegating to either format_profile, or looking up
+        the previous game and calling format_conversion, whenever necessary.
+        """
+        if refid is None:
+            return None
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            # User doesn't exist but should at this point
+            return None
+
+        if load_mode == self.OLD_PROFILE_ONLY:
+            # Trying to import from older version
+            oldversion = self.previous_version()
+            profile = oldversion.get_profile(userid)
+            if profile is None:
+                return None
+            return oldversion.format_conversion(userid, profile)
+        elif load_mode == self.NEW_PROFILE_ONLY:
+            # Trying to import from current version
+            profile = self.get_profile(userid)
+            if profile is None:
+                return None
+            return self.format_profile(userid, profile)
+        elif load_mode == self.OLD_PROFILE_FALLTHROUGH:
+            # Try to load from current, if that fails try to load previous
+            profile = self.get_profile(userid)
+            if profile is not None:
+                return self.format_profile(userid, profile)
+            oldversion = self.previous_version()
+            oldprofile = oldversion.get_profile(userid)
+            if oldprofile is not None:
+                return oldversion.format_conversion(userid, oldprofile)
+            return None
+        else:
+            # Unknown value
+            raise Exception("Unrecognized value for get profile!")
+
+    def new_profile_by_refid(
+        self,
+        refid: Optional[str],
+        name: Optional[str],
+        chara: Optional[int]=None,
+        achievements: Sequence[Achievement] = (),
+    ) -> Node:
+        """
+        Given a RefID and an optional name, create a profile and then return
+        a formatted profile node. Similar rationale to get_profile_by_refid.
+        """
+        if refid is None:
+            return None
+
+        if name is None:
+            name = 'なし'
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            raise Exception("Logic error! Didn't find user to tie profile to!")
+        defaultprofile = ValidatedDict({
+            'name': name,
+        })
+        if chara is not None:
+            defaultprofile.replace_int('chara', chara)
+        self.put_profile(userid, defaultprofile)
+        for achievement in achievements:
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                achievement.id,
+                achievement.type,
+                achievement.data,
+            )
+
+        profile = self.get_profile(userid)
+        if profile is None:
+            raise Exception("Logic error! Didn't find profile after writing it!")
+        return self.format_profile(userid, profile)
+
+    def update_score(
+        self,
+        userid: UserID,
+        songid: int,
+        chart: int,
+        points: int,
+        medal: int,
+        combo: Optional[int]=None,
+        stats: Optional[Dict[str, int]]=None,
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in Pop'n series can expect
+        the same attributes in a score. Note that the medals passed here are
+        expected to be converted from game identifier to our internal identifier,
+        so that any game in the series may convert them back. In this way, a song
+        played on Pop'n 22 that exists in Pop'n 19 will still have scores/medals
+        going back all versions.
+        """
+        # Range check medals
+        if medal not in [
+            self.PLAY_MEDAL_CIRCLE_FAILED,
+            self.PLAY_MEDAL_DIAMOND_FAILED,
+            self.PLAY_MEDAL_STAR_FAILED,
+            self.PLAY_MEDAL_EASY_CLEAR,
+            self.PLAY_MEDAL_CIRCLE_CLEARED,
+            self.PLAY_MEDAL_DIAMOND_CLEARED,
+            self.PLAY_MEDAL_STAR_CLEARED,
+            self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+            self.PLAY_MEDAL_DIAMOND_FULL_COMBO,
+            self.PLAY_MEDAL_STAR_FULL_COMBO,
+            self.PLAY_MEDAL_PERFECT,
+        ]:
+            raise Exception("Invalid medal value {}".format(medal))
+
+        oldscore = self.data.local.music.get_score(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+        )
+
+        # Score history is verbatum, instead of highest score
+        history = ValidatedDict({})
+        oldpoints = points
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({})
+            raised = True
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            raised = points > oldscore.points
+            highscore = points >= oldscore.points
+            points = max(points, oldscore.points)
+            scoredata = oldscore.data
+
+        # Replace medal with highest value
+        scoredata.replace_int('medal', max(scoredata.get_int('medal'), medal))
+        history.replace_int('medal', medal)
+
+        if stats is not None:
+            if raised:
+                # We have stats, and there's a new high score, update the stats
+                scoredata.replace_dict('stats', stats)
+            history.replace_dict('stats', stats)
+
+        if combo is not None:
+            # If we have a combo, replace it
+            scoredata.replace_int('combo', max(scoredata.get_int('combo'), combo))
+            history.replace_int('combo', combo)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        # Pop'n Music for all versions before Lapistoria sends all of the songs
+        # a player played at the end of the round. It doesn't send timestamps
+        # for those songs (Jubeat does). So, if a user plays the same song/chart
+        # more than once in a round, we will end up failing to store the attempt
+        # since we don't allow two of the same attempt at the same time for the
+        # same user and song/chart. So, bump the timestamp by one second and retry
+        # well past the maximum number of songs.
+        now = Time.now()
+        for bump in range(10):
+            timestamp = now + bump
+
+            # Write the new score back
+            self.data.local.music.put_score(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                chart,
+                lid,
+                points,
+                scoredata,
+                highscore,
+                timestamp=timestamp,
+            )
+
+            try:
+                # Save the history of this score too
+                self.data.local.music.put_attempt(
+                    self.game,
+                    self.version,
+                    userid,
+                    songid,
+                    chart,
+                    lid,
+                    oldpoints,
+                    history,
+                    raised,
+                    timestamp=timestamp,
+                )
+            except ScoreSaveException:
+                # Try again one second in the future
+                continue
+
+            # We saved successfully
+            break
diff --git a/bemani/backend/popn/eclale.py b/bemani/backend/popn/eclale.py
new file mode 100644
index 0000000..990bf75
--- /dev/null
+++ b/bemani/backend/popn/eclale.py
@@ -0,0 +1,737 @@
+# vim: set fileencoding=utf-8
+import binascii
+import copy
+from typing import Dict, Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.lapistoria import PopnMusicLapistoria
+
+from bemani.common import Time, ValidatedDict, VersionConstants
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class PopnMusicEclale(PopnMusicBase):
+
+    name = "Pop'n Music éclale"
+    version = VersionConstants.POPN_MUSIC_ECLALE
+
+    # Chart type, as returned from the game
+    GAME_CHART_TYPE_EASY = 0
+    GAME_CHART_TYPE_NORMAL = 1
+    GAME_CHART_TYPE_HYPER = 2
+    GAME_CHART_TYPE_EX = 3
+
+    # Medal type, as returned from the game
+    GAME_PLAY_MEDAL_CIRCLE_FAILED = 1
+    GAME_PLAY_MEDAL_DIAMOND_FAILED = 2
+    GAME_PLAY_MEDAL_STAR_FAILED = 3
+    GAME_PLAY_MEDAL_EASY_CLEAR = 4
+    GAME_PLAY_MEDAL_CIRCLE_CLEARED = 5
+    GAME_PLAY_MEDAL_DIAMOND_CLEARED = 6
+    GAME_PLAY_MEDAL_STAR_CLEARED = 7
+    GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO = 8
+    GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO = 9
+    GAME_PLAY_MEDAL_STAR_FULL_COMBO = 10
+    GAME_PLAY_MEDAL_PERFECT = 11
+
+    # Biggest ID in the music DB
+    GAME_MAX_MUSIC_ID = 1550
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicLapistoria(self.data, self.config, self.model)
+
+    def __construct_common_info(self, root: Node) -> None:
+        # Event phases
+        phases = {
+            # Unknown event (0-16)
+            0: 16,
+            # Unknown event (0-3)
+            1: 3,
+            # Unknown event (0-1)
+            2: 1,
+            # Unknown event (0-2)
+            3: 2,
+            # Unknown event (0-1)
+            4: 1,
+            # Unknown event (0-2)
+            5: 2,
+            # Unknown event (0-1)
+            6: 1,
+            # Unknown event (0-4)
+            7: 4,
+            # Unknown event (0-3)
+            8: 3,
+            # Unknown event (0-4)
+            9: 4,
+            # Unknown event (0-4)
+            10: 4,
+            # Unknown event (0-1)
+            11: 1,
+            # Possibly global event matching related? (0-1)
+            12: 1,
+            # Unknown event (0-4)
+            13: 4,
+        }
+
+        for phaseid in phases:
+            phase = Node.void('phase')
+            root.add_child(phase)
+            phase.add_child(Node.s16('event_id', phaseid))
+            phase.add_child(Node.s16('phase', phases[phaseid]))
+
+        for areaid in range(1, 50):
+            area = Node.void('area')
+            root.add_child(area)
+            area.add_child(Node.s16('area_id', areaid))
+            area.add_child(Node.u64('end_date', 0))
+            area.add_child(Node.s16('medal_id', areaid))
+            area.add_child(Node.bool('is_limit', False))
+
+        # Calculate most popular characters
+        profiles = self.data.remote.user.get_all_profiles(self.game, self.version)
+        charas: Dict[int, int] = {}
+        for (userid, profile) in profiles:
+            chara = profile.get_int('chara', -1)
+            if chara <= 0:
+                continue
+            if chara not in charas:
+                charas[chara] = 1
+            else:
+                charas[chara] = charas[chara] + 1
+
+        # Order a typle by most popular character to least popular character
+        charamap = sorted(
+            [(c, charas[c]) for c in charas],
+            key=lambda c: c[1],
+            reverse=True,
+        )
+
+        # Output the top 20 of them
+        rank = 1
+        for (charaid, usecount) in charamap[:20]:
+            popular = Node.void('popular')
+            root.add_child(popular)
+            popular.add_child(Node.s16('rank', rank))
+            popular.add_child(Node.s16('chara_num', charaid))
+            rank = rank + 1
+
+        # Output the hit chart
+        for (songid, plays) in self.data.local.music.get_hit_chart(self.game, self.version, 500):
+            popular_music = Node.void('popular_music')
+            root.add_child(popular_music)
+            popular_music.add_child(Node.s16('music_num', songid))
+
+        # Output goods prices
+        for goodsid in range(1, 421):
+            if goodsid >= 1 and goodsid <= 80:
+                price = 60
+            elif goodsid >= 81 and goodsid <= 120:
+                price = 250
+            elif goodsid >= 121 and goodsid <= 142:
+                price = 500
+            elif goodsid >= 143 and goodsid <= 300:
+                price = 100
+            elif goodsid >= 301 and goodsid <= 420:
+                price = 150
+            else:
+                raise Exception('Invalid goods ID!')
+            goods = Node.void('goods')
+            root.add_child(goods)
+            goods.add_child(Node.s16('goods_id', goodsid))
+            goods.add_child(Node.s32('price', price))
+            goods.add_child(Node.s16('goods_type', 0))
+
+    def handle_pcb23_boot_request(self, request: Node) -> Node:
+        return Node.void('pcb23')
+
+    def handle_pcb23_error_request(self, request: Node) -> Node:
+        return Node.void('pcb23')
+
+    def handle_pcb23_dlstatus_request(self, request: Node) -> Node:
+        return Node.void('pcb23')
+
+    def handle_pcb23_write_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('pcb_setting/name'))
+        return Node.void('pcb23')
+
+    def handle_info23_common_request(self, request: Node) -> Node:
+        info = Node.void('info23')
+        self.__construct_common_info(info)
+        return info
+
+    def handle_lobby22_request(self, request: Node) -> Optional[Node]:
+        # Stub out the entire lobby22 service (yes, its lobby22 in Pop'n 23)
+        return Node.void('lobby22')
+
+    def handle_player23_start_request(self, request: Node) -> Node:
+        root = Node.void('player23')
+        root.add_child(Node.s32('play_id', 0))
+        self.__construct_common_info(root)
+        return root
+
+    def handle_player23_logout_request(self, request: Node) -> Node:
+        return Node.void('player23')
+
+    def handle_player23_read_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        root = self.get_profile_by_refid(refid, self.OLD_PROFILE_FALLTHROUGH)
+        if root is None:
+            root = Node.void('player23')
+            root.add_child(Node.s8('result', 2))
+        return root
+
+    def handle_player23_write_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid) or ValidatedDict()
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+
+            if newprofile is not None:
+                self.put_profile(userid, newprofile)
+
+        return Node.void('player23')
+
+    def handle_player23_new_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        name = request.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        if root is None:
+            root = Node.void('player23')
+            root.add_child(Node.s8('result', 2))
+        return root
+
+    def handle_player23_conversion_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        name = request.child_value('name')
+        chara = request.child_value('chara')
+        root = self.new_profile_by_refid(refid, name, chara)
+        if root is None:
+            root = Node.void('player23')
+            root.add_child(Node.s8('result', 2))
+        return root
+
+    def handle_player23_buy_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            itemid = request.child_value('id')
+            itemtype = request.child_value('type')
+            itemparam = request.child_value('param')
+
+            price = request.child_value('price')
+            lumina = request.child_value('lumina')
+
+            if lumina >= price:
+                # Update player lumina balance
+                profile = self.get_profile(userid) or ValidatedDict()
+                profile.replace_int('lumina', lumina - price)
+                self.put_profile(userid, profile)
+
+                # Grant the object
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    itemid,
+                    'item_{}'.format(itemtype),
+                    {
+                        'param': itemparam,
+                        'is_new': True,
+                    },
+                )
+
+        return Node.void('player23')
+
+    def handle_player23_read_score_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        root = Node.void('player23')
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        for score in scores:
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            medal = score.data.get_int('medal')
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s32('score', points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[medal]))
+            music.add_child(Node.s16('cnt', score.plays))
+
+        return root
+
+    def handle_player23_write_music_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        root = Node.void('player23')
+        if refid is None:
+            return root
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            return root
+
+        songid = request.child_value('music_num')
+        chart = {
+            self.GAME_CHART_TYPE_EASY: self.CHART_TYPE_EASY,
+            self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL,
+            self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER,
+            self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX,
+        }[request.child_value('sheet_num')]
+        medal = request.child_value('clearmedal')
+        points = request.child_value('score')
+        combo = request.child_value('combo')
+        stats = {
+            'cool': request.child_value('cool'),
+            'great': request.child_value('great'),
+            'good': request.child_value('good'),
+            'bad': request.child_value('bad')
+        }
+        medal = {
+            self.GAME_PLAY_MEDAL_CIRCLE_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED,
+            self.GAME_PLAY_MEDAL_DIAMOND_FAILED: self.PLAY_MEDAL_DIAMOND_FAILED,
+            self.GAME_PLAY_MEDAL_STAR_FAILED: self.PLAY_MEDAL_STAR_FAILED,
+            self.GAME_PLAY_MEDAL_EASY_CLEAR: self.PLAY_MEDAL_EASY_CLEAR,
+            self.GAME_PLAY_MEDAL_CIRCLE_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED,
+            self.GAME_PLAY_MEDAL_DIAMOND_CLEARED: self.PLAY_MEDAL_DIAMOND_CLEARED,
+            self.GAME_PLAY_MEDAL_STAR_CLEARED: self.PLAY_MEDAL_STAR_CLEARED,
+            self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+            self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO: self.PLAY_MEDAL_DIAMOND_FULL_COMBO,
+            self.GAME_PLAY_MEDAL_STAR_FULL_COMBO: self.PLAY_MEDAL_STAR_FULL_COMBO,
+            self.GAME_PLAY_MEDAL_PERFECT: self.PLAY_MEDAL_PERFECT,
+        }[medal]
+        self.update_score(userid, songid, chart, points, medal, combo=combo, stats=stats)
+        return root
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('player23')
+        root.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        root.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        root.add_child(Node.s8('result', 1))
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            medal = score.data.get_int('medal')
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s32('score', points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[medal]))
+            music.add_child(Node.s16('cnt', score.plays))
+
+        return root
+
+    def format_extid(self, extid: int) -> str:
+        data = str(extid)
+        crc = abs(binascii.crc32(data.encode('ascii'))) % 10000
+        return '{}{:04d}'.format(data, crc)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('player23')
+
+        # Mark this as a current profile
+        root.add_child(Node.s8('result', 0))
+
+        # Account stuff
+        account = Node.void('account')
+        root.add_child(account)
+        account.add_child(Node.string('g_pm_id', self.format_extid(profile.get_int('extid'))))  # Eclale formats on its own
+        account.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        account.add_child(Node.s8('tutorial', profile.get_int('tutorial')))
+        account.add_child(Node.s16('area_id', profile.get_int('area_id')))
+        account.add_child(Node.s16('lumina', profile.get_int('lumina', 300)))
+        account.add_child(Node.s16('read_news', profile.get_int('read_news')))
+        account.add_child(Node.bool('welcom_pack', profile.get_bool('welcom_pack')))
+        account.add_child(Node.s16_array('medal_set', profile.get_int_array('medal_set', 4)))
+        account.add_child(Node.s16_array('nice', profile.get_int_array('nice', 30, [-1] * 30)))
+        account.add_child(Node.s16_array('favorite_chara', profile.get_int_array('favorite_chara', 20, [-1] * 20)))
+        account.add_child(Node.s16_array('special_area', profile.get_int_array('special_area', 8)))
+        account.add_child(Node.s16_array('chocolate_charalist', profile.get_int_array('chocolate_charalist', 5, [-1] * 5)))
+        account.add_child(Node.s16_array('teacher_setting', profile.get_int_array('teacher_setting', 10)))
+
+        # Stuff we never change
+        account.add_child(Node.s8('staff', 0))
+        account.add_child(Node.s16('item_type', 0))
+        account.add_child(Node.s16('item_id', 0))
+        account.add_child(Node.s8('is_conv', 0))
+        account.add_child(Node.bool('meteor_flg', True))
+        account.add_child(Node.s16_array('license_data', [-1] * 20))
+
+        # Add statistics section
+        last_played = [x[0] for x in self.data.local.music.get_last_played(self.game, self.version, userid, 5)]
+        most_played = [x[0] for x in self.data.local.music.get_most_played(self.game, self.version, userid, 10)]
+        while len(last_played) < 5:
+            last_played.append(-1)
+        while len(most_played) < 10:
+            most_played.append(-1)
+
+        account.add_child(Node.s16_array('my_best', most_played))
+        account.add_child(Node.s16_array('latest_music', last_played))
+
+        # TODO: Hook up rivals for Pop'n music?
+        account.add_child(Node.u8('active_fr_num', 0))
+
+        # player statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        account.add_child(Node.s16('total_play_cnt', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s16('today_play_cnt', today_count))
+        account.add_child(Node.s16('consecutive_days', statistics.get_int('consecutive_days', 0)))
+        account.add_child(Node.s16('total_days', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s16('interval_day', 0))
+
+        # Set up info node
+        info = Node.void('info')
+        root.add_child(info)
+        info.add_child(Node.u16('ep', profile.get_int('ep')))
+
+        # Set up last information
+        config = Node.void('config')
+        root.add_child(config)
+        config.add_child(Node.u8('mode', profile.get_int('mode')))
+        config.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        config.add_child(Node.s16('music', profile.get_int('music', -1)))
+        config.add_child(Node.u8('sheet', profile.get_int('sheet')))
+        config.add_child(Node.s8('category', profile.get_int('category', -1)))
+        config.add_child(Node.s8('sub_category', profile.get_int('sub_category', -1)))
+        config.add_child(Node.s8('chara_category', profile.get_int('chara_category', -1)))
+        config.add_child(Node.s16('course_id', profile.get_int('course_id', -1)))
+        config.add_child(Node.s8('course_folder', profile.get_int('course_folder', -1)))
+        config.add_child(Node.s8('ms_banner_disp', profile.get_int('ms_banner_disp')))
+        config.add_child(Node.s8('ms_down_info', profile.get_int('ms_down_info')))
+        config.add_child(Node.s8('ms_side_info', profile.get_int('ms_side_info')))
+        config.add_child(Node.s8('ms_raise_type', profile.get_int('ms_raise_type')))
+        config.add_child(Node.s8('ms_rnd_type', profile.get_int('ms_rnd_type')))
+
+        # Player options
+        option = Node.void('option')
+        option_dict = profile.get_dict('option')
+        root.add_child(option)
+        option.add_child(Node.s16('hispeed', option_dict.get_int('hispeed')))
+        option.add_child(Node.u8('popkun', option_dict.get_int('popkun')))
+        option.add_child(Node.bool('hidden', option_dict.get_bool('hidden')))
+        option.add_child(Node.s16('hidden_rate', option_dict.get_int('hidden_rate')))
+        option.add_child(Node.bool('sudden', option_dict.get_bool('sudden')))
+        option.add_child(Node.s16('sudden_rate', option_dict.get_int('sudden_rate')))
+        option.add_child(Node.s8('randmir', option_dict.get_int('randmir')))
+        option.add_child(Node.s8('gauge_type', option_dict.get_int('gauge_type')))
+        option.add_child(Node.u8('ojama_0', option_dict.get_int('ojama_0')))
+        option.add_child(Node.u8('ojama_1', option_dict.get_int('ojama_1')))
+        option.add_child(Node.bool('forever_0', option_dict.get_bool('forever_0')))
+        option.add_child(Node.bool('forever_1', option_dict.get_bool('forever_1')))
+        option.add_child(Node.bool('full_setting', option_dict.get_bool('full_setting')))
+        option.add_child(Node.u8('judge', option_dict.get_int('judge')))
+
+        # Unknown custom category stuff?
+        custom_cate = Node.void('custom_cate')
+        root.add_child(custom_cate)
+        custom_cate.add_child(Node.s8('valid', 0))
+        custom_cate.add_child(Node.s8('lv_min', -1))
+        custom_cate.add_child(Node.s8('lv_max', -1))
+        custom_cate.add_child(Node.s8('medal_min', -1))
+        custom_cate.add_child(Node.s8('medal_max', -1))
+        custom_cate.add_child(Node.s8('friend_no', -1))
+        custom_cate.add_child(Node.s8('score_flg', -1))
+
+        # Set up achievements
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for achievement in achievements:
+            if achievement.type[:5] == 'item_':
+                itemtype = int(achievement.type[5:])
+                param = achievement.data.get_int('param')
+                is_new = achievement.data.get_bool('is_new')
+
+                item = Node.void('item')
+                root.add_child(item)
+                # Type is the type of unlock/item. Type 0 is song unlock in Eclale.
+                # In this case, the id is the song ID according to the game. Unclear
+                # what the param is supposed to be, but i've seen 8 and 0. Might be
+                # what chart is available?
+                item.add_child(Node.u8('type', itemtype))
+                item.add_child(Node.u16('id', achievement.id))
+                item.add_child(Node.u16('param', param))
+                item.add_child(Node.bool('is_new', is_new))
+
+            elif achievement.type == 'chara':
+                friendship = achievement.data.get_int('friendship')
+
+                chara = Node.void('chara_param')
+                root.add_child(chara)
+                chara.add_child(Node.u16('chara_id', achievement.id))
+                chara.add_child(Node.u16('friendship', friendship))
+
+            elif achievement.type == 'medal':
+                level = achievement.data.get_int('level')
+                exp = achievement.data.get_int('exp')
+                set_count = achievement.data.get_int('set_count')
+                get_count = achievement.data.get_int('get_count')
+
+                medal = Node.void('medal')
+                root.add_child(medal)
+                medal.add_child(Node.s16('medal_id', achievement.id))
+                medal.add_child(Node.s16('level', level))
+                medal.add_child(Node.s32('exp', exp))
+                medal.add_child(Node.s32('set_count', set_count))
+                medal.add_child(Node.s32('get_count', get_count))
+
+        # Unknown customizations
+        customize = Node.void('customize')
+        root.add_child(customize)
+        customize.add_child(Node.u16('effect_left', profile.get_int('effect_left')))
+        customize.add_child(Node.u16('effect_center', profile.get_int('effect_center')))
+        customize.add_child(Node.u16('effect_right', profile.get_int('effect_right')))
+        customize.add_child(Node.u16('hukidashi', profile.get_int('hukidashi')))
+        customize.add_child(Node.u16('comment_1', profile.get_int('comment_1')))
+        customize.add_child(Node.u16('comment_2', profile.get_int('comment_2')))
+
+        # NetVS section
+        netvs = Node.void('netvs')
+        root.add_child(netvs)
+        netvs.add_child(Node.s16_array('record', [0] * 6))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.s8_array('ojama_condition', [0] * 74))
+        netvs.add_child(Node.s8_array('set_ojama', [0] * 3))
+        netvs.add_child(Node.s8_array('set_recommend', [0] * 3))
+        netvs.add_child(Node.u32('netvs_play_cnt', 0))
+
+        # Event stuff
+        event = Node.void('event')
+        root.add_child(event)
+        event.add_child(Node.s16('enemy_medal', profile.get_int('event_enemy_medal')))
+        event.add_child(Node.s16('hp', profile.get_int('event_hp')))
+
+        # Stamp stuff
+        stamp = Node.void('stamp')
+        root.add_child(stamp)
+        stamp.add_child(Node.s16('stamp_id', profile.get_int('stamp_id')))
+        stamp.add_child(Node.s16('cnt', profile.get_int('stamp_cnt')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Set that we've seen this profile
+        newprofile.replace_bool('welcom_pack', True)
+
+        account = request.child('account')
+        if account is not None:
+            newprofile.replace_int('tutorial', account.child_value('tutorial'))
+            newprofile.replace_int('read_news', account.child_value('read_news'))
+            newprofile.replace_int('area_id', account.child_value('area_id'))
+            newprofile.replace_int('lumina', account.child_value('lumina'))
+            newprofile.replace_int_array('medal_set', 4, account.child_value('medal_set'))
+            newprofile.replace_int_array('nice', 30, account.child_value('nice'))
+            newprofile.replace_int_array('favorite_chara', 20, account.child_value('favorite_chara'))
+            newprofile.replace_int_array('special_area', 8, account.child_value('special_area'))
+            newprofile.replace_int_array('chocolate_charalist', 5, account.child_value('chocolate_charalist'))
+            newprofile.replace_int_array('teacher_setting', 10, account.child_value('teacher_setting'))
+
+        info = request.child('info')
+        if info is not None:
+            newprofile.replace_int('ep', info.child_value('ep'))
+
+        config = request.child('config')
+        if config is not None:
+            newprofile.replace_int('mode', config.child_value('mode'))
+            newprofile.replace_int('chara', config.child_value('chara'))
+            newprofile.replace_int('music', config.child_value('music'))
+            newprofile.replace_int('sheet', config.child_value('sheet'))
+            newprofile.replace_int('category', config.child_value('category'))
+            newprofile.replace_int('sub_category', config.child_value('sub_category'))
+            newprofile.replace_int('chara_category', config.child_value('chara_category'))
+            newprofile.replace_int('course_id', config.child_value('course_id'))
+            newprofile.replace_int('course_folder', config.child_value('course_folder'))
+            newprofile.replace_int('ms_banner_disp', config.child_value('ms_banner_disp'))
+            newprofile.replace_int('ms_down_info', config.child_value('ms_down_info'))
+            newprofile.replace_int('ms_side_info', config.child_value('ms_side_info'))
+            newprofile.replace_int('ms_raise_type', config.child_value('ms_raise_type'))
+            newprofile.replace_int('ms_rnd_type', config.child_value('ms_rnd_type'))
+
+        option_dict = newprofile.get_dict('option')
+        option = request.child('option')
+        if option is not None:
+            option_dict.replace_int('hispeed', option.child_value('hispeed'))
+            option_dict.replace_int('popkun', option.child_value('popkun'))
+            option_dict.replace_bool('hidden', option.child_value('hidden'))
+            option_dict.replace_int('hidden_rate', option.child_value('hidden_rate'))
+            option_dict.replace_bool('sudden', option.child_value('sudden'))
+            option_dict.replace_int('sudden_rate', option.child_value('sudden_rate'))
+            option_dict.replace_int('randmir', option.child_value('randmir'))
+            option_dict.replace_int('gauge_type', option.child_value('gauge_type'))
+            option_dict.replace_int('ojama_0', option.child_value('ojama_0'))
+            option_dict.replace_int('ojama_1', option.child_value('ojama_1'))
+            option_dict.replace_bool('forever_0', option.child_value('forever_0'))
+            option_dict.replace_bool('forever_1', option.child_value('forever_1'))
+            option_dict.replace_bool('full_setting', option.child_value('full_setting'))
+            option_dict.replace_int('judge', option.child_value('judge'))
+        newprofile.replace_dict('option', option_dict)
+
+        customize = request.child('customize')
+        if customize is not None:
+            newprofile.replace_int('effect_left', customize.child_value('effect_left'))
+            newprofile.replace_int('effect_center', customize.child_value('effect_center'))
+            newprofile.replace_int('effect_right', customize.child_value('effect_right'))
+            newprofile.replace_int('hukidashi', customize.child_value('hukidashi'))
+            newprofile.replace_int('comment_1', customize.child_value('comment_1'))
+            newprofile.replace_int('comment_2', customize.child_value('comment_2'))
+
+        event = request.child('event')
+        if event is not None:
+            newprofile.replace_int('event_enemy_medal', event.child_value('enemy_medal'))
+            newprofile.replace_int('event_hp', event.child_value('hp'))
+
+        stamp = request.child('stamp')
+        if stamp is not None:
+            newprofile.replace_int('stamp_id', stamp.child_value('stamp_id'))
+            newprofile.replace_int('stamp_cnt', stamp.child_value('cnt'))
+
+        # Extract achievements
+        for node in request.children:
+            if node.name == 'item':
+                itemid = node.child_value('id')
+                itemtype = node.child_value('type')
+                param = node.child_value('param')
+                is_new = node.child_value('is_new')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    itemid,
+                    'item_{}'.format(itemtype),
+                    {
+                        'param': param,
+                        'is_new': is_new,
+                    },
+                )
+
+            elif node.name == 'chara_param':
+                charaid = node.child_value('chara_id')
+                friendship = node.child_value('friendship')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    charaid,
+                    'chara',
+                    {
+                        'friendship': friendship,
+                    },
+                )
+
+            elif node.name == 'medal':
+                medalid = node.child_value('medal_id')
+                level = node.child_value('level')
+                exp = node.child_value('exp')
+                set_count = node.child_value('set_count')
+                get_count = node.child_value('get_count')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    medalid,
+                    'medal',
+                    {
+                        'level': level,
+                        'exp': exp,
+                        'set_count': set_count,
+                        'get_count': get_count,
+                    },
+                )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/popn/factory.py b/bemani/backend/popn/factory.py
new file mode 100644
index 0000000..6c3bb74
--- /dev/null
+++ b/bemani/backend/popn/factory.py
@@ -0,0 +1,133 @@
+from typing import Dict, Optional, Any
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.popn.stubs import (
+    PopnMusic,
+    PopnMusic2,
+    PopnMusic3,
+    PopnMusic4,
+    PopnMusic5,
+    PopnMusic6,
+    PopnMusic7,
+    PopnMusic8,
+    PopnMusic9,
+    PopnMusic10,
+    PopnMusic11,
+    PopnMusicIroha,
+    PopnMusicCarnival,
+    PopnMusicFever,
+    PopnMusicAdventure,
+    PopnMusicParty,
+    PopnMusicTheMovie,
+    PopnMusicSengokuRetsuden,
+)
+from bemani.backend.popn.tunestreet import PopnMusicTuneStreet
+from bemani.backend.popn.fantasia import PopnMusicFantasia
+from bemani.backend.popn.sunnypark import PopnMusicSunnyPark
+from bemani.backend.popn.lapistoria import PopnMusicLapistoria
+from bemani.backend.popn.eclale import PopnMusicEclale
+from bemani.backend.popn.usaneko import PopnMusicUsaNeko
+from bemani.backend.popn.peace import PopnMusicPeace
+from bemani.common import Model, VersionConstants
+from bemani.data import Data
+
+
+class PopnMusicFactory(Factory):
+
+    MANAGED_CLASSES = [
+        PopnMusic,
+        PopnMusic2,
+        PopnMusic3,
+        PopnMusic4,
+        PopnMusic5,
+        PopnMusic6,
+        PopnMusic7,
+        PopnMusic8,
+        PopnMusic9,
+        PopnMusic10,
+        PopnMusic11,
+        PopnMusicIroha,
+        PopnMusicCarnival,
+        PopnMusicFever,
+        PopnMusicAdventure,
+        PopnMusicParty,
+        PopnMusicTheMovie,
+        PopnMusicSengokuRetsuden,
+        PopnMusicTuneStreet,
+        PopnMusicFantasia,
+        PopnMusicSunnyPark,
+        PopnMusicLapistoria,
+        PopnMusicEclale,
+        PopnMusicUsaNeko,
+        PopnMusicPeace,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['G15', 'H16', 'I17', 'J39', 'K39', 'L39', 'M39']:
+            Base.register(game, PopnMusicFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        def version_from_date(date: int) -> Optional[int]:
+            if date <= 2014061900:
+                return VersionConstants.POPN_MUSIC_SUNNY_PARK
+            if date >= 2014062500 and date < 2015112600:
+                return VersionConstants.POPN_MUSIC_LAPISTORIA
+            if date >= 2015112600 and date < 2016121400:
+                return VersionConstants.POPN_MUSIC_ECLALE
+            if date >= 2016121400 and date < 2018101700:
+                return VersionConstants.POPN_MUSIC_USANEKO
+            if date >= 2018101700:
+                return VersionConstants.POPN_MUSIC_PEACE
+            return None
+
+        if model.game == 'G15':
+            return PopnMusicAdventure(data, config, model)
+        if model.game == 'H16':
+            return PopnMusicParty(data, config, model)
+        if model.game == 'I17':
+            return PopnMusicTheMovie(data, config, model)
+        if model.game == 'J39':
+            return PopnMusicSengokuRetsuden(data, config, model)
+        if model.game == 'K39':
+            return PopnMusicTuneStreet(data, config, model)
+        if model.game == 'L39':
+            return PopnMusicFantasia(data, config, model)
+        if model.game == 'M39':
+            if model.version is None:
+                if parentmodel is None:
+                    return None
+
+                # We have no way to tell apart newer versions. However, we can make
+                # an educated guess if we happen to be summoned for old profile lookup.
+                if parentmodel.game not in ['G15', 'H16', 'I17', 'J39', 'K39', 'L39', 'M39']:
+                    return None
+                parentversion = version_from_date(parentmodel.version)
+                if parentversion == VersionConstants.POPN_MUSIC_LAPISTORIA:
+                    return PopnMusicSunnyPark(data, config, model)
+                if parentversion == VersionConstants.POPN_MUSIC_ECLALE:
+                    return PopnMusicLapistoria(data, config, model)
+                if parentversion == VersionConstants.POPN_MUSIC_USANEKO:
+                    return PopnMusicEclale(data, config, model)
+                if parentversion == VersionConstants.POPN_MUSIC_PEACE:
+                    return PopnMusicUsaNeko(data, config, model)
+
+                # Unknown older version
+                return None
+
+            version = version_from_date(model.version)
+            if version == VersionConstants.POPN_MUSIC_SUNNY_PARK:
+                return PopnMusicSunnyPark(data, config, model)
+            if version == VersionConstants.POPN_MUSIC_LAPISTORIA:
+                return PopnMusicLapistoria(data, config, model)
+            if version == VersionConstants.POPN_MUSIC_ECLALE:
+                return PopnMusicEclale(data, config, model)
+            if version == VersionConstants.POPN_MUSIC_USANEKO:
+                return PopnMusicUsaNeko(data, config, model)
+            if version == VersionConstants.POPN_MUSIC_PEACE:
+                return PopnMusicPeace(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/popn/fantasia.py b/bemani/backend/popn/fantasia.py
new file mode 100644
index 0000000..3b4f273
--- /dev/null
+++ b/bemani/backend/popn/fantasia.py
@@ -0,0 +1,460 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.tunestreet import PopnMusicTuneStreet
+
+from bemani.backend.base import Status
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class PopnMusicFantasia(PopnMusicBase):
+
+    name = "Pop'n Music fantasia"
+    version = VersionConstants.POPN_MUSIC_FANTASIA
+
+    # Chart type, as returned from the game
+    GAME_CHART_TYPE_EASY = 2
+    GAME_CHART_TYPE_NORMAL = 0
+    GAME_CHART_TYPE_HYPER = 1
+    GAME_CHART_TYPE_EX = 3
+
+    # Chart type, as packed into a hiscore binary
+    GAME_CHART_TYPE_EASY_POSITION = 0
+    GAME_CHART_TYPE_NORMAL_POSITION = 1
+    GAME_CHART_TYPE_HYPER_POSITION = 2
+    GAME_CHART_TYPE_EX_POSITION = 3
+
+    # Medal type, as returned from the game
+    GAME_PLAY_MEDAL_CIRCLE_FAILED = 1
+    GAME_PLAY_MEDAL_DIAMOND_FAILED = 2
+    GAME_PLAY_MEDAL_STAR_FAILED = 3
+    GAME_PLAY_MEDAL_CIRCLE_CLEARED = 5
+    GAME_PLAY_MEDAL_DIAMOND_CLEARED = 6
+    GAME_PLAY_MEDAL_STAR_CLEARED = 7
+    GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO = 9
+    GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO = 10
+    GAME_PLAY_MEDAL_STAR_FULL_COMBO = 11
+    GAME_PLAY_MEDAL_PERFECT = 15
+
+    # Maximum music ID for this game
+    GAME_MAX_MUSIC_ID = 1150
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicTuneStreet(self.data, self.config, self.model)
+
+    def __format_medal_for_score(self, score: Score) -> int:
+        medal = {
+            self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+            self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+            self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+            self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,  # Map approximately
+            self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+            self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+            self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+            self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+            self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+            self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+            self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+        }[score.data.get_int('medal')]
+        position = {
+            self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY_POSITION,
+            self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL_POSITION,
+            self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER_POSITION,
+            self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX_POSITION,
+        }[score.chart]
+        return medal << (position * 4)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('playerdata')
+
+        # Set up the base profile
+        base = Node.void('base')
+        root.add_child(base)
+        base.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        base.add_child(Node.string('g_pm_id', ID.format_extid(profile.get_int('extid'))))
+        base.add_child(Node.u8('mode', profile.get_int('mode', 0)))
+        base.add_child(Node.s8('button', profile.get_int('button', 0)))
+        base.add_child(Node.s8('last_play_flag', profile.get_int('last_play_flag', -1)))
+        base.add_child(Node.u8('medal_and_friend', profile.get_int('medal_and_friend', 0)))
+        base.add_child(Node.s8('category', profile.get_int('category', -1)))
+        base.add_child(Node.s8('sub_category', profile.get_int('sub_category', -1)))
+        base.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        base.add_child(Node.s8('chara_category', profile.get_int('chara_category', -1)))
+        base.add_child(Node.u8('collabo', profile.get_int('collabo', 255)))
+        base.add_child(Node.u8('sheet', profile.get_int('sheet', 0)))
+        base.add_child(Node.s8('tutorial', profile.get_int('tutorial', 0)))
+        base.add_child(Node.s32('music_open_pt', profile.get_int('music_open_pt', 0)))
+        base.add_child(Node.s8('is_conv', -1))
+        base.add_child(Node.s32('option', profile.get_int('option', 0)))
+        base.add_child(Node.s16('music', profile.get_int('music', -1)))
+        base.add_child(Node.u16('ep', profile.get_int('ep', 0)))
+        base.add_child(Node.s32_array('sp_color_flg', profile.get_int_array('sp_color_flg', 2)))
+        base.add_child(Node.s32('read_news', profile.get_int('read_news', 0)))
+        base.add_child(Node.s16('consecutive_days_coupon', profile.get_int('consecutive_days_coupon', 0)))
+        base.add_child(Node.s8('staff', 0))
+
+        # Player card section
+        player_card_dict = profile.get_dict('player_card')
+        player_card = Node.void('player_card')
+        root.add_child(player_card)
+        player_card.add_child(Node.u8_array('title', player_card_dict.get_int_array('title', 2, [0, 1])))
+        player_card.add_child(Node.u8('frame', player_card_dict.get_int('frame')))
+        player_card.add_child(Node.u8('base', player_card_dict.get_int('base')))
+        player_card.add_child(Node.u8_array('seal', player_card_dict.get_int_array('seal', 2)))
+        player_card.add_child(Node.s32_array('get_title', player_card_dict.get_int_array('get_title', 4)))
+        player_card.add_child(Node.s32('get_frame', player_card_dict.get_int('get_frame')))
+        player_card.add_child(Node.s32('get_base', player_card_dict.get_int('get_base')))
+        player_card.add_child(Node.s32_array('get_seal', player_card_dict.get_int_array('get_seal', 2)))
+
+        # Player card EX section
+        player_card_ex = Node.void('player_card_ex')
+        root.add_child(player_card_ex)
+        player_card_ex.add_child(Node.s32('get_title_ex', player_card_dict.get_int('get_title_ex')))
+        player_card_ex.add_child(Node.s32('get_frame_ex', player_card_dict.get_int('get_frame_ex')))
+        player_card_ex.add_child(Node.s32('get_base_ex', player_card_dict.get_int('get_base_ex')))
+        player_card_ex.add_child(Node.s32('get_seal_ex', player_card_dict.get_int('get_seal_ex')))
+
+        # Statistics section and scores section
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        base.add_child(Node.u8('active_fr_num', 0))  # TODO: Hook up rivals code?
+        base.add_child(Node.s32('total_play_cnt', statistics.get_int('total_plays', 0)))
+        base.add_child(Node.s16('today_play_cnt', today_count))
+        base.add_child(Node.s16('consecutive_days', statistics.get_int('consecutive_days', 0)))
+
+        last_played = [x[0] for x in self.data.local.music.get_last_played(self.game, self.version, userid, 3)]
+        most_played = [x[0] for x in self.data.local.music.get_most_played(self.game, self.version, userid, 20)]
+        while len(last_played) < 3:
+            last_played.append(-1)
+        while len(most_played) < 20:
+            most_played.append(-1)
+
+        hiscore_array = [0] * int((((self.GAME_MAX_MUSIC_ID * 4) * 17) + 7) / 8)
+        clear_medal = [0] * self.GAME_MAX_MUSIC_ID
+        clear_medal_sub = [0] * self.GAME_MAX_MUSIC_ID
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            clear_medal[score.id] = clear_medal[score.id] | self.__format_medal_for_score(score)
+
+            hiscore_index = (score.id * 4) + {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY_POSITION,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL_POSITION,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER_POSITION,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX_POSITION,
+            }[score.chart]
+            hiscore_byte_pos = int((hiscore_index * 17) / 8)
+            hiscore_bit_pos = int((hiscore_index * 17) % 8)
+            hiscore_value = points << hiscore_bit_pos
+            hiscore_array[hiscore_byte_pos] = hiscore_array[hiscore_byte_pos] | (hiscore_value & 0xFF)
+            hiscore_array[hiscore_byte_pos + 1] = hiscore_array[hiscore_byte_pos + 1] | ((hiscore_value >> 8) & 0xFF)
+            hiscore_array[hiscore_byte_pos + 2] = hiscore_array[hiscore_byte_pos + 2] | ((hiscore_value >> 16) & 0xFF)
+
+        hiscore = bytes(hiscore_array)
+
+        player_card.add_child(Node.s16_array('best_music', most_played[0:3]))
+        base.add_child(Node.s16_array('my_best', most_played))
+        base.add_child(Node.s16_array('latest_music', last_played))
+        base.add_child(Node.u16_array('clear_medal', clear_medal))
+        base.add_child(Node.u8_array('clear_medal_sub', clear_medal_sub))
+
+        # Goes outside of base for some reason
+        root.add_child(Node.binary('hiscore', hiscore))
+
+        # Net VS section
+        netvs = Node.void('netvs')
+        root.add_child(netvs)
+        netvs.add_child(Node.s32_array('get_ojama', [0, 0]))
+        netvs.add_child(Node.s32('rank_point', 0))
+        netvs.add_child(Node.s32('play_point', 0))
+        netvs.add_child(Node.s16_array('record', [0, 0, 0, 0, 0, 0]))
+        netvs.add_child(Node.u8('rank', 0))
+        netvs.add_child(Node.s8_array('ojama_condition', [0] * 74))
+        netvs.add_child(Node.s8_array('set_ojama', [0, 0, 0]))
+        netvs.add_child(Node.s8_array('set_recommend', [0, 0, 0]))
+        netvs.add_child(Node.s8_array('jewelry', [0] * 15))
+        for dialog in [0, 1, 2, 3, 4, 5]:
+            # TODO: Configure this, maybe?
+            netvs.add_child(Node.string('dialog', 'dialog#{}'.format(dialog)))
+
+        sp_data = Node.void('sp_data')
+        root.add_child(sp_data)
+        sp_data.add_child(Node.s32('sp', profile.get_int('sp', 0)))
+
+        reflec_data = Node.void('reflec_data')
+        root.add_child(reflec_data)
+        reflec_data.add_child(Node.s8_array('reflec', profile.get_int_array('reflec', 2)))
+
+        # Navigate section
+        navigate_dict = profile.get_dict('navigate')
+        navigate = Node.void('navigate')
+        root.add_child(navigate)
+        navigate.add_child(Node.s8('genre', navigate_dict.get_int('genre')))
+        navigate.add_child(Node.s8('image', navigate_dict.get_int('image')))
+        navigate.add_child(Node.s8('level', navigate_dict.get_int('level')))
+        navigate.add_child(Node.s8('ojama', navigate_dict.get_int('ojama')))
+        navigate.add_child(Node.s16('limit_num', navigate_dict.get_int('limit_num')))
+        navigate.add_child(Node.s8('button', navigate_dict.get_int('button')))
+        navigate.add_child(Node.s8('life', navigate_dict.get_int('life')))
+        navigate.add_child(Node.s16('progress', navigate_dict.get_int('progress')))
+
+        return root
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('playerdata')
+
+        root.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        root.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        root.add_child(Node.s32('option', profile.get_int('option', 0)))
+        root.add_child(Node.u8('version', 0))
+        root.add_child(Node.u8('kind', 0))
+        root.add_child(Node.u8('season', 0))
+
+        clear_medal = [0] * self.GAME_MAX_MUSIC_ID
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            clear_medal[score.id] = clear_medal[score.id] | self.__format_medal_for_score(score)
+
+        root.add_child(Node.u16_array('clear_medal', clear_medal))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        # For some reason, Pop'n 20 sends us two profile saves, one with 'not done yet'
+        # so we only want to process the done yet node. The 'not gameover' save has
+        # jubeat collabo stuff set in it, but we don't use that so it doesn't matter.
+        if request.child_value('is_not_gameover') == 1:
+            return oldprofile
+
+        newprofile = copy.deepcopy(oldprofile)
+        newprofile.replace_int('option', request.child_value('option'))
+        newprofile.replace_int('chara', request.child_value('chara'))
+        newprofile.replace_int('mode', request.child_value('mode'))
+        newprofile.replace_int('button', request.child_value('button'))
+        newprofile.replace_int('music', request.child_value('music'))
+        newprofile.replace_int('sheet', request.child_value('sheet'))
+        newprofile.replace_int('last_play_flag', request.child_value('last_play_flag'))
+        newprofile.replace_int('category', request.child_value('category'))
+        newprofile.replace_int('sub_category', request.child_value('sub_category'))
+        newprofile.replace_int('chara_category', request.child_value('chara_category'))
+        newprofile.replace_int('medal_and_friend', request.child_value('medal_and_friend'))
+        newprofile.replace_int('ep', request.child_value('ep'))
+        newprofile.replace_int_array('sp_color_flg', 2, request.child_value('sp_color_flg'))
+        newprofile.replace_int('read_news', request.child_value('read_news'))
+        newprofile.replace_int('consecutive_days_coupon', request.child_value('consecutive_days_coupon'))
+        newprofile.replace_int('tutorial', request.child_value('tutorial'))
+        newprofile.replace_int('music_open_pt', request.child_value('music_open_pt'))
+        newprofile.replace_int('collabo', request.child_value('collabo'))
+
+        sp_node = request.child('sp_data')
+        if sp_node is not None:
+            newprofile.replace_int('sp', sp_node.child_value('sp'))
+
+        reflec_node = request.child('reflec_data')
+        if reflec_node is not None:
+            newprofile.replace_int_array('reflec', 2, reflec_node.child_value('reflec'))
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        # Extract player card stuff
+        player_card_dict = newprofile.get_dict('player_card')
+        player_card_dict.replace_int_array('title', 2, request.child_value('title'))
+        player_card_dict.replace_int('frame', request.child_value('frame'))
+        player_card_dict.replace_int('base', request.child_value('base'))
+        player_card_dict.replace_int_array('seal', 2, request.child_value('seal'))
+        player_card_dict.replace_int_array('get_title', 4, request.child_value('get_title'))
+        player_card_dict.replace_int('get_frame', request.child_value('get_frame'))
+        player_card_dict.replace_int('get_base', request.child_value('get_base'))
+        player_card_dict.replace_int_array('get_seal', 2, request.child_value('get_seal'))
+
+        player_card_ex = request.child('player_card_ex')
+        if player_card_ex is not None:
+            player_card_dict.replace_int('get_title_ex', player_card_ex.child_value('get_title_ex'))
+            player_card_dict.replace_int('get_frame_ex', player_card_ex.child_value('get_frame_ex'))
+            player_card_dict.replace_int('get_base_ex', player_card_ex.child_value('get_base_ex'))
+            player_card_dict.replace_int('get_seal_ex', player_card_ex.child_value('get_seal_ex'))
+        newprofile.replace_dict('player_card', player_card_dict)
+
+        # Extract navigate stuff
+        navigate_dict = newprofile.get_dict('navigate')
+        navigate = request.child('navigate')
+        if navigate is not None:
+            navigate_dict.replace_int('genre', navigate.child_value('genre'))
+            navigate_dict.replace_int('image', navigate.child_value('image'))
+            navigate_dict.replace_int('level', navigate.child_value('level'))
+            navigate_dict.replace_int('ojama', navigate.child_value('ojama'))
+            navigate_dict.replace_int('limit_num', navigate.child_value('limit_num'))
+            navigate_dict.replace_int('button', navigate.child_value('button'))
+            navigate_dict.replace_int('life', navigate.child_value('life'))
+            navigate_dict.replace_int('progress', navigate.child_value('progress'))
+        newprofile.replace_dict('navigate', navigate_dict)
+
+        # Extract scores
+        for node in request.children:
+            if node.name == 'stage':
+                songid = node.child_value('no')
+                chart = {
+                    self.GAME_CHART_TYPE_EASY: self.CHART_TYPE_EASY,
+                    self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL,
+                    self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER,
+                    self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX,
+                }[node.child_value('sheet')]
+                medal = (node.child_value('n_data') >> (chart * 4)) & 0x000F
+                medal = {
+                    self.GAME_PLAY_MEDAL_CIRCLE_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED,
+                    self.GAME_PLAY_MEDAL_DIAMOND_FAILED: self.PLAY_MEDAL_DIAMOND_FAILED,
+                    self.GAME_PLAY_MEDAL_STAR_FAILED: self.PLAY_MEDAL_STAR_FAILED,
+                    self.GAME_PLAY_MEDAL_CIRCLE_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED,
+                    self.GAME_PLAY_MEDAL_DIAMOND_CLEARED: self.PLAY_MEDAL_DIAMOND_CLEARED,
+                    self.GAME_PLAY_MEDAL_STAR_CLEARED: self.PLAY_MEDAL_STAR_CLEARED,
+                    self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                    self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO: self.PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                    self.GAME_PLAY_MEDAL_STAR_FULL_COMBO: self.PLAY_MEDAL_STAR_FULL_COMBO,
+                    self.GAME_PLAY_MEDAL_PERFECT: self.PLAY_MEDAL_PERFECT,
+                }[medal]
+                points = node.child_value('score')
+                self.update_score(userid, songid, chart, points, medal)
+
+        return newprofile
+
+    def handle_playerdata_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'expire':
+            return Node.void('playerdata')
+
+        elif method == 'logout':
+            return Node.void('playerdata')
+
+        elif method == 'get':
+            modelstring = request.attribute('model')
+            refid = request.child_value('ref_id')
+            root = self.get_profile_by_refid(
+                refid,
+                self.NEW_PROFILE_ONLY if modelstring is None else self.OLD_PROFILE_ONLY,
+            )
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'conversion':
+            refid = request.child_value('ref_id')
+            name = request.child_value('name')
+            chara = request.child_value('chara')
+            root = self.new_profile_by_refid(refid, name, chara)
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'new':
+            refid = request.child_value('ref_id')
+            name = request.child_value('name')
+            root = self.new_profile_by_refid(refid, name)
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'set':
+            refid = request.attribute('ref_id')
+
+            root = Node.void('playerdata')
+            root.add_child(Node.s8('pref', -1))
+            if refid is None:
+                return root
+
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is None:
+                return root
+
+            oldprofile = self.get_profile(userid) or ValidatedDict()
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+
+            if newprofile is not None:
+                self.put_profile(userid, newprofile)
+                root.add_child(Node.string('name', newprofile['name']))
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_game_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'get':
+            # TODO: Hook these up to config so we can change this
+            root = Node.void('game')
+            root.add_child(Node.s32('game_phase', 2))
+            root.add_child(Node.s32('ir_phase', 0))
+            root.add_child(Node.s32('event_phase', 5))
+            root.add_child(Node.s32('netvs_phase', 0))
+            root.add_child(Node.s32('card_phase', 6))
+            root.add_child(Node.s32('illust_phase', 2))
+            root.add_child(Node.s32('psp_phase', 5))
+            root.add_child(Node.s32('other_phase', 1))
+            root.add_child(Node.s32('jubeat_phase', 1))
+            root.add_child(Node.s32('public_phase', 3))
+            root.add_child(Node.s32('kac_phase', 2))
+            root.add_child(Node.s32('local_matching', 1))
+            root.add_child(Node.s32('n_matching_sec', 60))
+            root.add_child(Node.s32('l_matching_sec', 60))
+            root.add_child(Node.s32('is_check_cpu', 0))
+            root.add_child(Node.s32('week_no', 0))
+            root.add_child(Node.s32_array('ng_illust', [0] * 10))
+            root.add_child(Node.s16_array('sel_ranking', [-1] * 10))
+            root.add_child(Node.s16_array('up_ranking', [-1] * 10))
+            return root
+
+        if method == 'active':
+            # Update the name of this cab for admin purposes
+            self.update_machine_name(request.child_value('shop_name'))
+            return Node.void('game')
+
+        if method == 'taxphase':
+            return Node.void('game')
+
+        # Invalid method
+        return None
diff --git a/bemani/backend/popn/lapistoria.py b/bemani/backend/popn/lapistoria.py
new file mode 100644
index 0000000..afd84f2
--- /dev/null
+++ b/bemani/backend/popn/lapistoria.py
@@ -0,0 +1,641 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.sunnypark import PopnMusicSunnyPark
+
+from bemani.backend.base import Status
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class PopnMusicLapistoria(PopnMusicBase):
+
+    name = "Pop'n Music ラピストリア"
+    version = VersionConstants.POPN_MUSIC_LAPISTORIA
+
+    # Chart type, as returned from the game
+    GAME_CHART_TYPE_EASY = 0
+    GAME_CHART_TYPE_NORMAL = 1
+    GAME_CHART_TYPE_HYPER = 2
+    GAME_CHART_TYPE_EX = 3
+
+    # Medal type, as returned from the game
+    GAME_PLAY_MEDAL_CIRCLE_FAILED = 1
+    GAME_PLAY_MEDAL_DIAMOND_FAILED = 2
+    GAME_PLAY_MEDAL_STAR_FAILED = 3
+    GAME_PLAY_MEDAL_EASY_CLEAR = 4
+    GAME_PLAY_MEDAL_CIRCLE_CLEARED = 5
+    GAME_PLAY_MEDAL_DIAMOND_CLEARED = 6
+    GAME_PLAY_MEDAL_STAR_CLEARED = 7
+    GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO = 8
+    GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO = 9
+    GAME_PLAY_MEDAL_STAR_FULL_COMBO = 10
+    GAME_PLAY_MEDAL_PERFECT = 11
+
+    # Max valud music ID for conversions and stuff
+    GAME_MAX_MUSIC_ID = 1422
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicSunnyPark(self.data, self.config, self.model)
+
+    def handle_info22_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'common':
+            # TODO: Hook these up to config so we can change this
+            phases = {
+                # Unknown event
+                0: 0,
+                # Unknown event
+                1: 0,
+                # Pop'n Aura, max 10 (remov all aura requirements)
+                2: 10,
+                # Story
+                3: 1,
+                # BEMANI ruins Discovery!
+                4: 0,
+                # Unknown event
+                5: 0,
+                # Unknown event
+                6: 0,
+                # Unknown event
+                7: 0,
+                # Unknown event
+                8: 0,
+                # Unknown event
+                9: 0,
+                # Unknown event
+                10: 0,
+                # Unknown event
+                11: 0,
+                # Unknown event
+                12: 0,
+                # Unknown event
+                13: 0,
+                # Unknown event
+                14: 0,
+                # Unknown event
+                15: 0,
+                # Unknown event
+                16: 0,
+                # Unknown event
+                17: 0,
+                # Unknown event
+                18: 0,
+                # Unknown event
+                19: 0,
+            }
+            stories = list(range(173))
+
+            root = Node.void('info22')
+            for phaseid in phases:
+                phase = Node.void('phase')
+                root.add_child(phase)
+                phase.add_child(Node.s16('event_id', phaseid))
+                phase.add_child(Node.s16('phase', phases[phaseid]))
+
+            for storyid in stories:
+                story = Node.void('story')
+                root.add_child(story)
+                story.add_child(Node.u32('story_id', storyid))
+                story.add_child(Node.bool('is_limited', False))
+                story.add_child(Node.u64('limit_date', 0))
+
+            return root
+
+        # Invalid method
+        return None
+
+    def handle_pcb22_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'boot':
+            return Node.void('pcb22')
+        elif method == 'error':
+            return Node.void('pcb22')
+        elif method == 'write':
+            # Update the name of this cab for admin purposes
+            self.update_machine_name(request.child_value('pcb_setting/name'))
+            return Node.void('pcb22')
+
+        # Invalid method
+        return None
+
+    def handle_lobby22_request(self, request: Node) -> Optional[Node]:
+        # Stub out the entire lobby22 service
+        return Node.void('lobby22')
+
+    def handle_player22_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'read':
+            refid = request.child_value('ref_id')
+            # Pop'n Music 22 doesn't send a modelstring to load old profiles,
+            # it just expects us to know. So always look for old profiles in
+            # Pop'n 22 land.
+            root = self.get_profile_by_refid(refid, self.OLD_PROFILE_FALLTHROUGH)
+            if root is None:
+                root = Node.void('player22')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'new':
+            refid = request.child_value('ref_id')
+            name = request.child_value('name')
+            root = self.new_profile_by_refid(refid, name)
+            if root is None:
+                root = Node.void('player22')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'start':
+            return Node.void('player22')
+
+        elif method == 'logout':
+            return Node.void('player22')
+
+        elif method == 'write':
+            refid = request.child_value('ref_id')
+
+            root = Node.void('player22')
+            if refid is None:
+                return root
+
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is None:
+                return root
+
+            oldprofile = self.get_profile(userid) or ValidatedDict()
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+
+            if newprofile is not None:
+                self.put_profile(userid, newprofile)
+
+            return root
+
+        elif method == 'conversion':
+            refid = request.child_value('ref_id')
+            name = request.child_value('name')
+            chara = request.child_value('chara')
+            root = self.new_profile_by_refid(refid, name, chara)
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'write_music':
+            refid = request.child_value('ref_id')
+
+            root = Node.void('player22')
+            if refid is None:
+                return root
+
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is None:
+                return root
+
+            songid = request.child_value('music_num')
+            chart = {
+                self.GAME_CHART_TYPE_EASY: self.CHART_TYPE_EASY,
+                self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL,
+                self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER,
+                self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX,
+            }[request.child_value('sheet_num')]
+            medal = request.child_value('clearmedal')
+            points = request.child_value('score')
+            combo = request.child_value('combo')
+            stats = {
+                'cool': request.child_value('cool'),
+                'great': request.child_value('great'),
+                'good': request.child_value('good'),
+                'bad': request.child_value('bad')
+            }
+            medal = {
+                self.GAME_PLAY_MEDAL_CIRCLE_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED,
+                self.GAME_PLAY_MEDAL_DIAMOND_FAILED: self.PLAY_MEDAL_DIAMOND_FAILED,
+                self.GAME_PLAY_MEDAL_STAR_FAILED: self.PLAY_MEDAL_STAR_FAILED,
+                self.GAME_PLAY_MEDAL_EASY_CLEAR: self.PLAY_MEDAL_EASY_CLEAR,
+                self.GAME_PLAY_MEDAL_CIRCLE_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED,
+                self.GAME_PLAY_MEDAL_DIAMOND_CLEARED: self.PLAY_MEDAL_DIAMOND_CLEARED,
+                self.GAME_PLAY_MEDAL_STAR_CLEARED: self.PLAY_MEDAL_STAR_CLEARED,
+                self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO: self.PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.GAME_PLAY_MEDAL_STAR_FULL_COMBO: self.PLAY_MEDAL_STAR_FULL_COMBO,
+                self.GAME_PLAY_MEDAL_PERFECT: self.PLAY_MEDAL_PERFECT,
+            }[medal]
+            self.update_score(userid, songid, chart, points, medal, combo=combo, stats=stats)
+            return root
+
+        # Invalid method
+        return None
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('player22')
+
+        # Result
+        root.add_child(Node.s8('result', 0))
+
+        # Set up account
+        account = Node.void('account')
+        root.add_child(account)
+        account.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        account.add_child(Node.string('g_pm_id', ID.format_extid(profile.get_int('extid'))))
+        account.add_child(Node.s8('tutorial', profile.get_int('tutorial', -1)))
+        account.add_child(Node.s16('read_news', profile.get_int('read_news', 0)))
+        account.add_child(Node.s8('staff', 0))
+        account.add_child(Node.s8('is_conv', 0))
+        account.add_child(Node.s16('item_type', 0))
+        account.add_child(Node.s16('item_id', 0))
+        account.add_child(Node.s16_array('license_data', [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
+
+        # Statistics section and scores section
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        account.add_child(Node.u8('active_fr_num', 0))  # TODO: Hook up rivals code?
+        account.add_child(Node.s16('total_play_cnt', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s16('today_play_cnt', today_count))
+        account.add_child(Node.s16('consecutive_days', statistics.get_int('consecutive_days', 0)))
+        account.add_child(Node.s16('total_days', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s16('interval_day', 0))
+
+        # Add scores section
+        last_played = [x[0] for x in self.data.local.music.get_last_played(self.game, self.version, userid, 5)]
+        most_played = [x[0] for x in self.data.local.music.get_most_played(self.game, self.version, userid, 10)]
+        while len(last_played) < 5:
+            last_played.append(-1)
+        while len(most_played) < 10:
+            most_played.append(-1)
+
+        account.add_child(Node.s16_array('my_best', most_played))
+        account.add_child(Node.s16_array('latest_music', last_played))
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            medal = score.data.get_int('medal')
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s16('cnt', score.plays))
+            music.add_child(Node.s32('score', points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[medal]))
+            music.add_child(Node.s32('old_score', 0))
+            music.add_child(Node.u8('old_clear_type', 0))
+
+        # Net VS section
+        netvs = Node.void('netvs')
+        root.add_child(netvs)
+        netvs.add_child(Node.s32('rank_point', 0))
+        netvs.add_child(Node.s16_array('record', [0, 0, 0, 0, 0, 0]))
+        netvs.add_child(Node.u8('rank', 0))
+        netvs.add_child(Node.s8('vs_rank_old', 0))
+        netvs.add_child(Node.s8_array('ojama_condition', [0] * 74))
+        netvs.add_child(Node.s8_array('set_ojama', [0, 0, 0]))
+        netvs.add_child(Node.s8_array('set_recommend', [0, 0, 0]))
+        netvs.add_child(Node.u32('netvs_play_cnt', 0))
+        for dialog in [0, 1, 2, 3, 4, 5]:
+            # TODO: Configure this, maybe?
+            netvs.add_child(Node.string('dialog', 'dialog#{}'.format(dialog)))
+
+        # Set up config
+        config = Node.void('config')
+        root.add_child(config)
+        config.add_child(Node.u8('mode', profile.get_int('mode', 0)))
+        config.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        config.add_child(Node.s16('music', profile.get_int('music', -1)))
+        config.add_child(Node.u8('sheet', profile.get_int('sheet', 0)))
+        config.add_child(Node.s8('category', profile.get_int('category', 1)))
+        config.add_child(Node.s8('sub_category', profile.get_int('sub_category', -1)))
+        config.add_child(Node.s8('chara_category', profile.get_int('chara_category', -1)))
+        config.add_child(Node.s16('story_id', profile.get_int('story_id', -1)))
+        config.add_child(Node.s16('course_id', profile.get_int('course_id', -1)))
+        config.add_child(Node.s8('course_folder', profile.get_int('course_folder', -1)))
+        config.add_child(Node.s8('story_folder', profile.get_int('story_folder', -1)))
+        config.add_child(Node.s8('ms_banner_disp', profile.get_int('ms_banner_disp')))
+        config.add_child(Node.s8('ms_down_info', profile.get_int('ms_down_info')))
+        config.add_child(Node.s8('ms_side_info', profile.get_int('ms_side_info')))
+        config.add_child(Node.s8('ms_raise_type', profile.get_int('ms_raise_type')))
+        config.add_child(Node.s8('ms_rnd_type', profile.get_int('ms_rnd_type')))
+
+        # Set up option
+        option_dict = profile.get_dict('option')
+        option = Node.void('option')
+        root.add_child(option)
+        option.add_child(Node.s16('hispeed', option_dict.get_int('hispeed', 10)))
+        option.add_child(Node.u8('popkun', option_dict.get_int('popkun', 0)))
+        option.add_child(Node.bool('hidden', option_dict.get_bool('hidden', False)))
+        option.add_child(Node.s16('hidden_rate', option_dict.get_int('hidden_rate', -1)))
+        option.add_child(Node.bool('sudden', option_dict.get_bool('sudden', False)))
+        option.add_child(Node.s16('sudden_rate', option_dict.get_int('sudden_rate', -1)))
+        option.add_child(Node.s8('randmir', option_dict.get_int('randmir', 0)))
+        option.add_child(Node.s8('gauge_type', option_dict.get_int('gauge_type', 0)))
+        option.add_child(Node.u8('ojama_0', option_dict.get_int('ojama_0', 0)))
+        option.add_child(Node.u8('ojama_1', option_dict.get_int('ojama_1', 0)))
+        option.add_child(Node.bool('forever_0', option_dict.get_bool('forever_0', False)))
+        option.add_child(Node.bool('forever_1', option_dict.get_bool('forever_1', False)))
+        option.add_child(Node.bool('full_setting', option_dict.get_bool('full_setting', False)))
+
+        # Set up info
+        info = Node.void('info')
+        root.add_child(info)
+        info.add_child(Node.u16('ep', profile.get_int('ep', 0)))
+        info.add_child(Node.u16('ap', profile.get_int('ap', 0)))
+
+        # Set up custom_cate
+        custom_cate = Node.void('custom_cate')
+        root.add_child(custom_cate)
+        custom_cate.add_child(Node.s8('valid', 0))
+        custom_cate.add_child(Node.s8('lv_min', -1))
+        custom_cate.add_child(Node.s8('lv_max', -1))
+        custom_cate.add_child(Node.s8('medal_min', -1))
+        custom_cate.add_child(Node.s8('medal_max', -1))
+        custom_cate.add_child(Node.s8('friend_no', -1))
+        custom_cate.add_child(Node.s8('score_flg', -1))
+
+        # Set up customize
+        customize_dict = profile.get_dict('customize')
+        customize = Node.void('customize')
+        root.add_child(customize)
+        customize.add_child(Node.u16('effect', customize_dict.get_int('effect')))
+        customize.add_child(Node.u16('hukidashi', customize_dict.get_int('hukidashi')))
+        customize.add_child(Node.u16('font', customize_dict.get_int('font')))
+        customize.add_child(Node.u16('comment_1', customize_dict.get_int('comment_1')))
+        customize.add_child(Node.u16('comment_2', customize_dict.get_int('comment_2')))
+
+        # Set up achievements
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for achievement in achievements:
+            if achievement.type == 'item':
+                itemtype = achievement.data.get_int('type')
+                param = achievement.data.get_int('param')
+
+                item = Node.void('item')
+                root.add_child(item)
+                item.add_child(Node.u8('type', itemtype))
+                item.add_child(Node.u16('id', achievement.id))
+                item.add_child(Node.u16('param', param))
+                item.add_child(Node.bool('is_new', False))
+
+            elif achievement.type == 'achievement':
+                count = achievement.data.get_int('count')
+
+                ach_node = Node.void('achievement')
+                root.add_child(ach_node)
+                ach_node.add_child(Node.u8('type', achievement.id))
+                ach_node.add_child(Node.u32('count', count))
+
+            elif achievement.type == 'chara':
+                friendship = achievement.data.get_int('friendship')
+
+                chara = Node.void('chara_param')
+                root.add_child(chara)
+                chara.add_child(Node.u16('chara_id', achievement.id))
+                chara.add_child(Node.u16('friendship', friendship))
+
+            elif achievement.type == 'story':
+                chapter = achievement.data.get_int('chapter')
+                gauge = achievement.data.get_int('gauge')
+                cleared = achievement.data.get_bool('cleared')
+                clear_chapter = achievement.data.get_int('clear_chapter')
+
+                story = Node.void('story')
+                root.add_child(story)
+                story.add_child(Node.u32('story_id', achievement.id))
+                story.add_child(Node.u32('chapter_id', chapter))
+                story.add_child(Node.u16('gauge_point', gauge))
+                story.add_child(Node.bool('is_cleared', cleared))
+                story.add_child(Node.u32('clear_chapter', clear_chapter))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        account = request.child('account')
+        if account is not None:
+            newprofile.replace_int('tutorial', account.child_value('tutorial'))
+            newprofile.replace_int('read_news', account.child_value('read_news'))
+
+        info = request.child('info')
+        if info is not None:
+            newprofile.replace_int('ep', info.child_value('ep'))
+            newprofile.replace_int('ap', info.child_value('ap'))
+
+        config = request.child('config')
+        if config is not None:
+            newprofile.replace_int('mode', config.child_value('mode'))
+            newprofile.replace_int('chara', config.child_value('chara'))
+            newprofile.replace_int('music', config.child_value('music'))
+            newprofile.replace_int('sheet', config.child_value('sheet'))
+            newprofile.replace_int('category', config.child_value('category'))
+            newprofile.replace_int('sub_category', config.child_value('sub_category'))
+            newprofile.replace_int('chara_category', config.child_value('chara_category'))
+            newprofile.replace_int('story_id', config.child_value('story_id'))
+            newprofile.replace_int('course_id', config.child_value('course_id'))
+            newprofile.replace_int('course_folder', config.child_value('course_folder'))
+            newprofile.replace_int('story_folder', config.child_value('story_folder'))
+            newprofile.replace_int('ms_banner_disp', config.child_value('ms_banner_disp'))
+            newprofile.replace_int('ms_down_info', config.child_value('ms_down_info'))
+            newprofile.replace_int('ms_side_info', config.child_value('ms_side_info'))
+            newprofile.replace_int('ms_raise_type', config.child_value('ms_raise_type'))
+            newprofile.replace_int('ms_rnd_type', config.child_value('ms_rnd_type'))
+
+        option_dict = newprofile.get_dict('option')
+        option = request.child('option')
+        if option is not None:
+            option_dict.replace_int('hispeed', option.child_value('hispeed'))
+            option_dict.replace_int('popkun', option.child_value('popkun'))
+            option_dict.replace_bool('hidden', option.child_value('hidden'))
+            option_dict.replace_bool('sudden', option.child_value('sudden'))
+            option_dict.replace_int('hidden_rate', option.child_value('hidden_rate'))
+            option_dict.replace_int('sudden_rate', option.child_value('sudden_rate'))
+            option_dict.replace_int('randmir', option.child_value('randmir'))
+            option_dict.replace_int('gauge_type', option.child_value('gauge_type'))
+            option_dict.replace_int('ojama_0', option.child_value('ojama_0'))
+            option_dict.replace_int('ojama_1', option.child_value('ojama_1'))
+            option_dict.replace_bool('forever_0', option.child_value('forever_0'))
+            option_dict.replace_bool('forever_1', option.child_value('forever_1'))
+            option_dict.replace_bool('full_setting', option.child_value('full_setting'))
+        newprofile.replace_dict('option', option_dict)
+
+        customize_dict = newprofile.get_dict('customize')
+        customize = request.child('customize')
+        if customize is not None:
+            customize_dict.replace_int('effect', customize.child_value('effect'))
+            customize_dict.replace_int('hukidashi', customize.child_value('hukidashi'))
+            customize_dict.replace_int('font', customize.child_value('font'))
+            customize_dict.replace_int('comment_1', customize.child_value('comment_1'))
+            customize_dict.replace_int('comment_2', customize.child_value('comment_2'))
+        newprofile.replace_dict('customize', customize_dict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        # Extract achievements
+        for node in request.children:
+            if node.name == 'item':
+                if not node.child_value('is_new'):
+                    # No need to save this one
+                    continue
+
+                itemid = node.child_value('id')
+                itemtype = node.child_value('type')
+                param = node.child_value('param')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    itemid,
+                    'item',
+                    {
+                        'type': itemtype,
+                        'param': param,
+                    },
+                )
+
+            elif node.name == 'achievement':
+                achievementid = node.child_value('type')
+                count = node.child_value('count')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    achievementid,
+                    'achievement',
+                    {
+                        'count': count,
+                    },
+                )
+
+            elif node.name == 'chara_param':
+                charaid = node.child_value('chara_id')
+                friendship = node.child_value('friendship')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    charaid,
+                    'chara',
+                    {
+                        'friendship': friendship,
+                    },
+                )
+
+            elif node.name == 'story':
+                storyid = node.child_value('story_id')
+                chapter = node.child_value('chapter_id')
+                gauge = node.child_value('gauge_point')
+                cleared = node.child_value('is_cleared')
+                clear_chapter = node.child_value('clear_chapter')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    storyid,
+                    'story',
+                    {
+                        'chapter': chapter,
+                        'gauge': gauge,
+                        'cleared': cleared,
+                        'clear_chapter': clear_chapter,
+                    },
+                )
+
+        return newprofile
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        # Circular import, ugh
+        from bemani.backend.popn.eclale import PopnMusicEclale
+
+        root = Node.void('player23')
+        root.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        root.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        root.add_child(Node.s8('result', 1))
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            medal = score.data.get_int('medal')
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: PopnMusicEclale.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: PopnMusicEclale.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: PopnMusicEclale.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: PopnMusicEclale.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s32('score', points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: PopnMusicEclale.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: PopnMusicEclale.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: PopnMusicEclale.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: PopnMusicEclale.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: PopnMusicEclale.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: PopnMusicEclale.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: PopnMusicEclale.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: PopnMusicEclale.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: PopnMusicEclale.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: PopnMusicEclale.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: PopnMusicEclale.GAME_PLAY_MEDAL_PERFECT,
+            }[medal]))
+            music.add_child(Node.s16('cnt', score.plays))
+
+        return root
diff --git a/bemani/backend/popn/peace.py b/bemani/backend/popn/peace.py
new file mode 100644
index 0000000..64b0db9
--- /dev/null
+++ b/bemani/backend/popn/peace.py
@@ -0,0 +1,15 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.usaneko import PopnMusicUsaNeko
+from bemani.common import VersionConstants
+
+
+class PopnMusicPeace(PopnMusicBase):
+
+    name = "Pop'n Music peace"
+    version = VersionConstants.POPN_MUSIC_PEACE
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicUsaNeko(self.data, self.config, self.model)
diff --git a/bemani/backend/popn/stubs.py b/bemani/backend/popn/stubs.py
new file mode 100644
index 0000000..c27e43f
--- /dev/null
+++ b/bemani/backend/popn/stubs.py
@@ -0,0 +1,164 @@
+# vim: set fileencoding=utf-8
+from typing import Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.common import VersionConstants
+
+
+class PopnMusic(PopnMusicBase):
+
+    name = "Pop'n Music"
+    version = VersionConstants.POPN_MUSIC
+
+
+class PopnMusic2(PopnMusicBase):
+
+    name = "Pop'n Music 2"
+    version = VersionConstants.POPN_MUSIC_2
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic(self.data, self.config, self.model)
+
+
+class PopnMusic3(PopnMusicBase):
+
+    name = "Pop'n Music 3"
+    version = VersionConstants.POPN_MUSIC_3
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic2(self.data, self.config, self.model)
+
+
+class PopnMusic4(PopnMusicBase):
+
+    name = "Pop'n Music 4"
+    version = VersionConstants.POPN_MUSIC_4
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic3(self.data, self.config, self.model)
+
+
+class PopnMusic5(PopnMusicBase):
+
+    name = "Pop'n Music 5"
+    version = VersionConstants.POPN_MUSIC_5
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic4(self.data, self.config, self.model)
+
+
+class PopnMusic6(PopnMusicBase):
+
+    name = "Pop'n Music 6"
+    version = VersionConstants.POPN_MUSIC_6
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic5(self.data, self.config, self.model)
+
+
+class PopnMusic7(PopnMusicBase):
+
+    name = "Pop'n Music 7"
+    version = VersionConstants.POPN_MUSIC_7
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic6(self.data, self.config, self.model)
+
+
+class PopnMusic8(PopnMusicBase):
+
+    name = "Pop'n Music 8"
+    version = VersionConstants.POPN_MUSIC_8
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic7(self.data, self.config, self.model)
+
+
+class PopnMusic9(PopnMusicBase):
+
+    name = "Pop'n Music 9"
+    version = VersionConstants.POPN_MUSIC_9
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic8(self.data, self.config, self.model)
+
+
+class PopnMusic10(PopnMusicBase):
+
+    name = "Pop'n Music 10"
+    version = VersionConstants.POPN_MUSIC_10
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic9(self.data, self.config, self.model)
+
+
+class PopnMusic11(PopnMusicBase):
+
+    name = "Pop'n Music 11"
+    version = VersionConstants.POPN_MUSIC_11
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic10(self.data, self.config, self.model)
+
+
+class PopnMusicIroha(PopnMusicBase):
+
+    name = "Pop'n Music いろは"
+    version = VersionConstants.POPN_MUSIC_IROHA
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusic11(self.data, self.config, self.model)
+
+
+class PopnMusicCarnival(PopnMusicBase):
+
+    name = "Pop'n Music カーニバル"
+    version = VersionConstants.POPN_MUSIC_CARNIVAL
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicIroha(self.data, self.config, self.model)
+
+
+class PopnMusicFever(PopnMusicBase):
+
+    name = "Pop'n Music FEVER!"
+    version = VersionConstants.POPN_MUSIC_FEVER
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicCarnival(self.data, self.config, self.model)
+
+
+class PopnMusicAdventure(PopnMusicBase):
+
+    name = "Pop'n Music ADVENTURE"
+    version = VersionConstants.POPN_MUSIC_ADVENTURE
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicFever(self.data, self.config, self.model)
+
+
+class PopnMusicParty(PopnMusicBase):
+
+    name = "Pop'n Music Party♪"
+    version = VersionConstants.POPN_MUSIC_PARTY
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicAdventure(self.data, self.config, self.model)
+
+
+class PopnMusicTheMovie(PopnMusicBase):
+
+    name = "Pop'n Music THE MOVIE"
+    version = VersionConstants.POPN_MUSIC_THE_MOVIE
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicParty(self.data, self.config, self.model)
+
+
+class PopnMusicSengokuRetsuden(PopnMusicBase):
+
+    name = "Pop'n Music せんごく列伝"
+    version = VersionConstants.POPN_MUSIC_SENGOKU_RETSUDEN
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicTheMovie(self.data, self.config, self.model)
diff --git a/bemani/backend/popn/sunnypark.py b/bemani/backend/popn/sunnypark.py
new file mode 100644
index 0000000..f06f1ff
--- /dev/null
+++ b/bemani/backend/popn/sunnypark.py
@@ -0,0 +1,529 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.fantasia import PopnMusicFantasia
+
+from bemani.backend.base import Status
+from bemani.common import ValidatedDict, VersionConstants, Time, ID
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class PopnMusicSunnyPark(PopnMusicBase):
+
+    name = "Pop'n Music Sunny Park"
+    version = VersionConstants.POPN_MUSIC_SUNNY_PARK
+
+    # Chart type, as returned from the game
+    GAME_CHART_TYPE_EASY = 0
+    GAME_CHART_TYPE_NORMAL = 1
+    GAME_CHART_TYPE_HYPER = 2
+    GAME_CHART_TYPE_EX = 3
+
+    # Chart type, as packed into a hiscore binary
+    GAME_CHART_TYPE_EASY_POSITION = 0
+    GAME_CHART_TYPE_NORMAL_POSITION = 1
+    GAME_CHART_TYPE_HYPER_POSITION = 2
+    GAME_CHART_TYPE_EX_POSITION = 3
+
+    # Medal type, as returned from the game
+    GAME_PLAY_MEDAL_CIRCLE_FAILED = 1
+    GAME_PLAY_MEDAL_DIAMOND_FAILED = 2
+    GAME_PLAY_MEDAL_STAR_FAILED = 3
+    GAME_PLAY_MEDAL_CIRCLE_CLEARED = 5
+    GAME_PLAY_MEDAL_DIAMOND_CLEARED = 6
+    GAME_PLAY_MEDAL_STAR_CLEARED = 7
+    GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO = 9
+    GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO = 10
+    GAME_PLAY_MEDAL_STAR_FULL_COMBO = 11
+    GAME_PLAY_MEDAL_PERFECT = 15
+
+    # Maximum music ID for this game
+    GAME_MAX_MUSIC_ID = 1350
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicFantasia(self.data, self.config, self.model)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('playerdata')
+
+        # Set up the base profile
+        base = Node.void('base')
+        root.add_child(base)
+        base.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        base.add_child(Node.string('g_pm_id', ID.format_extid(profile.get_int('extid'))))
+        base.add_child(Node.u8('mode', profile.get_int('mode', 0)))
+        base.add_child(Node.s8('button', profile.get_int('button', 0)))
+        base.add_child(Node.s8('last_play_flag', profile.get_int('last_play_flag', -1)))
+        base.add_child(Node.u8('medal_and_friend', profile.get_int('medal_and_friend', 0)))
+        base.add_child(Node.s8('category', profile.get_int('category', -1)))
+        base.add_child(Node.s8('sub_category', profile.get_int('sub_category', -1)))
+        base.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        base.add_child(Node.s8('chara_category', profile.get_int('chara_category', -1)))
+        base.add_child(Node.u8('collabo', 255))
+        base.add_child(Node.u8('sheet', profile.get_int('sheet', 0)))
+        base.add_child(Node.s8('tutorial', profile.get_int('tutorial', 0)))
+        base.add_child(Node.s8('music_open_pt', profile.get_int('music_open_pt', 0)))
+        base.add_child(Node.s8('is_conv', -1))
+        base.add_child(Node.s32('option', profile.get_int('option', 0)))
+        base.add_child(Node.s16('music', profile.get_int('music', -1)))
+        base.add_child(Node.u16('ep', profile.get_int('ep', 0)))
+        base.add_child(Node.s32_array('sp_color_flg', profile.get_int_array('sp_color_flg', 2)))
+        base.add_child(Node.s32('read_news', profile.get_int('read_news', 0)))
+        base.add_child(Node.s16('consecutive_days_coupon', profile.get_int('consecutive_days_coupon', 0)))
+        base.add_child(Node.s8('staff', 0))
+        # These are probably from an old event, but if they aren't present and defaulted,
+        # then different songs show up in the Zoo event.
+        base.add_child(Node.u16_array('gitadora_point', profile.get_int_array('gitadora_point', 3, [2000, 2000, 2000])))
+        base.add_child(Node.u8('gitadora_select', profile.get_int('gitadora_select', 2)))
+
+        # Statistics section and scores section
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        base.add_child(Node.u8('active_fr_num', 0))  # TODO: Hook up rivals code?
+        base.add_child(Node.s32('total_play_cnt', statistics.get_int('total_plays', 0)))
+        base.add_child(Node.s16('today_play_cnt', today_count))
+        base.add_child(Node.s16('consecutive_days', statistics.get_int('consecutive_days', 0)))
+
+        last_played = [x[0] for x in self.data.local.music.get_last_played(self.game, self.version, userid, 3)]
+        most_played = [x[0] for x in self.data.local.music.get_most_played(self.game, self.version, userid, 20)]
+        while len(last_played) < 3:
+            last_played.append(-1)
+        while len(most_played) < 20:
+            most_played.append(-1)
+
+        hiscore_array = [0] * int((((self.GAME_MAX_MUSIC_ID * 4) * 17) + 7) / 8)
+        clear_medal = [0] * self.GAME_MAX_MUSIC_ID
+        clear_medal_sub = [0] * self.GAME_MAX_MUSIC_ID
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            medal = {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,  # Map approximately
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[score.data.get_int('medal')]
+            clear_medal[score.id] = clear_medal[score.id] | (medal << (score.chart * 4))
+
+            hiscore_index = (score.id * 4) + {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY_POSITION,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL_POSITION,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER_POSITION,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX_POSITION,
+            }[score.chart]
+            hiscore_byte_pos = int((hiscore_index * 17) / 8)
+            hiscore_bit_pos = int((hiscore_index * 17) % 8)
+            hiscore_value = points << hiscore_bit_pos
+            hiscore_array[hiscore_byte_pos] = hiscore_array[hiscore_byte_pos] | (hiscore_value & 0xFF)
+            hiscore_array[hiscore_byte_pos + 1] = hiscore_array[hiscore_byte_pos + 1] | ((hiscore_value >> 8) & 0xFF)
+            hiscore_array[hiscore_byte_pos + 2] = hiscore_array[hiscore_byte_pos + 2] | ((hiscore_value >> 16) & 0xFF)
+
+        hiscore = bytes(hiscore_array)
+
+        base.add_child(Node.s16_array('my_best', most_played))
+        base.add_child(Node.s16_array('latest_music', last_played))
+        base.add_child(Node.u16_array('clear_medal', clear_medal))
+        base.add_child(Node.u8_array('clear_medal_sub', clear_medal_sub))
+
+        # Goes outside of base for some reason
+        root.add_child(Node.binary('hiscore', hiscore))
+
+        # Avatar section
+        avatar_dict = profile.get_dict('avatar')
+        avatar = Node.void('avatar')
+        root.add_child(avatar)
+        avatar.add_child(Node.u8('hair', avatar_dict.get_int('hair', 0)))
+        avatar.add_child(Node.u8('face', avatar_dict.get_int('face', 0)))
+        avatar.add_child(Node.u8('body', avatar_dict.get_int('body', 0)))
+        avatar.add_child(Node.u8('effect', avatar_dict.get_int('effect', 0)))
+        avatar.add_child(Node.u8('object', avatar_dict.get_int('object', 0)))
+        avatar.add_child(Node.u8_array('comment', avatar_dict.get_int_array('comment', 2)))
+        avatar.add_child(Node.s32_array('get_hair', avatar_dict.get_int_array('get_hair', 2)))
+        avatar.add_child(Node.s32_array('get_face', avatar_dict.get_int_array('get_face', 2)))
+        avatar.add_child(Node.s32_array('get_body', avatar_dict.get_int_array('get_body', 2)))
+        avatar.add_child(Node.s32_array('get_effect', avatar_dict.get_int_array('get_effect', 2)))
+        avatar.add_child(Node.s32_array('get_object', avatar_dict.get_int_array('get_object', 2)))
+        avatar.add_child(Node.s32_array('get_comment_over', avatar_dict.get_int_array('get_comment_over', 3)))
+        avatar.add_child(Node.s32_array('get_comment_under', avatar_dict.get_int_array('get_comment_under', 3)))
+
+        # Avatar add section
+        avatar_add_dict = profile.get_dict('avatar_add')
+        avatar_add = Node.void('avatar_add')
+        root.add_child(avatar_add)
+        avatar_add.add_child(Node.s32_array('get_hair', avatar_add_dict.get_int_array('get_hair', 2)))
+        avatar_add.add_child(Node.s32_array('get_face', avatar_add_dict.get_int_array('get_face', 2)))
+        avatar_add.add_child(Node.s32_array('get_body', avatar_add_dict.get_int_array('get_body', 2)))
+        avatar_add.add_child(Node.s32_array('get_effect', avatar_add_dict.get_int_array('get_effect', 2)))
+        avatar_add.add_child(Node.s32_array('get_object', avatar_add_dict.get_int_array('get_object', 2)))
+        avatar_add.add_child(Node.s32_array('get_comment_over', avatar_add_dict.get_int_array('get_comment_over', 2)))
+        avatar_add.add_child(Node.s32_array('get_comment_under', avatar_add_dict.get_int_array('get_comment_under', 2)))
+        avatar_add.add_child(Node.s32_array('new_hair', avatar_add_dict.get_int_array('new_hair', 2)))
+        avatar_add.add_child(Node.s32_array('new_face', avatar_add_dict.get_int_array('new_face', 2)))
+        avatar_add.add_child(Node.s32_array('new_body', avatar_add_dict.get_int_array('new_body', 2)))
+        avatar_add.add_child(Node.s32_array('new_effect', avatar_add_dict.get_int_array('new_effect', 2)))
+        avatar_add.add_child(Node.s32_array('new_object', avatar_add_dict.get_int_array('new_object', 2)))
+        avatar_add.add_child(Node.s32_array('new_comment_over', avatar_add_dict.get_int_array('new_comment_over', 2)))
+        avatar_add.add_child(Node.s32_array('new_comment_under', avatar_add_dict.get_int_array('new_comment_under', 2)))
+
+        # Net VS section
+        netvs = Node.void('netvs')
+        root.add_child(netvs)
+        netvs.add_child(Node.s32('rank_point', 0))
+        netvs.add_child(Node.s16_array('record', [0, 0, 0, 0, 0, 0]))
+        netvs.add_child(Node.u8('rank', 0))
+        netvs.add_child(Node.s8('vs_rank_old', 0))
+        netvs.add_child(Node.s8_array('ojama_condition', [0] * 74))
+        netvs.add_child(Node.s8_array('set_ojama', [0, 0, 0]))
+        netvs.add_child(Node.s8_array('set_recommend', [0, 0, 0]))
+        netvs.add_child(Node.u8('netvs_play_cnt', 0))
+        for dialog in [0, 1, 2, 3, 4, 5]:
+            # TODO: Configure this, maybe?
+            netvs.add_child(Node.string('dialog', 'dialog#{}'.format(dialog)))
+
+        sp_data = Node.void('sp_data')
+        root.add_child(sp_data)
+        sp_data.add_child(Node.s32('sp', profile.get_int('sp', 0)))
+
+        gakuen = Node.void('gakuen_data')
+        root.add_child(gakuen)
+        gakuen.add_child(Node.s32('music_list', -1))
+
+        saucer = Node.void('flying_saucer')
+        root.add_child(saucer)
+        saucer.add_child(Node.s32('music_list', -1))
+        saucer.add_child(Node.s32('tune_count', -1))
+        saucer.add_child(Node.u32('clear_norma', 0))
+        saucer.add_child(Node.u32('clear_norma_add', 0))
+
+        zoo_dict = profile.get_dict('zoo')
+        zoo = Node.void('zoo')
+        root.add_child(zoo)
+        zoo.add_child(Node.u16_array('point', zoo_dict.get_int_array('point', 5)))
+        zoo.add_child(Node.s32_array('music_list', zoo_dict.get_int_array('music_list', 2)))
+        zoo.add_child(Node.s8_array('today_play_flag', zoo_dict.get_int_array('today_play_flag', 4)))
+
+        triple = Node.void('triple_journey')
+        root.add_child(triple)
+        triple.add_child(Node.s32('music_list', -1))
+        triple.add_child(Node.s32_array('boss_damage', [65534, 65534, 65534, 65534]))
+        triple.add_child(Node.s32_array('boss_stun', [0, 0, 0, 0]))
+        triple.add_child(Node.s32('magic_gauge', 0))
+        triple.add_child(Node.s32('today_party', 0))
+        triple.add_child(Node.bool('union_magic', False))
+        triple.add_child(Node.float('base_attack_rate', 1.0))
+        triple.add_child(Node.s32('iidx_play_num', 0))
+        triple.add_child(Node.s32('reflec_play_num', 0))
+        triple.add_child(Node.s32('voltex_play_num', 0))
+        triple.add_child(Node.bool('iidx_play_flg', True))
+        triple.add_child(Node.bool('reflec_play_flg', True))
+        triple.add_child(Node.bool('voltex_play_flg', True))
+
+        ios = Node.void('ios')
+        root.add_child(ios)
+        ios.add_child(Node.s32('continueRightAnswer', 30))
+        ios.add_child(Node.s32('totalRightAnswer', 30))
+
+        kac2013 = Node.void('kac2013')
+        root.add_child(kac2013)
+        kac2013.add_child(Node.s8('music_num', 0))
+        kac2013.add_child(Node.s16('music', 0))
+        kac2013.add_child(Node.u8('sheet', 0))
+
+        baseball = Node.void('baseball_data')
+        root.add_child(baseball)
+        baseball.add_child(Node.s64('music_list', -1))
+
+        for id in [3, 5, 7]:
+            node = Node.void('floor_infection')
+            root.add_child(node)
+            node.add_child(Node.s32('infection_id', id))
+            node.add_child(Node.s32('music_list', -1))
+
+        return root
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        # Circular import, ugh
+        from bemani.backend.popn.lapistoria import PopnMusicLapistoria
+
+        root = Node.void('playerdata')
+
+        root.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        root.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        root.add_child(Node.s32('option', profile.get_int('option', 0)))
+        root.add_child(Node.s8('result', 1))
+
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            points = score.points
+            medal = score.data.get_int('medal')
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: PopnMusicLapistoria.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: PopnMusicLapistoria.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: PopnMusicLapistoria.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: PopnMusicLapistoria.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s16('cnt', score.plays))
+            music.add_child(Node.s32('score', 0))
+            music.add_child(Node.u8('clear_type', 0))
+            music.add_child(Node.s32('old_score', points))
+            music.add_child(Node.u8('old_clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: PopnMusicLapistoria.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: PopnMusicLapistoria.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: PopnMusicLapistoria.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: PopnMusicLapistoria.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: PopnMusicLapistoria.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: PopnMusicLapistoria.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: PopnMusicLapistoria.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: PopnMusicLapistoria.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: PopnMusicLapistoria.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: PopnMusicLapistoria.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: PopnMusicLapistoria.GAME_PLAY_MEDAL_PERFECT,
+            }[medal]))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+        newprofile.replace_int('option', request.child_value('option'))
+        newprofile.replace_int('chara', request.child_value('chara'))
+        newprofile.replace_int('mode', request.child_value('mode'))
+        newprofile.replace_int('button', request.child_value('button'))
+        newprofile.replace_int('music', request.child_value('music'))
+        newprofile.replace_int('sheet', request.child_value('sheet'))
+        newprofile.replace_int('last_play_flag', request.child_value('last_play_flag'))
+        newprofile.replace_int('category', request.child_value('category'))
+        newprofile.replace_int('sub_category', request.child_value('sub_category'))
+        newprofile.replace_int('chara_category', request.child_value('chara_category'))
+        newprofile.replace_int('medal_and_friend', request.child_value('medal_and_friend'))
+        newprofile.replace_int('ep', request.child_value('ep'))
+        newprofile.replace_int_array('sp_color_flg', 2, request.child_value('sp_color_flg'))
+        newprofile.replace_int('read_news', request.child_value('read_news'))
+        newprofile.replace_int('consecutive_days_coupon', request.child_value('consecutive_days_coupon'))
+        newprofile.replace_int('tutorial', request.child_value('tutorial'))
+        newprofile.replace_int('music_open_pt', request.child_value('music_open_pt'))
+        newprofile.replace_int_array('gitadora_point', 3, request.child_value('gitadora_point'))
+        newprofile.replace_int('gitadora_select', request.child_value('gitadora_select'))
+
+        sp_node = request.child('sp_data')
+        if sp_node is not None:
+            newprofile.replace_int('sp', sp_node.child_value('sp'))
+
+        zoo_dict = newprofile.get_dict('zoo')
+        zoo_node = request.child('zoo')
+        if zoo_node is not None:
+            zoo_dict.replace_int_array('point', 5, zoo_node.child_value('point'))
+            zoo_dict.replace_int_array('music_list', 2, zoo_node.child_value('music_list'))
+            zoo_dict.replace_int_array('today_play_flag', 4, zoo_node.child_value('today_play_flag'))
+        newprofile.replace_dict('zoo', zoo_dict)
+
+        avatar_dict = newprofile.get_dict('avatar')
+        avatar_dict.replace_int('hair', request.child_value('hair'))
+        avatar_dict.replace_int('face', request.child_value('face'))
+        avatar_dict.replace_int('body', request.child_value('body'))
+        avatar_dict.replace_int('effect', request.child_value('effect'))
+        avatar_dict.replace_int('object', request.child_value('object'))
+        avatar_dict.replace_int_array('comment', 2, request.child_value('comment'))
+        avatar_dict.replace_int_array('get_hair', 2, request.child_value('get_hair'))
+        avatar_dict.replace_int_array('get_face', 2, request.child_value('get_face'))
+        avatar_dict.replace_int_array('get_body', 2, request.child_value('get_body'))
+        avatar_dict.replace_int_array('get_effect', 2, request.child_value('get_effect'))
+        avatar_dict.replace_int_array('get_object', 2, request.child_value('get_object'))
+        avatar_dict.replace_int_array('get_comment_over', 3, request.child_value('get_comment_over'))
+        avatar_dict.replace_int_array('get_comment_under', 3, request.child_value('get_comment_under'))
+        newprofile.replace_dict('avatar', avatar_dict)
+
+        avatar_add_dict = newprofile.get_dict('avatar_add')
+        avatar_add_node = request.child('avatar_add')
+        if avatar_add_node is not None:
+            avatar_add_dict.replace_int_array('get_hair', 2, avatar_add_node.child_value('get_hair'))
+            avatar_add_dict.replace_int_array('get_face', 2, avatar_add_node.child_value('get_face'))
+            avatar_add_dict.replace_int_array('get_body', 2, avatar_add_node.child_value('get_body'))
+            avatar_add_dict.replace_int_array('get_effect', 2, avatar_add_node.child_value('get_effect'))
+            avatar_add_dict.replace_int_array('get_object', 2, avatar_add_node.child_value('get_object'))
+            avatar_add_dict.replace_int_array('get_comment_over', 2, avatar_add_node.child_value('get_comment_over'))
+            avatar_add_dict.replace_int_array('get_comment_under', 2, avatar_add_node.child_value('get_comment_under'))
+            avatar_add_dict.replace_int_array('new_hair', 2, avatar_add_node.child_value('new_hair'))
+            avatar_add_dict.replace_int_array('new_face', 2, avatar_add_node.child_value('new_face'))
+            avatar_add_dict.replace_int_array('new_body', 2, avatar_add_node.child_value('new_body'))
+            avatar_add_dict.replace_int_array('new_effect', 2, avatar_add_node.child_value('new_effect'))
+            avatar_add_dict.replace_int_array('new_object', 2, avatar_add_node.child_value('new_object'))
+            avatar_add_dict.replace_int_array('new_comment_over', 2, avatar_add_node.child_value('new_comment_over'))
+            avatar_add_dict.replace_int_array('new_comment_under', 2, avatar_add_node.child_value('new_comment_under'))
+        newprofile.replace_dict('avatar_add', avatar_add_dict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        # Extract scores
+        for node in request.children:
+            if node.name == 'stage':
+                songid = node.child_value('no')
+                chart = {
+                    self.GAME_CHART_TYPE_EASY: self.CHART_TYPE_EASY,
+                    self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL,
+                    self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER,
+                    self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX,
+                }[node.child_value('sheet')]
+                medal = (node.child_value('n_data') >> (chart * 4)) & 0x000F
+                medal = {
+                    self.GAME_PLAY_MEDAL_CIRCLE_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED,
+                    self.GAME_PLAY_MEDAL_DIAMOND_FAILED: self.PLAY_MEDAL_DIAMOND_FAILED,
+                    self.GAME_PLAY_MEDAL_STAR_FAILED: self.PLAY_MEDAL_STAR_FAILED,
+                    self.GAME_PLAY_MEDAL_CIRCLE_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED,
+                    self.GAME_PLAY_MEDAL_DIAMOND_CLEARED: self.PLAY_MEDAL_DIAMOND_CLEARED,
+                    self.GAME_PLAY_MEDAL_STAR_CLEARED: self.PLAY_MEDAL_STAR_CLEARED,
+                    self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                    self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO: self.PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                    self.GAME_PLAY_MEDAL_STAR_FULL_COMBO: self.PLAY_MEDAL_STAR_FULL_COMBO,
+                    self.GAME_PLAY_MEDAL_PERFECT: self.PLAY_MEDAL_PERFECT,
+                }[medal]
+                points = node.child_value('score')
+                self.update_score(userid, songid, chart, points, medal)
+
+        return newprofile
+
+    def handle_game_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'get':
+            # TODO: Hook these up to config so we can change this
+            root = Node.void('game')
+            root.add_child(Node.s32('ir_phase', 0))
+            root.add_child(Node.s32('music_open_phase', 8))
+            root.add_child(Node.s32('collabo_phase', 8))
+            root.add_child(Node.s32('personal_event_phase', 10))
+            root.add_child(Node.s32('shop_event_phase', 6))
+            root.add_child(Node.s32('netvs_phase', 0))
+            root.add_child(Node.s32('card_phase', 9))
+            root.add_child(Node.s32('other_phase', 9))
+            root.add_child(Node.s32('local_matching_enable', 1))
+            root.add_child(Node.s32('n_matching_sec', 60))
+            root.add_child(Node.s32('l_matching_sec', 60))
+            root.add_child(Node.s32('is_check_cpu', 0))
+            root.add_child(Node.s32('week_no', 0))
+            root.add_child(Node.s16_array('sel_ranking', [-1, -1, -1, -1, -1]))
+            root.add_child(Node.s16_array('up_ranking', [-1, -1, -1, -1, -1]))
+            return root
+
+        if method == 'active':
+            # Update the name of this cab for admin purposes
+            self.update_machine_name(request.child_value('shop_name'))
+            return Node.void('game')
+
+        if method == 'taxphase':
+            return Node.void('game')
+
+        # Invalid method
+        return None
+
+    def handle_playerdata_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'expire':
+            return Node.void('playerdata')
+
+        elif method == 'logout':
+            return Node.void('playerdata')
+
+        elif method == 'get':
+            modelstring = request.attribute('model')
+            refid = request.child_value('ref_id')
+            root = self.get_profile_by_refid(
+                refid,
+                self.NEW_PROFILE_ONLY if modelstring is None else self.OLD_PROFILE_ONLY,
+            )
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'conversion':
+            refid = request.child_value('ref_id')
+            name = request.child_value('name')
+            chara = request.child_value('chara')
+            root = self.new_profile_by_refid(refid, name, chara)
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'new':
+            refid = request.child_value('ref_id')
+            name = request.child_value('name')
+            root = self.new_profile_by_refid(refid, name)
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'set':
+            refid = request.attribute('ref_id')
+
+            root = Node.void('playerdata')
+            root.add_child(Node.s8('pref', -1))
+            if refid is None:
+                return root
+
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is None:
+                return root
+
+            oldprofile = self.get_profile(userid) or ValidatedDict()
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+
+            if newprofile is not None:
+                self.put_profile(userid, newprofile)
+                root.add_child(Node.string('name', newprofile['name']))
+
+            return root
+
+        # Invalid method
+        return None
diff --git a/bemani/backend/popn/tunestreet.py b/bemani/backend/popn/tunestreet.py
new file mode 100644
index 0000000..8305968
--- /dev/null
+++ b/bemani/backend/popn/tunestreet.py
@@ -0,0 +1,401 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Optional
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.stubs import PopnMusicSengokuRetsuden
+
+from bemani.backend.base import Status
+from bemani.common import ValidatedDict, VersionConstants
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class PopnMusicTuneStreet(PopnMusicBase):
+
+    name = "Pop'n Music TUNE STREET"
+    version = VersionConstants.POPN_MUSIC_TUNE_STREET
+
+    # Play modes, as reported by profile save from the game
+    GAME_PLAY_MODE_CHALLENGE = 3
+    GAME_PLAY_MODE_CHO_CHALLENGE = 4
+
+    # Play flags, as saved into/loaded from the DB
+    GAME_PLAY_FLAG_FAILED = 0
+    GAME_PLAY_FLAG_CLEARED = 1
+    GAME_PLAY_FLAG_FULL_COMBO = 2
+    GAME_PLAY_FLAG_PERFECT_COMBO = 3
+
+    # Chart type, as reported by profile save from the game
+    GAME_CHART_TYPE_NORMAL = 0
+    GAME_CHART_TYPE_HYPER = 1
+    GAME_CHART_TYPE_5_BUTTON = 2
+    GAME_CHART_TYPE_EX = 3
+    GAME_CHART_TYPE_BATTLE_NORMAL = 4
+    GAME_CHART_TYPE_BATTLE_HYPER = 5
+    GAME_CHART_TYPE_ENJOY_5_BUTTON = 6
+    GAME_CHART_TYPE_ENJOY_9_BUTTON = 7
+
+    # Extra chart types supported by Pop'n 19
+    CHART_TYPE_OLD_NORMAL = 4
+    CHART_TYPE_OLD_HYPER = 5
+    CHART_TYPE_OLD_EX = 6
+    CHART_TYPE_ENJOY_5_BUTTON = 7
+    CHART_TYPE_ENJOY_9_BUTTON = 8
+    CHART_TYPE_5_BUTTON = 9
+
+    # Chart type, as packed into a hiscore binary
+    GAME_CHART_TYPE_5_BUTTON_POSITION = 0
+    GAME_CHART_TYPE_NORMAL_POSITION = 1
+    GAME_CHART_TYPE_HYPER_POSITION = 2
+    GAME_CHART_TYPE_EX_POSITION = 3
+    GAME_CHART_TYPE_CHO_NORMAL_POSITION = 4
+    GAME_CHART_TYPE_CHO_HYPER_POSITION = 5
+    GAME_CHART_TYPE_CHO_EX_POSITION = 6
+
+    # Highest song ID we can represent
+    GAME_MAX_MUSIC_ID = 1045
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicSengokuRetsuden(self.data, self.config, self.model)
+
+    def __format_flags_for_score(self, score: Score) -> int:
+        # Format song flags (cleared/not, combo flags)
+        playedflag = {
+            self.CHART_TYPE_5_BUTTON: 0x2000,
+            self.CHART_TYPE_OLD_NORMAL: 0x0800,
+            self.CHART_TYPE_OLD_HYPER: 0x1000,
+            self.CHART_TYPE_OLD_EX: 0x4000,
+            self.CHART_TYPE_NORMAL: 0x0800,
+            self.CHART_TYPE_HYPER: 0x1000,
+            self.CHART_TYPE_EX: 0x4000,
+            # We don't have a played flag for these, only cleared/no play
+            self.CHART_TYPE_ENJOY_5_BUTTON: 0,
+            self.CHART_TYPE_ENJOY_9_BUTTON: 0,
+        }[score.chart]
+        # Shift value for cleared/failed/combo indicators
+        shift = {
+            self.CHART_TYPE_5_BUTTON: 4,
+            self.CHART_TYPE_OLD_NORMAL: 0,
+            self.CHART_TYPE_OLD_HYPER: 2,
+            self.CHART_TYPE_OLD_EX: 6,
+            self.CHART_TYPE_NORMAL: 0,
+            self.CHART_TYPE_HYPER: 2,
+            self.CHART_TYPE_EX: 6,
+            self.CHART_TYPE_ENJOY_5_BUTTON: 9,
+            self.CHART_TYPE_ENJOY_9_BUTTON: 8,
+        }[score.chart]
+        flags = {
+            self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_FLAG_FAILED,
+            self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_FLAG_FAILED,
+            self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_FLAG_FAILED,
+            self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_FLAG_CLEARED,
+            self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_FLAG_CLEARED,
+            self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_FLAG_CLEARED,
+            self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_FLAG_CLEARED,
+            self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_FLAG_FULL_COMBO,
+            self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_FLAG_FULL_COMBO,
+            self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_FLAG_FULL_COMBO,
+            self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_FLAG_PERFECT_COMBO,
+        }[score.data.get_int('medal')]
+        return (flags << shift) | playedflag
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('playerdata')
+
+        # Format profile
+        binary_profile = [0] * 2200
+
+        # Copy name
+        name_binary = profile.get_str('name', 'なし').encode('shift-jis')[0:12]
+        name_pos = 0
+        for byte in name_binary:
+            binary_profile[name_pos] = byte
+            name_pos = name_pos + 1
+
+        # Copy game mode
+        binary_profile[13] = {
+            0: 0,
+            1: 0,
+            2: 1,
+            3: 1,
+            4: 4,
+            5: 2,
+        }[profile.get_int('play_mode')]
+
+        # Copy miscelaneous values
+        binary_profile[16] = profile.get_int('last_play_flag') & 0xFF
+        binary_profile[44] = profile.get_int('option') & 0xFF
+        binary_profile[45] = (profile.get_int('option') >> 8) & 0xFF
+        binary_profile[46] = (profile.get_int('option') >> 16) & 0xFF
+        binary_profile[47] = (profile.get_int('option') >> 24) & 0xFF
+        binary_profile[60] = profile.get_int('chara') & 0xFF
+        binary_profile[61] = (profile.get_int('chara') >> 8) & 0xFF
+        binary_profile[62] = profile.get_int('music') & 0xFF
+        binary_profile[63] = (profile.get_int('music') >> 8) & 0xFF
+        binary_profile[64] = profile.get_int('sheet') & 0xFF
+        binary_profile[65] = profile.get_int('category') & 0xFF
+        binary_profile[67] = profile.get_int('medal_and_friend') & 0xFF
+
+        # Format Scores
+        hiscore_array = [0] * int((((self.GAME_MAX_MUSIC_ID * 7) * 17) + 7) / 8)
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart in [
+                self.CHART_TYPE_EASY,
+            ]:
+                continue
+
+            flags = self.__format_flags_for_score(score)
+
+            flags_index = score.id * 2
+            binary_profile[108 + flags_index] = binary_profile[108 + flags_index] | (flags & 0xFF)
+            binary_profile[109 + flags_index] = binary_profile[109 + flags_index] | ((flags >> 8) & 0xFF)
+
+            if score.chart in [
+                self.CHART_TYPE_ENJOY_5_BUTTON,
+                self.CHART_TYPE_ENJOY_9_BUTTON,
+            ]:
+                # We don't return enjoy scores, just the flags that we played them
+                continue
+
+            # Format actual score, according to DB chart position
+            points = score.points
+
+            hiscore_index = (score.id * 7) + {
+                self.CHART_TYPE_5_BUTTON: self.GAME_CHART_TYPE_5_BUTTON_POSITION,
+                self.CHART_TYPE_OLD_NORMAL: self.GAME_CHART_TYPE_NORMAL_POSITION,
+                self.CHART_TYPE_OLD_HYPER: self.GAME_CHART_TYPE_HYPER_POSITION,
+                self.CHART_TYPE_OLD_EX: self.GAME_CHART_TYPE_EX_POSITION,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_CHO_NORMAL_POSITION,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_CHO_HYPER_POSITION,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_CHO_EX_POSITION,
+            }[score.chart]
+            hiscore_byte_pos = int((hiscore_index * 17) / 8)
+            hiscore_bit_pos = int((hiscore_index * 17) % 8)
+            hiscore_value = points << hiscore_bit_pos
+            hiscore_array[hiscore_byte_pos] = hiscore_array[hiscore_byte_pos] | (hiscore_value & 0xFF)
+            hiscore_array[hiscore_byte_pos + 1] = hiscore_array[hiscore_byte_pos + 1] | ((hiscore_value >> 8) & 0xFF)
+            hiscore_array[hiscore_byte_pos + 2] = hiscore_array[hiscore_byte_pos + 2] | ((hiscore_value >> 16) & 0xFF)
+
+        # Format most played
+        most_played = [x[0] for x in self.data.local.music.get_most_played(self.game, self.version, userid, 20)]
+        while len(most_played) < 20:
+            most_played.append(-1)
+        profile_pos = 68
+        for musicid in most_played:
+            binary_profile[profile_pos] = musicid & 0xFF
+            binary_profile[profile_pos + 1] = (musicid >> 8) & 0xFF
+            profile_pos = profile_pos + 2
+
+        # Construct final profile
+        root.add_child(Node.binary('b', bytes(binary_profile)))
+        root.add_child(Node.binary('hiscore', bytes(hiscore_array)))
+        root.add_child(Node.binary('town', b''))
+
+        return root
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('playerdata')
+
+        root.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        root.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        root.add_child(Node.s32('option', profile.get_int('option', 0)))
+        root.add_child(Node.u8('version', 0))
+        root.add_child(Node.u8('kind', 0))
+        root.add_child(Node.u8('season', 0))
+
+        medals = [0] * (self.GAME_MAX_MUSIC_ID)
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            if score.id > self.GAME_MAX_MUSIC_ID:
+                continue
+
+            # Skip any scores for chart types we don't support
+            if score.chart in [
+                self.CHART_TYPE_EASY,
+            ]:
+                continue
+
+            flags = self.__format_flags_for_score(score)
+            medals[score.id] = medals[score.id] | flags
+        root.add_child(Node.u16_array('clear_medal', medals))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Extract the playmode, important for scores later
+        playmode = int(request.attribute('play_mode'))
+        newprofile.replace_int('play_mode', playmode)
+
+        # Extract profile options
+        newprofile.replace_int('chara', int(request.attribute('chara_num')))
+        if 'option' in request.attributes:
+            newprofile.replace_int('option', int(request.attribute('option')))
+        if 'last_play_flag' in request.attributes:
+            newprofile.replace_int('last_play_flag', int(request.attribute('last_play_flag')))
+        if 'medal_and_friend' in request.attributes:
+            newprofile.replace_int('medal_and_friend', int(request.attribute('medal_and_friend')))
+        if 'music_num' in request.attributes:
+            newprofile.replace_int('music', int(request.attribute('music_num')))
+        if 'sheet_num' in request.attributes:
+            newprofile.replace_int('sheet', int(request.attribute('sheet_num')))
+        if 'category_num' in request.attributes:
+            newprofile.replace_int('category', int(request.attribute('category_num')))
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        # Extract scores
+        for node in request.children:
+            if node.name == 'music':
+                songid = int(node.attribute('music_num'))
+                chart = int(node.attribute('sheet_num'))
+                points = int(node.attribute('score'))
+                data = int(node.attribute('data'))
+
+                # We never save battle scores
+                if chart in [
+                    self.GAME_CHART_TYPE_BATTLE_NORMAL,
+                    self.GAME_CHART_TYPE_BATTLE_HYPER,
+                ]:
+                    continue
+
+                # Arrange order to be compatible with future mixes
+                if playmode == self.GAME_PLAY_MODE_CHO_CHALLENGE:
+                    if chart in [
+                        self.GAME_CHART_TYPE_5_BUTTON,
+                        self.GAME_CHART_TYPE_ENJOY_5_BUTTON,
+                        self.GAME_CHART_TYPE_ENJOY_9_BUTTON,
+                    ]:
+                        # We don't save 5 button for cho scores, or enjoy modes
+                        continue
+                    chart = {
+                        self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL,
+                        self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER,
+                        self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX,
+                    }[chart]
+                else:
+                    chart = {
+                        self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_OLD_NORMAL,
+                        self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_OLD_HYPER,
+                        self.GAME_CHART_TYPE_5_BUTTON: self.CHART_TYPE_5_BUTTON,
+                        self.GAME_CHART_TYPE_EX: self.CHART_TYPE_OLD_EX,
+                        self.GAME_CHART_TYPE_ENJOY_5_BUTTON: self.CHART_TYPE_ENJOY_5_BUTTON,
+                        self.GAME_CHART_TYPE_ENJOY_9_BUTTON: self.CHART_TYPE_ENJOY_9_BUTTON,
+                    }[chart]
+
+                # Extract play flags
+                shift = {
+                    self.CHART_TYPE_5_BUTTON: 4,
+                    self.CHART_TYPE_OLD_NORMAL: 0,
+                    self.CHART_TYPE_OLD_HYPER: 2,
+                    self.CHART_TYPE_OLD_EX: 6,
+                    self.CHART_TYPE_NORMAL: 0,
+                    self.CHART_TYPE_HYPER: 2,
+                    self.CHART_TYPE_EX: 6,
+                    self.CHART_TYPE_ENJOY_5_BUTTON: 9,
+                    self.CHART_TYPE_ENJOY_9_BUTTON: 8,
+                }[chart]
+
+                if chart in [
+                    self.CHART_TYPE_ENJOY_5_BUTTON,
+                    self.CHART_TYPE_ENJOY_9_BUTTON,
+                ]:
+                    # We only store cleared or not played for enjoy mode
+                    mask = 0x1
+                else:
+                    # We store all data for regular charts
+                    mask = 0x3
+
+                # Grab flags, map to medals in DB. Choose lowest one for each so
+                # a newer pop'n can still improve scores and medals.
+                flags = (data >> shift) & mask
+                medal = {
+                    self.GAME_PLAY_FLAG_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED,
+                    self.GAME_PLAY_FLAG_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED,
+                    self.GAME_PLAY_FLAG_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                    self.GAME_PLAY_FLAG_PERFECT_COMBO: self.PLAY_MEDAL_PERFECT,
+                }[flags]
+                self.update_score(userid, songid, chart, points, medal)
+
+        return newprofile
+
+    def handle_game_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'get':
+            # TODO: Hook these up to config so we can change this
+            root = Node.void('game')
+            root.set_attribute('game_phase', '2')
+            root.set_attribute('psp_phase', '2')
+            return root
+
+        if method == 'active':
+            # Update the name of this cab for admin purposes
+            self.update_machine_name(request.attribute('shop_name'))
+            return Node.void('game')
+
+        if method == 'taxphase':
+            return Node.void('game')
+
+        # Invalid method
+        return None
+
+    def handle_playerdata_request(self, request: Node) -> Optional[Node]:
+        method = request.attribute('method')
+
+        if method == 'expire':
+            return Node.void('playerdata')
+
+        elif method == 'logout':
+            return Node.void('playerdata')
+
+        elif method == 'get':
+            modelstring = request.attribute('model')
+            refid = request.attribute('ref_id')
+            root = self.get_profile_by_refid(
+                refid,
+                self.NEW_PROFILE_ONLY if modelstring is None else self.OLD_PROFILE_ONLY,
+            )
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'new':
+            refid = request.attribute('ref_id')
+            name = request.attribute('name')
+            root = self.new_profile_by_refid(refid, name)
+            if root is None:
+                root = Node.void('playerdata')
+                root.set_attribute('status', str(Status.NO_PROFILE))
+            return root
+
+        elif method == 'set':
+            refid = request.attribute('ref_id')
+
+            root = Node.void('playerdata')
+            if refid is None:
+                return root
+
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+            if userid is None:
+                return root
+
+            oldprofile = self.get_profile(userid) or ValidatedDict()
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+
+            if newprofile is not None:
+                self.put_profile(userid, newprofile)
+
+            return root
+
+        # Invalid method
+        return None
diff --git a/bemani/backend/popn/usaneko.py b/bemani/backend/popn/usaneko.py
new file mode 100644
index 0000000..21b563e
--- /dev/null
+++ b/bemani/backend/popn/usaneko.py
@@ -0,0 +1,1210 @@
+# vim: set fileencoding=utf-8
+import binascii
+import copy
+import random
+from typing import Any, Dict, List, Optional, Tuple
+
+from bemani.backend.popn.base import PopnMusicBase
+from bemani.backend.popn.eclale import PopnMusicEclale
+from bemani.common import Time, ID, ValidatedDict, VersionConstants, Parallel
+from bemani.data import Data, UserID, Achievement
+from bemani.protocol import Node
+
+
+class PopnMusicUsaNeko(PopnMusicBase):
+
+    name = "Pop'n Music うさぎと猫と少年の夢"
+    version = VersionConstants.POPN_MUSIC_USANEKO
+
+    # Chart type, as returned from the game
+    GAME_CHART_TYPE_EASY = 0
+    GAME_CHART_TYPE_NORMAL = 1
+    GAME_CHART_TYPE_HYPER = 2
+    GAME_CHART_TYPE_EX = 3
+
+    # Medal type, as returned from the game
+    GAME_PLAY_MEDAL_CIRCLE_FAILED = 1
+    GAME_PLAY_MEDAL_DIAMOND_FAILED = 2
+    GAME_PLAY_MEDAL_STAR_FAILED = 3
+    GAME_PLAY_MEDAL_EASY_CLEAR = 4
+    GAME_PLAY_MEDAL_CIRCLE_CLEARED = 5
+    GAME_PLAY_MEDAL_DIAMOND_CLEARED = 6
+    GAME_PLAY_MEDAL_STAR_CLEARED = 7
+    GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO = 8
+    GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO = 9
+    GAME_PLAY_MEDAL_STAR_FULL_COMBO = 10
+    GAME_PLAY_MEDAL_PERFECT = 11
+
+    # Rank type, as returned from the game
+    GAME_PLAY_RANK_E = 1
+    GAME_PLAY_RANK_D = 2
+    GAME_PLAY_RANK_C = 3
+    GAME_PLAY_RANK_B = 4
+    GAME_PLAY_RANK_A = 5
+    GAME_PLAY_RANK_AA = 6
+    GAME_PLAY_RANK_AAA = 7
+    GAME_PLAY_RANK_S = 8
+
+    # Biggest ID in the music DB
+    GAME_MAX_MUSIC_ID = 1704
+
+    def previous_version(self) -> Optional[PopnMusicBase]:
+        return PopnMusicEclale(self.data, self.config, self.model)
+
+    def extra_services(self) -> List[str]:
+        """
+        Return the local2 and lobby2 service so that Pop'n Music 24 will
+        send game packets.
+        """
+        return [
+            'local2',
+            'lobby2',
+        ]
+
+    @classmethod
+    def run_scheduled_work(cls, data: Data, config: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+        """
+        Once a week, insert a new course.
+        """
+        events = []
+        if data.local.network.should_schedule(cls.game, cls.version, 'course', 'weekly'):
+            # Generate a new course list, save it to the DB.
+            start_time, end_time = data.local.network.get_schedule_duration('weekly')
+            all_songs = [song.id for song in data.local.music.get_all_songs(cls.game, cls.version)]
+            course_song = random.choice(all_songs)
+            data.local.game.put_time_sensitive_settings(
+                cls.game,
+                cls.version,
+                'course',
+                {
+                    'start_time': start_time,
+                    'end_time': end_time,
+                    'music': course_song,
+                },
+            )
+            events.append((
+                'pnm_course',
+                {
+                    'version': cls.version,
+                    'song': course_song,
+                },
+            ))
+
+            # Mark that we did some actual work here.
+            data.local.network.mark_scheduled(cls.game, cls.version, 'course', 'weekly')
+        return events
+
+    def __score_to_rank(self, score: int) -> int:
+        if score < 50000:
+            return self.GAME_PLAY_RANK_E
+        if score < 62000:
+            return self.GAME_PLAY_RANK_D
+        if score < 72000:
+            return self.GAME_PLAY_RANK_C
+        if score < 82000:
+            return self.GAME_PLAY_RANK_B
+        if score < 90000:
+            return self.GAME_PLAY_RANK_A
+        if score < 95000:
+            return self.GAME_PLAY_RANK_AA
+        if score < 98000:
+            return self.GAME_PLAY_RANK_AAA
+        return self.GAME_PLAY_RANK_S
+
+    def handle_lobby24_request(self, request: Node) -> Optional[Node]:
+        # Stub out the entire lobby24 service
+        return Node.void('lobby24')
+
+    def handle_pcb24_error_request(self, request: Node) -> Node:
+        return Node.void('pcb24')
+
+    def handle_pcb24_boot_request(self, request: Node) -> Node:
+        return Node.void('pcb24')
+
+    def handle_pcb24_write_request(self, request: Node) -> Node:
+        # Update the name of this cab for admin purposes
+        self.update_machine_name(request.child_value('pcb_setting/name'))
+        return Node.void('pcb24')
+
+    def __construct_common_info(self, root: Node) -> None:
+        # Event phases
+        phases = {
+            # Default song phase availability (0-11)
+            0: 11,
+            # Unknown event (0-2)
+            1: 2,
+            # Unknown event (0-2)
+            2: 2,
+            # Unknown event (0-4)
+            3: 4,
+            # Unknown event (0-1)
+            4: 1,
+            # Enable Net Taisen, including win/loss display on song select (0-1)
+            5: 1,
+            # Enable NAVI-kun shunkyoku toujou, allows song 1608 to be unlocked (0-1)
+            6: 1,
+            # Unknown event (0-1)
+            7: 1,
+            # Unknown event (0-2)
+            8: 2,
+            # Daily Mission (0-2)
+            9: 2,
+            # NAVI-kun Song phase availability (0-15)
+            10: 15,
+            # Unknown event (0-1)
+            11: 1,
+            # Unknown event (0-2)
+            12: 2,
+            # Enable Pop'n Peace preview song (0-1)
+            13: 1,
+        }
+
+        for phaseid in phases:
+            phase = Node.void('phase')
+            root.add_child(phase)
+            phase.add_child(Node.s16('event_id', phaseid))
+            phase.add_child(Node.s16('phase', phases[phaseid]))
+
+        # Gather course informatino and course ranking for users.
+        course_infos, achievements, profiles = Parallel.execute([
+            lambda: self.data.local.game.get_all_time_sensitive_settings(self.game, self.version, 'course'),
+            lambda: self.data.local.user.get_all_achievements(self.game, self.version),
+            lambda: self.data.local.user.get_all_profiles(self.game, self.version),
+        ])
+        # Sort courses by newest to oldest so we can grab the newest 256.
+        course_infos = sorted(
+            course_infos,
+            key=lambda c: c['start_time'],
+            reverse=True,
+        )
+        # Sort achievements within course ID from best to worst ranking.
+        achievements_by_course_id: Dict[int, Dict[str, List[Tuple[UserID, Achievement]]]] = {}
+        type_to_chart_lut: Dict[str, str] = {
+            f'course_{self.GAME_CHART_TYPE_EASY}': "loc_ranking_e",
+            f'course_{self.GAME_CHART_TYPE_NORMAL}': "loc_ranking_n",
+            f'course_{self.GAME_CHART_TYPE_HYPER}': "loc_ranking_h",
+            f'course_{self.GAME_CHART_TYPE_EX}': "loc_ranking_ex",
+        }
+        for uid, ach in achievements:
+            if ach.type[:7] != 'course_':
+                continue
+            if ach.id not in achievements_by_course_id:
+                achievements_by_course_id[ach.id] = {
+                    "loc_ranking_e": [],
+                    "loc_ranking_n": [],
+                    "loc_ranking_h": [],
+                    "loc_ranking_ex": [],
+                }
+            achievements_by_course_id[ach.id][type_to_chart_lut[ach.type]].append((uid, ach))
+        for courseid in achievements_by_course_id:
+            for chart in ["loc_ranking_e", "loc_ranking_n", "loc_ranking_h", "loc_ranking_ex"]:
+                achievements_by_course_id[courseid][chart] = sorted(
+                    achievements_by_course_id[courseid][chart],
+                    key=lambda uid_and_ach: uid_and_ach[1].data.get_int('score'),
+                    reverse=True,
+                )
+
+        # Cache of userID to profile
+        userid_to_profile: Dict[UserID, ValidatedDict] = {uid: profile for (uid, profile) in profiles}
+
+        # Course ranking info for the last 256 courses
+        for course_info in course_infos[:256]:
+            course_id = int(course_info['start_time'] / 604800)
+            course_rankings = achievements_by_course_id.get(course_id, {})
+
+            ranking_info = Node.void('ranking_info')
+            root.add_child(ranking_info)
+            ranking_info.add_child(Node.s16('course_id', course_id))
+            ranking_info.add_child(Node.u64('start_date', course_info['start_time'] * 1000))
+            ranking_info.add_child(Node.u64('end_date', course_info['end_time'] * 1000))
+            ranking_info.add_child(Node.s32('music_id', course_info['music']))
+
+            # Top 20 rankings for each particular chart.
+            for name in ["loc_ranking_e", "loc_ranking_n", "loc_ranking_h", "loc_ranking_ex"]:
+                chart_rankings = course_rankings.get(name, [])
+
+                for pos, (uid, ach) in enumerate(chart_rankings[:20]):
+                    profile = userid_to_profile.get(uid, ValidatedDict())
+
+                    subnode = Node.void(name)
+                    ranking_info.add_child(subnode)
+                    subnode.add_child(Node.s16('rank', pos + 1))
+                    subnode.add_child(Node.string('name', profile.get_str('name')))
+                    subnode.add_child(Node.s16('chara_num', profile.get_int('chara', -1)))
+                    subnode.add_child(Node.s32('total_score', ach.data.get_int('score')))
+                    subnode.add_child(Node.u8('clear_type', ach.data.get_int('clear_type')))
+                    subnode.add_child(Node.u8('clear_rank', ach.data.get_int('clear_rank')))
+
+        for area_id in range(1, 16):
+            area = Node.void('area')
+            root.add_child(area)
+            area.add_child(Node.s16('area_id', area_id))
+            area.add_child(Node.u64('end_date', 0))
+            area.add_child(Node.s16('medal_id', area_id))
+            area.add_child(Node.bool('is_limit', False))
+
+        for choco_id in range(1, 5):
+            choco = Node.void('choco')
+            root.add_child(choco)
+            choco.add_child(Node.s16('choco_id', choco_id))
+            choco.add_child(Node.s32('param', -1))
+
+        # Set up goods, educated guess here.
+        for goods_id in range(97):
+            if goods_id < 15:
+                price = 30
+            elif goods_id < 30:
+                price = 40
+            elif goods_id < 45:
+                price = 60
+            elif goods_id < 60:
+                price = 80
+            else:
+                price = 200
+            goods = Node.void('goods')
+            root.add_child(goods)
+            goods.add_child(Node.s32('item_id', goods_id + 1))
+            goods.add_child(Node.s16('item_type', 3))
+            goods.add_child(Node.s32('price', price))
+            goods.add_child(Node.s16('goods_type', 0))
+
+        # Ignoring NAVIfes node, we don't set these.
+        # fes = Node.void('fes')
+        # fes.add_child(Node.s16('fes_id', -1))
+        # fes.add_child(Node.s32('gauge_count', -1))
+        # fes.add_child(Node.s32_array('gauge', [-1, -1, -1, -1, -1, -1]))
+        # fes.add_child(Node.s32_array('music', [-1, -1, -1, -1, -1, -1]))
+        # fes.add_child(Node.s16('r', -1))
+        # fes.add_child(Node.s16('g', -1))
+        # fes.add_child(Node.s16('b', -1))
+        # fes.add_child(Node.s16('poster', -1))
+
+        # Calculate most popular characters
+        profiles = self.data.remote.user.get_all_profiles(self.game, self.version)
+        charas: Dict[int, int] = {}
+        for (userid, profile) in profiles:
+            chara = profile.get_int('chara', -1)
+            if chara <= 0:
+                continue
+            if chara not in charas:
+                charas[chara] = 1
+            else:
+                charas[chara] = charas[chara] + 1
+
+        # Order a typle by most popular character to least popular character
+        charamap = sorted(
+            [(c, charas[c]) for c in charas],
+            key=lambda c: c[1],
+            reverse=True,
+        )
+
+        # Top 20 Popular characters
+        for rank, (charaid, usecount) in enumerate(charamap[:20]):
+            popular = Node.void('popular')
+            root.add_child(popular)
+            popular.add_child(Node.s16('rank', rank + 1))
+            popular.add_child(Node.s16('chara_num', charaid))
+
+        # Top 500 Popular music
+        for (songid, plays) in self.data.local.music.get_hit_chart(self.game, self.version, 500):
+            popular_music = Node.void('popular_music')
+            root.add_child(popular_music)
+            popular_music.add_child(Node.s16('music_num', songid))
+
+        # Ignoring recommended music, we don't set this
+        # recommend = Node.void('recommend')
+        # root.add_child(recommend)
+        # recommend.add_child(Node.s32_array('music_no', [-1] * 30))
+
+        # Ignoring mission points, we don't set these.
+        # mission_point = Node.void('mission_point')
+        # mission_point.add_child(Node.s32('point', -1))
+        # mission_point.add_child(Node.s32('bonus_point', -1))
+
+        # Ignoring medals, we don't set these.
+        # medal = Node.void('medal')
+        # medal.add_child(Node.s16('medal_id', -1))
+        # medal.add_child(Node.s16('percent', -1))
+
+        # Ignoring chara ranking, we don't set these.
+        # chara_ranking = Node.void('chara_ranking')
+        # chara_ranking.add_child(Node.s32('rank', -1))
+        # chara_ranking.add_child(Node.s32('kind_id', -1))
+        # chara_ranking.add_child(Node.s32('point', -1))
+        # chara_ranking.add_child(Node.s32('month', -1))
+
+    def handle_info24_common_request(self, root: Node) -> Node:
+        root = Node.void('info24')
+        self.__construct_common_info(root)
+        return root
+
+    def handle_player24_new_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        name = request.child_value('name')
+        root = self.new_profile_by_refid(refid, name)
+        if root is None:
+            root = Node.void('player24')
+            root.add_child(Node.s8('result', 2))
+        return root
+
+    def handle_player24_conversion_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        name = request.child_value('name')
+        chara = request.child_value('chara')
+        achievements: List[Achievement] = []
+        for node in request.children:
+            if node.name == 'item':
+                itemid = node.child_value('id')
+                itemtype = node.child_value('type')
+                param = node.child_value('param')
+                is_new = node.child_value('is_new')
+                get_time = node.child_value('get_time')
+
+                achievements.append(
+                    Achievement(
+                        itemid,
+                        'item_{}'.format(itemtype),
+                        0,
+                        {
+                            'param': param,
+                            'is_new': is_new,
+                            'get_time': get_time,
+                        },
+                    )
+                )
+        root = self.new_profile_by_refid(refid, name, chara, achievements=achievements)
+        if root is None:
+            root = Node.void('player24')
+            root.add_child(Node.s8('result', 2))
+        return root
+
+    def handle_player24_read_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        root = self.get_profile_by_refid(refid, self.OLD_PROFILE_FALLTHROUGH)
+        if root is None:
+            root = Node.void('player24')
+            root.add_child(Node.s8('result', 2))
+        return root
+
+    def handle_player24_write_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid) or ValidatedDict()
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+
+            if newprofile is not None:
+                self.put_profile(userid, newprofile)
+
+        return Node.void('player24')
+
+    def handle_player24_update_ranking_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        root = Node.void('player24')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            course_id = request.child_value('course_id')
+            chart = request.child_value('sheet_num')
+            score = request.child_value('total_score')
+            clear_type = request.child_value('clear_type')
+            clear_rank = request.child_value('clear_rank')
+            prefecture = request.child_value('pref')
+            loc_id = ID.parse_machine_id(request.child_value('location_id'))
+            course_type = f"course_{chart}"
+
+            old_course = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                course_id,
+                course_type,
+            )
+            if old_course is None:
+                old_course = ValidatedDict()
+
+            new_course = ValidatedDict({
+                'score': max(score, old_course.get_int('score')),
+                'clear_type': max(clear_type, old_course.get_int('clear_type')),
+                'clear_rank': max(clear_rank, old_course.get_int('clear_rank')),
+                'pref': prefecture,
+                'lid': loc_id,
+                'count': old_course.get_int('count') + 1,
+            })
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                course_id,
+                course_type,
+                new_course,
+            )
+
+            # Handle fetching all scores
+            uids_and_courses, profile = Parallel.execute([
+                lambda: self.data.local.user.get_all_achievements(self.game, self.version),
+                lambda: self.get_profile(userid) or ValidatedDict()
+            ])
+
+            # Grab a sorted list of all scores for this course and chart
+            global_uids_and_courses = sorted(
+                [(uid, ach) for (uid, ach) in uids_and_courses if ach.type == course_type and ach.id == course_id],
+                key=lambda uid_and_course: uid_and_course[1].data.get_int('score'),
+                reverse=True,
+            )
+            # Grab smaller lists that contain only sorted for our prefecture/location
+            pref_uids_and_courses = [(uid, ach) for (uid, ach) in global_uids_and_courses if ach.data.get_int('pref') == prefecture]
+            loc_uids_and_courses = [(uid, ach) for (uid, ach) in global_uids_and_courses if ach.data.get_int('lid') == loc_id]
+
+            def _get_rank(uac: List[Tuple[UserID, Achievement]]) -> Optional[int]:
+                for rank, (uid, _) in enumerate(uac):
+                    if uid == userid:
+                        return rank + 1
+                return None
+
+            for nodename, ranklist in [
+                ("all_ranking", global_uids_and_courses),
+                ("pref_ranking", pref_uids_and_courses),
+                ("location_ranking", loc_uids_and_courses),
+            ]:
+                # Grab the rank, bail if we don't have any answer since the game doesn't
+                # require a response.
+                rank = _get_rank(ranklist)
+                if rank is None:
+                    continue
+
+                # Send back the data for this ranking.
+                node = Node.void(nodename)
+                root.add_child(node)
+                node.add_child(Node.string("name", profile.get_str('name', 'なし')))
+                node.add_child(Node.s16("chara_num", profile.get_int('chara', -1)))
+                node.add_child(Node.s32("total_score", new_course.get_int('score')))
+                node.add_child(Node.u8("clear_type", new_course.get_int('clear_type')))
+                node.add_child(Node.u8("clear_rank", new_course.get_int('clear_rank')))
+                node.add_child(Node.s16("player_count", len(ranklist)))
+                node.add_child(Node.s16("player_rank", rank))
+
+        return root
+
+    def handle_player24_read_score_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            return Node.void('player24')
+
+        root = Node.void('player24')
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s32('score', score.points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[score.data.get_int('medal')]))
+            music.add_child(Node.u8('clear_rank', self.__score_to_rank(score.points)))
+            music.add_child(Node.s16('cnt', score.plays))
+
+        return root
+
+    def handle_player24_write_music_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        root = Node.void('player24')
+        if refid is None:
+            return root
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            return root
+
+        songid = request.child_value('music_num')
+        chart = {
+            self.GAME_CHART_TYPE_EASY: self.CHART_TYPE_EASY,
+            self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL,
+            self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER,
+            self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX,
+        }[request.child_value('sheet_num')]
+        medal = request.child_value('clear_type')
+        points = request.child_value('score')
+        combo = request.child_value('combo')
+        stats = {
+            'cool': request.child_value('cool'),
+            'great': request.child_value('great'),
+            'good': request.child_value('good'),
+            'bad': request.child_value('bad')
+        }
+        medal = {
+            self.GAME_PLAY_MEDAL_CIRCLE_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED,
+            self.GAME_PLAY_MEDAL_DIAMOND_FAILED: self.PLAY_MEDAL_DIAMOND_FAILED,
+            self.GAME_PLAY_MEDAL_STAR_FAILED: self.PLAY_MEDAL_STAR_FAILED,
+            self.GAME_PLAY_MEDAL_EASY_CLEAR: self.PLAY_MEDAL_EASY_CLEAR,
+            self.GAME_PLAY_MEDAL_CIRCLE_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED,
+            self.GAME_PLAY_MEDAL_DIAMOND_CLEARED: self.PLAY_MEDAL_DIAMOND_CLEARED,
+            self.GAME_PLAY_MEDAL_STAR_CLEARED: self.PLAY_MEDAL_STAR_CLEARED,
+            self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO,
+            self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO: self.PLAY_MEDAL_DIAMOND_FULL_COMBO,
+            self.GAME_PLAY_MEDAL_STAR_FULL_COMBO: self.PLAY_MEDAL_STAR_FULL_COMBO,
+            self.GAME_PLAY_MEDAL_PERFECT: self.PLAY_MEDAL_PERFECT,
+        }[medal]
+        self.update_score(userid, songid, chart, points, medal, combo=combo, stats=stats)
+        return root
+
+    def handle_player24_start_request(self, request: Node) -> Node:
+        root = Node.void('player24')
+        root.add_child(Node.s32('play_id', 0))
+        self.__construct_common_info(root)
+        return root
+
+    def handle_player24_logout_request(self, request: Node) -> Node:
+        return Node.void('player24')
+
+    def handle_player24_buy_request(self, request: Node) -> Node:
+        refid = request.child_value('ref_id')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            itemid = request.child_value('id')
+            itemtype = request.child_value('type')
+            itemparam = request.child_value('param')
+
+            price = request.child_value('price')
+            lumina = request.child_value('lumina')
+
+            if lumina >= price:
+                # Update player lumina balance
+                profile = self.get_profile(userid) or ValidatedDict()
+                profile.replace_int('player_point', lumina - price)
+                self.put_profile(userid, profile)
+
+                # Grant the object
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    itemid,
+                    'item_{}'.format(itemtype),
+                    {
+                        'param': itemparam,
+                        'is_new': True,
+                    },
+                )
+
+        return Node.void('player24')
+
+    def format_conversion(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('player24')
+        root.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        root.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        root.add_child(Node.s8('con_type', 0))
+        root.add_child(Node.s8('result', 1))
+
+        # Scores
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s32('score', score.points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[score.data.get_int('medal')]))
+            music.add_child(Node.u8('clear_rank', self.__score_to_rank(score.points)))
+            music.add_child(Node.s16('cnt', score.plays))
+
+        return root
+
+    def format_extid(self, extid: int) -> str:
+        data = str(extid)
+        crc = abs(binascii.crc32(data.encode('ascii'))) % 10000
+        return '{}{:04d}'.format(data, crc)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        root = Node.void('player24')
+
+        # Mark this as a current profile
+        root.add_child(Node.s8('result', 0))
+
+        # Basic account info
+        account = Node.void('account')
+        root.add_child(account)
+        account.add_child(Node.string('g_pm_id', self.format_extid(profile.get_int('extid'))))
+        account.add_child(Node.string('name', profile.get_str('name', 'なし')))
+        account.add_child(Node.s16('tutorial', profile.get_int('tutorial')))
+        account.add_child(Node.s16('area_id', profile.get_int('area_id')))
+        account.add_child(Node.s16('use_navi', profile.get_int('use_navi')))
+        account.add_child(Node.s16('read_news', profile.get_int('read_news')))
+        account.add_child(Node.s16_array('nice', profile.get_int_array('nice', 30, [-1] * 30)))
+        account.add_child(Node.s16_array('favorite_chara', profile.get_int_array('favorite_chara', 20, [-1] * 20)))
+        account.add_child(Node.s16_array('special_area', profile.get_int_array('special_area', 8, [-1] * 8)))
+        account.add_child(Node.s16_array('chocolate_charalist', profile.get_int_array('chocolate_charalist', 5, [-1] * 5)))
+        account.add_child(Node.s32('chocolate_sp_chara', profile.get_int('chocolate_sp_chara', -1)))
+        account.add_child(Node.s32('chocolate_pass_cnt', profile.get_int('chocolate_pass_cnt')))
+        account.add_child(Node.s32('chocolate_hon_cnt', profile.get_int('chocolate_hon_cnt')))
+        account.add_child(Node.s16_array('teacher_setting', profile.get_int_array('teacher_setting', 10, [-1] * 10)))
+        account.add_child(Node.bool('welcom_pack', profile.get_bool('welcome_pack')))
+        account.add_child(Node.s32('ranking_node', profile.get_int('ranking_node')))
+        account.add_child(Node.s32('chara_ranking_kind_id', profile.get_int('chara_ranking_kind_id')))
+        account.add_child(Node.s8('navi_evolution_flg', profile.get_int('navi_evolution_flg')))
+        account.add_child(Node.s32('ranking_news_last_no', profile.get_int('ranking_news_last_no')))
+        account.add_child(Node.s32('power_point', profile.get_int('power_point')))
+        account.add_child(Node.s32('player_point', profile.get_int('player_point', 300)))
+        account.add_child(Node.s32_array('power_point_list', profile.get_int_array('power_point_list', 20, [-1] * 20)))
+
+        # Stuff we never change
+        account.add_child(Node.s8('staff', 0))
+        account.add_child(Node.s16('item_type', 0))
+        account.add_child(Node.s16('item_id', 0))
+        account.add_child(Node.s8('is_conv', 0))
+        account.add_child(Node.s16_array('license_data', [-1] * 20))
+
+        # Song statistics
+        last_played = [x[0] for x in self.data.local.music.get_last_played(self.game, self.version, userid, 10)]
+        most_played = [x[0] for x in self.data.local.music.get_most_played(self.game, self.version, userid, 20)]
+        while len(last_played) < 10:
+            last_played.append(-1)
+        while len(most_played) < 20:
+            most_played.append(-1)
+
+        account.add_child(Node.s16_array('my_best', most_played))
+        account.add_child(Node.s16_array('latest_music', last_played))
+
+        # Player statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        account.add_child(Node.s16('total_play_cnt', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s16('today_play_cnt', today_count))
+        account.add_child(Node.s16('consecutive_days', statistics.get_int('consecutive_days', 0)))
+        account.add_child(Node.s16('total_days', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s16('interval_day', 0))
+
+        # TODO: Hook up rivals for Pop'n Music?
+        account.add_child(Node.u8('active_fr_num', 0))
+
+        # eAmuse account link
+        eaappli = Node.void('eaappli')
+        root.add_child(eaappli)
+        eaappli.add_child(Node.s8('relation', -1))
+
+        # Player info
+        info = Node.void('info')
+        root.add_child(info)
+        info.add_child(Node.u16('ep', profile.get_int('ep')))
+
+        # Player config
+        config = Node.void('config')
+        root.add_child(config)
+        config.add_child(Node.u8('mode', profile.get_int('mode')))
+        config.add_child(Node.s16('chara', profile.get_int('chara', -1)))
+        config.add_child(Node.s16('music', profile.get_int('music', -1)))
+        config.add_child(Node.u8('sheet', profile.get_int('sheet')))
+        config.add_child(Node.s8('category', profile.get_int('category', -1)))
+        config.add_child(Node.s8('sub_category', profile.get_int('sub_category', -1)))
+        config.add_child(Node.s8('chara_category', profile.get_int('chara_category', -1)))
+        config.add_child(Node.s16('course_id', profile.get_int('course_id', -1)))
+        config.add_child(Node.s8('course_folder', profile.get_int('course_folder', -1)))
+        config.add_child(Node.s8('ms_banner_disp', profile.get_int('ms_banner_disp', -1)))
+        config.add_child(Node.s8('ms_down_info', profile.get_int('ms_down_info', -1)))
+        config.add_child(Node.s8('ms_side_info', profile.get_int('ms_side_info', -1)))
+        config.add_child(Node.s8('ms_raise_type', profile.get_int('ms_raise_type', -1)))
+        config.add_child(Node.s8('ms_rnd_type', profile.get_int('ms_rnd_type', -1)))
+        config.add_child(Node.s8('banner_sort', profile.get_int('banner_sort', -1)))
+
+        # Player options
+        option = Node.void('option')
+        option_dict = profile.get_dict('option')
+        root.add_child(option)
+        option.add_child(Node.s16('hispeed', option_dict.get_int('hispeed')))
+        option.add_child(Node.u8('popkun', option_dict.get_int('popkun')))
+        option.add_child(Node.bool('hidden', option_dict.get_bool('hidden')))
+        option.add_child(Node.s16('hidden_rate', option_dict.get_int('hidden_rate')))
+        option.add_child(Node.bool('sudden', option_dict.get_bool('sudden')))
+        option.add_child(Node.s16('sudden_rate', option_dict.get_int('sudden_rate')))
+        option.add_child(Node.s8('randmir', option_dict.get_int('randmir')))
+        option.add_child(Node.s8('gauge_type', option_dict.get_int('gauge_type')))
+        option.add_child(Node.u8('ojama_0', option_dict.get_int('ojama_0')))
+        option.add_child(Node.u8('ojama_1', option_dict.get_int('ojama_1')))
+        option.add_child(Node.bool('forever_0', option_dict.get_bool('forever_0')))
+        option.add_child(Node.bool('forever_1', option_dict.get_bool('forever_1')))
+        option.add_child(Node.bool('full_setting', option_dict.get_bool('full_setting')))
+        option.add_child(Node.u8('judge', option_dict.get_int('judge')))
+        option.add_child(Node.s8('guide_se', option_dict.get_int('guide_se')))
+
+        # Player custom category
+        custom_cate = Node.void('custom_cate')
+        root.add_child(custom_cate)
+        custom_cate.add_child(Node.s8('valid', 0))
+        custom_cate.add_child(Node.s8('lv_min', -1))
+        custom_cate.add_child(Node.s8('lv_max', -1))
+        custom_cate.add_child(Node.s8('medal_min', -1))
+        custom_cate.add_child(Node.s8('medal_max', -1))
+        custom_cate.add_child(Node.s8('friend_no', -1))
+        custom_cate.add_child(Node.s8('score_flg', -1))
+
+        # Navi data
+        navi_data = Node.void('navi_data')
+        root.add_child(navi_data)
+        if 'navi_points' in profile:
+            navi_data.add_child(Node.s32_array('raisePoint', profile.get_int_array('navi_points', 5)))
+
+        # Set up achievements
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        for achievement in achievements:
+            if achievement.type[:5] == 'item_':
+                itemtype = int(achievement.type[5:])
+                param = achievement.data.get_int('param')
+                is_new = achievement.data.get_bool('is_new')
+                get_time = achievement.data.get_int('get_time')
+
+                item = Node.void('item')
+                root.add_child(item)
+                # Item type can be 0-6 inclusive and is the type of the unlock/item.
+                # Item 0 is music unlocks. In this case, the id is the song ID according
+                # to the game. Unclear what the param is supposed to be, but i've seen
+                # seen 8 and 0. Might be what chart is available?
+                #
+                # Item limits are as follows:
+                # 0: 1704
+                # 1: 2201
+                # 2: 3
+                # 3: 97
+                # 4: 1
+                # 5: 1
+                # 6: 60
+                item.add_child(Node.u8('type', itemtype))
+                item.add_child(Node.u16('id', achievement.id))
+                item.add_child(Node.u16('param', param))
+                item.add_child(Node.bool('is_new', is_new))
+                item.add_child(Node.u64('get_time', get_time))
+
+            elif achievement.type == 'chara':
+                friendship = achievement.data.get_int('friendship')
+
+                chara = Node.void('chara_param')
+                root.add_child(chara)
+                chara.add_child(Node.u16('chara_id', achievement.id))
+                chara.add_child(Node.u16('friendship', friendship))
+
+            elif achievement.type == 'navi':
+                # There should only be 12 of these.
+                friendship = achievement.data.get_int('friendship')
+
+                # This relies on the above Navi data section to ensure the navi_param
+                # node is created.
+                navi_param = Node.void('navi_param')
+                navi_data.add_child(navi_param)
+                navi_param.add_child(Node.u16('navi_id', achievement.id))
+                navi_param.add_child(Node.s32('friendship', friendship))
+
+            elif achievement.type == 'area':
+                # There should only be 16 of these.
+                index = achievement.data.get_int('index')
+                points = achievement.data.get_int('points')
+                cleared = achievement.data.get_bool('cleared')
+                diary = achievement.data.get_int('diary')
+
+                area = Node.void('area')
+                root.add_child(area)
+                area.add_child(Node.u32('area_id', achievement.id))
+                area.add_child(Node.u8('chapter_index', index))
+                area.add_child(Node.u16('gauge_point', points))
+                area.add_child(Node.bool('is_cleared', cleared))
+                area.add_child(Node.u32('diary', diary))
+
+            elif achievement.type[:7] == 'course_':
+                sheet = int(achievement.type[7:])
+
+                course_data = Node.void('course_data')
+                root.add_child(course_data)
+                course_data.add_child(Node.s16('course_id', achievement.id))
+                course_data.add_child(Node.u8('clear_type', achievement.data.get_int('clear_type')))
+                course_data.add_child(Node.u8('clear_rank', achievement.data.get_int('clear_rank')))
+                course_data.add_child(Node.s32('total_score', achievement.data.get_int('score')))
+                course_data.add_child(Node.s32('update_count', achievement.data.get_int('count')))
+                course_data.add_child(Node.u8('sheet_num', sheet))
+
+            elif achievement.type == 'fes':
+                index = achievement.data.get_int('index')
+                points = achievement.data.get_int('points')
+                cleared = achievement.data.get_bool('cleared')
+
+                fes = Node.void('fes')
+                root.add_child(fes)
+                fes.add_child(Node.u32('fes_id', achievement.id))
+                fes.add_child(Node.u8('chapter_index', index))
+                fes.add_child(Node.u16('gauge_point', points))
+                fes.add_child(Node.bool('is_cleared', cleared))
+
+        # Handle daily mission
+        achievements = self.data.local.user.get_time_based_achievements(
+            self.game,
+            self.version,
+            userid,
+            since=Time.beginning_of_today(),
+            until=Time.end_of_today(),
+        )
+        achievements = sorted(achievements, key=lambda a: a.timestamp)
+        daily_missions: Dict[int, ValidatedDict] = {
+            1: ValidatedDict(),
+            2: ValidatedDict(),
+            3: ValidatedDict(),
+        }
+        # Find the newest version of each daily mission completion,
+        # since we've sorted by time above. If we haven't started for
+        # today, the defaults will be set so we at least give the game
+        # the right ID.
+        for achievement in achievements:
+            if achievement.type == 'mission':
+                daily_missions[achievement.id] = achievement.data
+
+        for daily_id, data in daily_missions.items():
+            points = data.get_int('points')
+            complete = data.get_int('complete')
+
+            mission = Node.void('mission')
+            root.add_child(mission)
+            mission.add_child(Node.u32('mission_id', daily_id))
+            mission.add_child(Node.u32('gauge_point', points))
+            mission.add_child(Node.u32('mission_comp', complete))
+
+        # Scores
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        for score in scores:
+            # Skip any scores for chart types we don't support
+            if score.chart not in [
+                self.CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX,
+            ]:
+                continue
+
+            music = Node.void('music')
+            root.add_child(music)
+            music.add_child(Node.s16('music_num', score.id))
+            music.add_child(Node.u8('sheet_num', {
+                self.CHART_TYPE_EASY: self.GAME_CHART_TYPE_EASY,
+                self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_NORMAL,
+                self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_HYPER,
+                self.CHART_TYPE_EX: self.GAME_CHART_TYPE_EX,
+            }[score.chart]))
+            music.add_child(Node.s32('score', score.points))
+            music.add_child(Node.u8('clear_type', {
+                self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_MEDAL_CIRCLE_FAILED,
+                self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_MEDAL_DIAMOND_FAILED,
+                self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_MEDAL_STAR_FAILED,
+                self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_MEDAL_EASY_CLEAR,
+                self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_MEDAL_CIRCLE_CLEARED,
+                self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_MEDAL_DIAMOND_CLEARED,
+                self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_MEDAL_STAR_CLEARED,
+                self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+                self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+                self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_MEDAL_STAR_FULL_COMBO,
+                self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_MEDAL_PERFECT,
+            }[score.data.get_int('medal')]))
+            music.add_child(Node.u8('clear_rank', self.__score_to_rank(score.points)))
+            music.add_child(Node.s16('cnt', score.plays))
+
+        # Player netvs section
+        netvs = Node.void('netvs')
+        root.add_child(netvs)
+        netvs.add_child(Node.s16_array('record', [0] * 6))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.string('dialog', ''))
+        netvs.add_child(Node.s8_array('ojama_condition', [0] * 74))
+        netvs.add_child(Node.s8_array('set_ojama', [0] * 3))
+        netvs.add_child(Node.s8_array('set_recommend', [0] * 3))
+        netvs.add_child(Node.u32('netvs_play_cnt', 0))
+
+        # Player customize section
+        customize = Node.void('customize')
+        root.add_child(customize)
+        customize.add_child(Node.u16('effect_left', 0))
+        customize.add_child(Node.u16('effect_center', 0))
+        customize.add_child(Node.u16('effect_right', 0))
+        customize.add_child(Node.u16('hukidashi', 0))
+        customize.add_child(Node.u16('comment_1', 0))
+        customize.add_child(Node.u16('comment_2', 0))
+
+        # Stamp stuff
+        stamp = Node.void('stamp')
+        root.add_child(stamp)
+        stamp.add_child(Node.s16('stamp_id', profile.get_int('stamp_id')))
+        stamp.add_child(Node.s16('cnt', profile.get_int('stamp_cnt')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Set that we've seen this profile
+        newprofile.replace_bool('welcome_pack', True)
+
+        account = request.child('account')
+        if account is not None:
+            newprofile.replace_int('tutorial', account.child_value('tutorial'))
+            newprofile.replace_int('read_news', account.child_value('read_news'))
+            newprofile.replace_int('area_id', account.child_value('area_id'))
+            newprofile.replace_int('use_navi', account.child_value('use_navi'))
+            newprofile.replace_int('ranking_node', account.child_value('ranking_node'))
+            newprofile.replace_int('chara_ranking_kind_id', account.child_value('chara_ranking_kind_id'))
+            newprofile.replace_int('navi_evolution_flg', account.child_value('navi_evolution_flg'))
+            newprofile.replace_int('ranking_news_last_no', account.child_value('ranking_news_last_no'))
+            newprofile.replace_int('power_point', account.child_value('power_point'))
+            newprofile.replace_int('player_point', account.child_value('player_point'))
+
+            newprofile.replace_int_array('nice', 30, account.child_value('nice'))
+            newprofile.replace_int_array('favorite_chara', 20, account.child_value('favorite_chara'))
+            newprofile.replace_int_array('special_area', 8, account.child_value('special_area'))
+            newprofile.replace_int_array('chocolate_charalist', 5, account.child_value('chocolate_charalist'))
+            newprofile.replace_int('chocolate_sp_chara', account.child_value('chocolate_sp_chara'))
+            newprofile.replace_int('chocolate_pass_cnt', account.child_value('chocolate_pass_cnt'))
+            newprofile.replace_int('chocolate_hon_cnt', account.child_value('chocolate_hon_cnt'))
+            newprofile.replace_int('chocolate_giri_cnt', account.child_value('chocolate_giri_cnt'))
+            newprofile.replace_int('chocolate_kokyu_cnt', account.child_value('chocolate_kokyu_cnt'))
+            newprofile.replace_int_array('teacher_setting', 10, account.child_value('teacher_setting'))
+            newprofile.replace_int_array('power_point_list', 20, account.child_value('power_point_list'))
+
+        info = request.child('info')
+        if info is not None:
+            newprofile.replace_int('ep', info.child_value('ep'))
+
+        stamp = request.child('stamp')
+        if stamp is not None:
+            newprofile.replace_int('stamp_id', stamp.child_value('stamp_id'))
+            newprofile.replace_int('stamp_cnt', stamp.child_value('cnt'))
+
+        config = request.child('config')
+        if config is not None:
+            newprofile.replace_int('mode', config.child_value('mode'))
+            newprofile.replace_int('chara', config.child_value('chara'))
+            newprofile.replace_int('music', config.child_value('music'))
+            newprofile.replace_int('sheet', config.child_value('sheet'))
+            newprofile.replace_int('category', config.child_value('category'))
+            newprofile.replace_int('sub_category', config.child_value('sub_category'))
+            newprofile.replace_int('chara_category', config.child_value('chara_category'))
+            newprofile.replace_int('course_id', config.child_value('course_id'))
+            newprofile.replace_int('course_folder', config.child_value('course_folder'))
+            newprofile.replace_int('ms_banner_disp', config.child_value('ms_banner_disp'))
+            newprofile.replace_int('ms_down_info', config.child_value('ms_down_info'))
+            newprofile.replace_int('ms_side_info', config.child_value('ms_side_info'))
+            newprofile.replace_int('ms_raise_type', config.child_value('ms_raise_type'))
+            newprofile.replace_int('ms_rnd_type', config.child_value('ms_rnd_type'))
+            newprofile.replace_int('banner_sort', config.child_value('banner_sort'))
+
+        option_dict = newprofile.get_dict('option')
+        option = request.child('option')
+        if option is not None:
+            option_dict.replace_int('hispeed', option.child_value('hispeed'))
+            option_dict.replace_int('popkun', option.child_value('popkun'))
+            option_dict.replace_bool('hidden', option.child_value('hidden'))
+            option_dict.replace_int('hidden_rate', option.child_value('hidden_rate'))
+            option_dict.replace_bool('sudden', option.child_value('sudden'))
+            option_dict.replace_int('sudden_rate', option.child_value('sudden_rate'))
+            option_dict.replace_int('randmir', option.child_value('randmir'))
+            option_dict.replace_int('gauge_type', option.child_value('gauge_type'))
+            option_dict.replace_int('ojama_0', option.child_value('ojama_0'))
+            option_dict.replace_int('ojama_1', option.child_value('ojama_1'))
+            option_dict.replace_bool('forever_0', option.child_value('forever_0'))
+            option_dict.replace_bool('forever_1', option.child_value('forever_1'))
+            option_dict.replace_bool('full_setting', option.child_value('full_setting'))
+            option_dict.replace_int('judge', option.child_value('judge'))
+            option_dict.replace_int('guide_se', option.child_value('guide_se'))
+        newprofile.replace_dict('option', option_dict)
+
+        navi_data = request.child('navi_data')
+        if navi_data is not None:
+            newprofile.replace_int_array('navi_points', 5, navi_data.child_value('raisePoint'))
+
+            # Extract navi achievements
+            for node in navi_data.children:
+                if node.name == 'navi_param':
+                    navi_id = node.child_value('navi_id')
+                    friendship = node.child_value('friendship')
+
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        navi_id,
+                        'navi',
+                        {
+                            'friendship': friendship,
+                        },
+                    )
+
+        # Extract achievements
+        for node in request.children:
+            if node.name == 'item':
+                itemid = node.child_value('id')
+                itemtype = node.child_value('type')
+                param = node.child_value('param')
+                is_new = node.child_value('is_new')
+                get_time = node.child_value('get_time')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    itemid,
+                    'item_{}'.format(itemtype),
+                    {
+                        'param': param,
+                        'is_new': is_new,
+                        'get_time': get_time,
+                    },
+                )
+
+            elif node.name == 'chara_param':
+                charaid = node.child_value('chara_id')
+                friendship = node.child_value('friendship')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    charaid,
+                    'chara',
+                    {
+                        'friendship': friendship,
+                    },
+                )
+
+            elif node.name == 'area':
+                area_id = node.child_value('area_id')
+                index = node.child_value('chapter_index')
+                points = node.child_value('gauge_point')
+                cleared = node.child_value('is_cleared')
+                diary = node.child_value('diary')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    area_id,
+                    'area',
+                    {
+                        'index': index,
+                        'points': points,
+                        'cleared': cleared,
+                        'diary': diary,
+                    },
+                )
+
+            elif node.name == 'mission':
+                # If you don't send the right values on login, then
+                # the game sends 0 for mission_id three times. Skip
+                # those values since they're bogus.
+                mission_id = node.child_value('mission_id')
+                if mission_id > 0:
+                    points = node.child_value('gauge_point')
+                    complete = node.child_value('mission_comp')
+
+                    self.data.local.user.put_time_based_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        mission_id,
+                        'mission',
+                        {
+                            'points': points,
+                            'complete': complete,
+                        },
+                    )
+
+        # Unlock NAVI-kun and Kenshi Yonezu after one play
+        for songid in [1592, 1608]:
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                'item_0',
+                {
+                    'param': 0xF,
+                    'is_new': False,
+                    'get_time': Time.now(),
+                },
+            )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/__init__.py b/bemani/backend/reflec/__init__.py
new file mode 100644
index 0000000..4de33e7
--- /dev/null
+++ b/bemani/backend/reflec/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.reflec.factory import ReflecBeatFactory
+from bemani.backend.reflec.base import ReflecBeatBase
diff --git a/bemani/backend/reflec/base.py b/bemani/backend/reflec/base.py
new file mode 100644
index 0000000..8c012bd
--- /dev/null
+++ b/bemani/backend/reflec/base.py
@@ -0,0 +1,276 @@
+# vim: set fileencoding=utf-8
+from typing import Dict, List, Optional
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import ValidatedDict, GameConstants, DBConstants, Time
+from bemani.data import Machine, ScoreSaveException, UserID
+from bemani.protocol import Node
+
+
+class ReflecBeatBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all Reflec Beat version that we support.
+    """
+
+    game = GameConstants.REFLEC_BEAT
+
+    # Chart types, as stored in the DB
+    CHART_TYPE_BASIC = 0
+    CHART_TYPE_MEDIUM = 1
+    CHART_TYPE_HARD = 2
+    CHART_TYPE_SPECIAL = 3
+
+    # Clear types, as saved/loaded from the DB
+    CLEAR_TYPE_NO_PLAY = DBConstants.REFLEC_BEAT_CLEAR_TYPE_NO_PLAY
+    CLEAR_TYPE_FAILED = DBConstants.REFLEC_BEAT_CLEAR_TYPE_FAILED
+    CLEAR_TYPE_CLEARED = DBConstants.REFLEC_BEAT_CLEAR_TYPE_CLEARED
+    CLEAR_TYPE_HARD_CLEARED = DBConstants.REFLEC_BEAT_CLEAR_TYPE_HARD_CLEARED
+    CLEAR_TYPE_S_HARD_CLEARED = DBConstants.REFLEC_BEAT_CLEAR_TYPE_S_HARD_CLEARED
+
+    # Combo types, as saved/loaded from the DB
+    COMBO_TYPE_NONE = DBConstants.REFLEC_BEAT_COMBO_TYPE_NONE
+    COMBO_TYPE_ALMOST_COMBO = DBConstants.REFLEC_BEAT_COMBO_TYPE_ALMOST_COMBO
+    COMBO_TYPE_FULL_COMBO = DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO
+    COMBO_TYPE_FULL_COMBO_ALL_JUST = DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO_ALL_JUST
+
+    def previous_version(self) -> Optional['ReflecBeatBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def extra_services(self) -> List[str]:
+        """
+        Return the local2 and lobby2 service so that matching will work on newer
+        Reflec Beat games.
+        """
+        return [
+            'local2',
+            'lobby2',
+        ]
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('pc')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication.
+        """
+        if refid is None:
+            return None
+
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            # User doesn't exist but should at this point
+            return None
+
+        # Trying to import from current version
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+        return self.format_profile(userid, profile)
+
+    def put_profile_by_refid(self, refid: Optional[str], request: Node) -> Optional[ValidatedDict]:
+        """
+        Given a RefID and a request node, unformat the profile and save it.
+        """
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            return None
+
+        oldprofile = self.get_profile(userid)
+        if oldprofile is None:
+            # Create one so we can get refid/extid
+            self.put_profile(userid, ValidatedDict())
+            oldprofile = self.get_profile(userid)
+        newprofile = self.unformat_profile(userid, request, oldprofile)
+        if newprofile is not None:
+            self.put_profile(userid, newprofile)
+            return newprofile
+        else:
+            return oldprofile
+
+    def get_machine_by_id(self, shop_id: int) -> Optional[Machine]:
+        pcbid = self.data.local.machine.from_machine_id(shop_id)
+        if pcbid is not None:
+            return self.data.local.machine.get_machine(pcbid)
+        else:
+            return None
+
+    def update_score(
+        self,
+        userid: UserID,
+        songid: int,
+        chart: int,
+        points: int,
+        achievement_rate: int,
+        clear_type: int,
+        combo_type: int,
+        miss_count: int,
+        combo: Optional[int]=None,
+        stats: Optional[Dict[str, int]]=None,
+        param: Optional[int]=None,
+        kflag: Optional[int]=None,
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in Reflec series can expect
+        the same attributes in a score. Note that the clear_types passed here are
+        expected to be converted from game identifier to our internal identifier,
+        so that any game in the series may convert them back.
+        """
+        # Range check clear type
+        if clear_type not in [
+            self.CLEAR_TYPE_NO_PLAY,
+            self.CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_HARD_CLEARED,
+            self.CLEAR_TYPE_S_HARD_CLEARED,
+        ]:
+            raise Exception("Invalid clear_type value {}".format(clear_type))
+
+        # Range check combo type
+        if combo_type not in [
+            self.COMBO_TYPE_NONE,
+            self.COMBO_TYPE_ALMOST_COMBO,
+            self.COMBO_TYPE_FULL_COMBO,
+            self.COMBO_TYPE_FULL_COMBO_ALL_JUST,
+        ]:
+            raise Exception("Invalid combo_type value {}".format(combo_type))
+
+        oldscore = self.data.local.music.get_score(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+        )
+
+        # Score history is verbatum, instead of highest score
+        now = Time.now()
+        history = ValidatedDict({})
+        oldpoints = points
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({})
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            highscore = points >= oldscore.points
+            points = max(points, oldscore.points)
+            scoredata = oldscore.data
+
+        # Update the last played time
+        scoredata.replace_int('last_played_time', now)
+
+        # Replace clear type with highest value and timestamps
+        if clear_type >= scoredata.get_int('clear_type'):
+            scoredata.replace_int('clear_type', max(scoredata.get_int('clear_type'), clear_type))
+            scoredata.replace_int('best_clear_type_time', now)
+        history.replace_int('clear_type', clear_type)
+
+        # Replace combo type with highest value and timestamps
+        if combo_type >= scoredata.get_int('combo_type'):
+            scoredata.replace_int('combo_type', max(scoredata.get_int('combo_type'), combo_type))
+            scoredata.replace_int('best_clear_type_time', now)
+        history.replace_int('combo_type', combo_type)
+
+        # Update the combo for this song
+        if combo is not None:
+            scoredata.replace_int('combo', max(scoredata.get_int('combo'), combo))
+            history.replace_int('combo', combo)
+
+        # Update the param for this song
+        if param is not None:
+            scoredata.replace_int('param', max(scoredata.get_int('param'), param))
+            history.replace_int('param', param)
+
+        # Update the kflag for this song
+        if kflag is not None:
+            scoredata.replace_int('kflag', max(scoredata.get_int('kflag'), kflag))
+            history.replace_int('kflag', kflag)
+
+        # Update win/lost/draw stats for this song
+        if stats is not None:
+            scoredata.replace_dict('stats', stats)
+            history.replace_dict('stats', stats)
+
+        # Update the achievement rate with timestamps
+        if achievement_rate >= scoredata.get_int('achievement_rate'):
+            scoredata.replace_int('achievement_rate', max(scoredata.get_int('achievement_rate'), achievement_rate))
+            scoredata.replace_int('best_achievement_rate_time', now)
+        history.replace_int('achievement_rate', achievement_rate)
+
+        # Update the miss count with timestamps, either if it was lowered, or if the old value was blank.
+        # If the new value is -1 (we didn't get a miss count this time), never update the old value.
+        if miss_count >= 0:
+            if miss_count <= scoredata.get_int('miss_count', 999999) or scoredata.get_int('miss_count') == -1:
+                scoredata.replace_int('miss_count', min(scoredata.get_int('miss_count', 999999), miss_count))
+                scoredata.replace_int('best_miss_count_time', now)
+        history.replace_int('miss_count', miss_count)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        # Reflec Beat happens to send all songs that were played by a player
+        # at the end of the round. It sends timestamps for the songs, but as of
+        # Colette they were identical for each song in the round. So, if a user
+        # plays the same song/chart# more than once in a round, we will end up
+        # failing to store the attempt since we don't allow two of the same
+        # attempt at the same time for the same user and song/chart. So, bump
+        # the timestamp by one second and retry well past the maximum number of
+        # songs.
+        for bump in range(10):
+            timestamp = now + bump
+
+            # Write the new score back
+            self.data.local.music.put_score(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                chart,
+                lid,
+                points,
+                scoredata,
+                highscore,
+                timestamp=timestamp,
+            )
+
+            try:
+                # Save the history of this score too
+                self.data.local.music.put_attempt(
+                    self.game,
+                    self.version,
+                    userid,
+                    songid,
+                    chart,
+                    lid,
+                    oldpoints,
+                    history,
+                    highscore,
+                    timestamp=timestamp,
+                )
+            except ScoreSaveException:
+                # Try again one second in the future
+                continue
+
+            # We saved successfully
+            break
diff --git a/bemani/backend/reflec/colette.py b/bemani/backend/reflec/colette.py
new file mode 100644
index 0000000..95f1f22
--- /dev/null
+++ b/bemani/backend/reflec/colette.py
@@ -0,0 +1,1221 @@
+import copy
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.backend.reflec.base import ReflecBeatBase
+from bemani.backend.reflec.limelight import ReflecBeatLimelight
+
+from bemani.common import ValidatedDict, VersionConstants, ID, Time
+from bemani.data import UserID, Achievement
+from bemani.protocol import Node
+
+
+class ReflecBeatColette(ReflecBeatBase):
+
+    name = "REFLEC BEAT colette"
+    version = VersionConstants.REFLEC_BEAT_COLETTE
+
+    # Clear types according to the game
+    GAME_CLEAR_TYPE_NO_PLAY = 0
+    GAME_CLEAR_TYPE_FAILED = 1
+    GAME_CLEAR_TYPE_CLEARED = 2
+    GAME_CLEAR_TYPE_ALMOST_COMBO = 3
+    GAME_CLEAR_TYPE_FULL_COMBO = 4
+
+    def previous_version(self) -> Optional[ReflecBeatBase]:
+        return ReflecBeatLimelight(self.data, self.config, self.model)
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+            'ints': [],
+        }
+
+    def __db_to_game_clear_type(self, db_clear_type: int, db_combo_type: int) -> int:
+        if db_clear_type == self.CLEAR_TYPE_NO_PLAY:
+            return self.GAME_CLEAR_TYPE_NO_PLAY
+        if db_clear_type == self.CLEAR_TYPE_FAILED:
+            return self.GAME_CLEAR_TYPE_FAILED
+        if db_clear_type in [
+            self.CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_HARD_CLEARED,
+            self.CLEAR_TYPE_S_HARD_CLEARED,
+        ]:
+            if db_combo_type == self.COMBO_TYPE_NONE:
+                return self.GAME_CLEAR_TYPE_CLEARED
+            if db_combo_type == self.COMBO_TYPE_ALMOST_COMBO:
+                return self.GAME_CLEAR_TYPE_ALMOST_COMBO
+            if db_combo_type in [
+                self.COMBO_TYPE_FULL_COMBO,
+                self.COMBO_TYPE_FULL_COMBO_ALL_JUST,
+            ]:
+                return self.GAME_CLEAR_TYPE_FULL_COMBO
+            raise Exception('Invalid db_combo_type {}'.format(db_combo_type))
+        raise Exception('Invalid db_clear_type {}'.format(db_clear_type))
+
+    def __game_to_db_clear_type(self, game_clear_type: int) -> Tuple[int, int]:
+        if game_clear_type == self.GAME_CLEAR_TYPE_NO_PLAY:
+            return (self.CLEAR_TYPE_NO_PLAY, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_FAILED:
+            return (self.CLEAR_TYPE_FAILED, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_CLEARED:
+            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_ALMOST_COMBO:
+            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_ALMOST_COMBO)
+        if game_clear_type == self.GAME_CLEAR_TYPE_FULL_COMBO:
+            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_FULL_COMBO)
+
+        raise Exception('Invalid game_clear_type {}'.format(game_clear_type))
+
+    def handle_pcb_error_request(self, request: Node) -> Node:
+        return Node.void('pcb')
+
+    def handle_pcb_uptime_update_request(self, request: Node) -> Node:
+        return Node.void('pcb')
+
+    def handle_pcb_boot_request(self, request: Node) -> Node:
+        shop_id = ID.parse_machine_id(request.child_value('lid'))
+        machine = self.get_machine_by_id(shop_id)
+        if machine is not None:
+            machine_name = machine.name
+            close = machine.data.get_bool('close')
+            hour = machine.data.get_int('hour')
+            minute = machine.data.get_int('minute')
+        else:
+            machine_name = ''
+            close = False
+            hour = 0
+            minute = 0
+
+        root = Node.void('pcb')
+        sinfo = Node.void('sinfo')
+        root.add_child(sinfo)
+        sinfo.add_child(Node.string('nm', machine_name))
+        sinfo.add_child(Node.bool('cl_enbl', close))
+        sinfo.add_child(Node.u8('cl_h', hour))
+        sinfo.add_child(Node.u8('cl_m', minute))
+        return root
+
+    def handle_shop_setting_write_request(self, request: Node) -> Node:
+        return Node.void('shop')
+
+    def handle_shop_info_write_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('sinfo/nm'))
+        self.update_machine_data({
+            'close': request.child_value('sinfo/cl_enbl'),
+            'hour': request.child_value('sinfo/cl_h'),
+            'minute': request.child_value('sinfo/cl_m'),
+            'pref': request.child_value('sinfo/prf'),
+        })
+        return Node.void('shop')
+
+    def __add_event_info(self, root: Node) -> None:
+        event_ctrl = Node.void('event_ctrl')
+        root.add_child(event_ctrl)
+
+        events: Dict[int, int] = {
+            # Tricolette Park unlock event.
+            9: 0,
+        }
+
+        for (eventid, phase) in events.items():
+            data = Node.void('data')
+            event_ctrl.add_child(data)
+            data.add_child(Node.s32('type', eventid))
+            data.add_child(Node.s32('phase', phase))
+
+        item_lock_ctrl = Node.void('item_lock_ctrl')
+        root.add_child(item_lock_ctrl)
+        # Contains zero or more nodes like:
+        # <item>
+        #     <type __type="u8">any</type>
+        #     <id __type="u16">any</id>
+        #     <param __type="u16">0-3</param>
+        # </item>
+
+    def handle_info_common_request(self, request: Node) -> Node:
+        root = Node.void('info')
+        self.__add_event_info(root)
+        return root
+
+    def handle_info_ranking_request(self, request: Node) -> Node:
+        version = request.child_value('ver')
+
+        root = Node.void('info')
+        root.add_child(Node.s32('ver', version))
+        ranking = Node.void('ranking')
+        root.add_child(ranking)
+
+        def add_hitchart(name: str, start: int, end: int, hitchart: List[Tuple[int, int]]) -> None:
+            base = Node.void(name)
+            ranking.add_child(base)
+            base.add_child(Node.s32('bt', start))
+            base.add_child(Node.s32('et', end))
+            new = Node.void('new')
+            base.add_child(new)
+
+            for (mid, plays) in hitchart:
+                d = Node.void('d')
+                new.add_child(d)
+                d.add_child(Node.s16('mid', mid))
+                d.add_child(Node.s32('cnt', plays))
+
+        # Weekly hit chart
+        add_hitchart(
+            'weekly',
+            Time.now() - Time.SECONDS_IN_WEEK,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 7),
+        )
+
+        # Monthly hit chart
+        add_hitchart(
+            'monthly',
+            Time.now() - Time.SECONDS_IN_DAY * 30,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 30),
+        )
+
+        # All time hit chart
+        add_hitchart(
+            'total',
+            Time.now() - Time.SECONDS_IN_DAY * 365,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 365),
+        )
+
+        return root
+
+    def handle_info_pzlcmt_read_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        teamid = request.child_value('tid')
+        limit = request.child_value('limit')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        comments = [
+            achievement for achievement in
+            self.data.local.user.get_all_time_based_achievements(self.game, self.version)
+            if achievement[1].type == 'puzzle_comment'
+        ]
+        comments.sort(key=lambda x: x[1].timestamp, reverse=True)
+        favorites = [
+            comment for comment in comments
+            if comment[0] == userid
+        ]
+        teamcomments = [
+            comment for comment in comments
+            if comment[1].data.get_int('teamid') == teamid
+        ]
+
+        # Cap all comment blocks to the limit
+        if limit >= 0:
+            comments = comments[:limit]
+            favorites = favorites[:limit]
+            teamcomments = teamcomments[:limit]
+
+        root = Node.void('info')
+        comment = Node.void('comment')
+        root.add_child(comment)
+        comment.add_child(Node.s32('time', Time.now()))
+
+        # Mapping of profiles to userIDs
+        uid_mapping = {
+            uid: prof for (uid, prof) in self.get_any_profiles([c[0] for c in comments])
+        }
+
+        # Handle anonymous comments by returning a default profile
+        uid_mapping[UserID(0)] = ValidatedDict({'name': 'ＰＬＡＹＥＲ', 'extid': 0})
+
+        def add_comments(name: str, selected: List[Tuple[UserID, Achievement]]) -> None:
+            for (uid, ach) in selected:
+                cmnt = Node.void(name)
+                root.add_child(cmnt)
+                cmnt.add_child(Node.s32('uid', uid_mapping[uid].get_int('extid')))
+                cmnt.add_child(Node.string('name', uid_mapping[uid].get_str('name')))
+                cmnt.add_child(Node.s16('icon', ach.data.get_int('icon')))
+                cmnt.add_child(Node.s8('bln', ach.data.get_int('bln')))
+                cmnt.add_child(Node.s32('tid', ach.data.get_int('teamid')))
+                cmnt.add_child(Node.string('t_name', ach.data.get_str('teamname')))
+                cmnt.add_child(Node.s8('pref', ach.data.get_int('prefecture')))
+                cmnt.add_child(Node.s32('time', ach.timestamp))
+                cmnt.add_child(Node.string('comment', ach.data.get_str('comment')))
+                cmnt.add_child(Node.bool('is_tweet', ach.data.get_bool('tweet')))
+
+        # Add all comments
+        add_comments('c', comments)
+
+        # Add personal comments (favorites)
+        add_comments('cf', favorites)
+
+        # Add team comments
+        add_comments('ct', teamcomments)
+
+        return root
+
+    def handle_info_pzlcmt_write_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            # Anonymous comment
+            userid = UserID(0)
+
+        icon = request.child_value('icon')
+        bln = request.child_value('bln')
+        teamid = request.child_value('tid')
+        teamname = request.child_value('t_name')
+        prefecture = request.child_value('pref')
+        comment = request.child_value('comment')
+        is_tweet = request.child_value('is_tweet')
+
+        # Link comment to user's profile
+        self.data.local.user.put_time_based_achievement(
+            self.game,
+            self.version,
+            userid,
+            0,  # We never have an ID for this, since comments are add-only
+            'puzzle_comment',
+            {
+                'icon': icon,
+                'bln': bln,
+                'teamid': teamid,
+                'teamname': teamname,
+                'prefecture': prefecture,
+                'comment': comment,
+                'tweet': is_tweet,
+            },
+        )
+
+        return Node.void('info')
+
+    def handle_jbrbcollabo_save_request(self, request: Node) -> Node:
+        jbrbcollabo = Node.void('jbrbcollabo')
+        jbrbcollabo.add_child(Node.u16('marathontype', 0))
+        jbrbcollabo.add_child(Node.u32('smith_start', 0))
+        jbrbcollabo.add_child(Node.u32('pastel_start', 0))
+        jbrbcollabo.add_child(Node.u32('smith_run', 0))
+        jbrbcollabo.add_child(Node.u32('pastel_run', 0))
+        jbrbcollabo.add_child(Node.u16('smith_ouen', 0))
+        jbrbcollabo.add_child(Node.u16('pastel_ouen', 0))
+        jbrbcollabo.add_child(Node.u32('smith_water_run', 0))
+        jbrbcollabo.add_child(Node.u32('pastel_water_run', 0))
+        jbrbcollabo.add_child(Node.bool('getwater', False))
+        jbrbcollabo.add_child(Node.bool('smith_goal', False))
+        jbrbcollabo.add_child(Node.bool('pastel_goal', False))
+        jbrbcollabo.add_child(Node.u16('distancetype', 0))
+        jbrbcollabo.add_child(Node.bool('run1_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_2_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_3_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_2_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_3_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_2_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_3_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_2_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_3_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_2_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_3_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_2_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_3_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_2_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_2_flg', False))
+        jbrbcollabo.add_child(Node.bool('start_flg', False))
+        return jbrbcollabo
+
+    def handle_lobby_entry_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Create a lobby entry for this user
+        extid = request.child_value('e/uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            self.data.local.lobby.put_lobby(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'mid': request.child_value('e/mid'),
+                    'ng': request.child_value('e/ng'),
+                    'mopt': request.child_value('e/mopt'),
+                    'tid': request.child_value('e/tid'),
+                    'tn': request.child_value('e/tn'),
+                    'topt': request.child_value('e/topt'),
+                    'lid': request.child_value('e/lid'),
+                    'sn': request.child_value('e/sn'),
+                    'pref': request.child_value('e/pref'),
+                    'stg': request.child_value('e/stg'),
+                    'pside': request.child_value('e/pside'),
+                    'eatime': request.child_value('e/eatime'),
+                    'ga': request.child_value('e/ga'),
+                    'gp': request.child_value('e/gp'),
+                    'la': request.child_value('e/la'),
+                    'ver': request.child_value('e/ver'),
+                }
+            )
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            root.add_child(Node.s32('eid', lobby.get_int('id')))
+            e = Node.void('e')
+            root.add_child(e)
+            e.add_child(Node.s32('eid', lobby.get_int('id')))
+            e.add_child(Node.u16('mid', lobby.get_int('mid')))
+            e.add_child(Node.u8('ng', lobby.get_int('ng')))
+            e.add_child(Node.s32('uid', profile.get_int('extid')))
+            e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+            e.add_child(Node.string('pn', profile.get_str('name')))
+            e.add_child(Node.s16('mg', profile.get_int('mg')))
+            e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+            e.add_child(Node.s32('tid', lobby.get_int('tid')))
+            e.add_child(Node.string('tn', lobby.get_str('tn')))
+            e.add_child(Node.s32('topt', lobby.get_int('topt')))
+            e.add_child(Node.string('lid', lobby.get_str('lid')))
+            e.add_child(Node.string('sn', lobby.get_str('sn')))
+            e.add_child(Node.u8('pref', lobby.get_int('pref')))
+            e.add_child(Node.s8('stg', lobby.get_int('stg')))
+            e.add_child(Node.s8('pside', lobby.get_int('pside')))
+            e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+            e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+            e.add_child(Node.u16('gp', lobby.get_int('gp')))
+            e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+            e.add_child(Node.u8('ver', lobby.get_int('ver')))
+
+        return root
+
+    def handle_lobby_read_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Look up all lobbies matching the criteria specified
+        ver = request.child_value('var')
+        mg = request.child_value('m_grade')  # noqa: F841
+        extid = request.child_value('uid')
+        limit = request.child_value('max')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
+            for (user, lobby) in lobbies:
+                if limit <= 0:
+                    break
+
+                if user == userid:
+                    # If we have our own lobby, don't return it
+                    continue
+                if ver != lobby.get_int('ver'):
+                    # Don't return lobby data for different versions
+                    continue
+
+                profile = self.get_profile(user)
+                if profile is None:
+                    # No profile info, don't return this lobby
+                    continue
+
+                e = Node.void('e')
+                root.add_child(e)
+                e.add_child(Node.s32('eid', lobby.get_int('id')))
+                e.add_child(Node.u16('mid', lobby.get_int('mid')))
+                e.add_child(Node.u8('ng', lobby.get_int('ng')))
+                e.add_child(Node.s32('uid', profile.get_int('extid')))
+                e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+                e.add_child(Node.string('pn', profile.get_str('name')))
+                e.add_child(Node.s16('mg', profile.get_int('mg')))
+                e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+                e.add_child(Node.s32('tid', lobby.get_int('tid')))
+                e.add_child(Node.string('tn', lobby.get_str('tn')))
+                e.add_child(Node.s32('topt', lobby.get_int('topt')))
+                e.add_child(Node.string('lid', lobby.get_str('lid')))
+                e.add_child(Node.string('sn', lobby.get_str('sn')))
+                e.add_child(Node.u8('pref', lobby.get_int('pref')))
+                e.add_child(Node.s8('stg', lobby.get_int('stg')))
+                e.add_child(Node.s8('pside', lobby.get_int('pside')))
+                e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+                e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+                e.add_child(Node.u16('gp', lobby.get_int('gp')))
+                e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+                e.add_child(Node.u8('ver', lobby.get_int('ver')))
+
+                limit = limit - 1
+
+        return root
+
+    def handle_lobby_delete_request(self, request: Node) -> Node:
+        eid = request.child_value('eid')
+        self.data.local.lobby.destroy_lobby(eid)
+        return Node.void('lobby')
+
+    def handle_player_start_request(self, request: Node) -> Node:
+        root = Node.void('player')
+
+        # Create a new play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            self.data.local.lobby.put_play_session_info(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'ga': request.child_value('ga'),
+                    'gp': request.child_value('gp'),
+                    'la': request.child_value('la'),
+                },
+            )
+            info = self.data.local.lobby.get_play_session_info(
+                self.game,
+                self.version,
+                userid,
+            )
+            if info is not None:
+                play_id = info.get_int('id')
+            else:
+                play_id = 0
+        else:
+            play_id = 0
+
+        # Session stuff, and resend global defaults
+        root.add_child(Node.s32('plyid', play_id))
+        root.add_child(Node.u64('start_time', Time.now() * 1000))
+        self.__add_event_info(root)
+
+        # Event settings and such
+        lincle_link_4 = Node.void('lincle_link_4')
+        root.add_child(lincle_link_4)
+        lincle_link_4.add_child(Node.u32('qpro', 0))
+        lincle_link_4.add_child(Node.u32('glass', 0))
+        lincle_link_4.add_child(Node.u32('treasure', 0))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_0', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_1', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_2', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_3', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_4', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_5', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_6', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_1', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_2', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_3', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_4', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_0', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_1', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_2', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_3', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_4', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_5', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_6', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0', False))
+        lincle_link_4.add_child(Node.bool('for_rb_1', False))
+        lincle_link_4.add_child(Node.bool('for_rb_2', False))
+        lincle_link_4.add_child(Node.bool('for_rb_3', False))
+        lincle_link_4.add_child(Node.bool('for_rb_4', False))
+        lincle_link_4.add_child(Node.bool('qproflg', False))
+        lincle_link_4.add_child(Node.bool('glassflg', False))
+        lincle_link_4.add_child(Node.bool('complete', False))
+
+        jbrbcollabo = Node.void('jbrbcollabo')
+        root.add_child(jbrbcollabo)
+        jbrbcollabo.add_child(Node.bool('run1_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_2_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_3_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_2_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_3_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run1_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_2_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_3_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_2_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_3_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run2_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_2_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_3_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_4_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_2_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_3_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run3_4_flg', False))
+        jbrbcollabo.add_child(Node.u16('marathontype', 0))
+        jbrbcollabo.add_child(Node.u32('smith_start', 0))
+        jbrbcollabo.add_child(Node.u32('pastel_start', 0))
+        jbrbcollabo.add_child(Node.u16('smith_ouen', 0))
+        jbrbcollabo.add_child(Node.u16('pastel_ouen', 0))
+        jbrbcollabo.add_child(Node.u16('distancetype', 0))
+        jbrbcollabo.add_child(Node.bool('smith_goal', False))
+        jbrbcollabo.add_child(Node.bool('pastel_goal', False))
+        jbrbcollabo.add_child(Node.bool('run4_1_j_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_1_r_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_2_flg', False))
+        jbrbcollabo.add_child(Node.bool('run4_2_flg', False))
+        jbrbcollabo.add_child(Node.bool('start_flg', False))
+
+        tricolettepark = Node.void('tricolettepark')
+        root.add_child(tricolettepark)
+        tricolettepark.add_child(Node.s32('open_music', -1))
+        tricolettepark.add_child(Node.s32('boss0_damage', -1))
+        tricolettepark.add_child(Node.s32('boss1_damage', -1))
+        tricolettepark.add_child(Node.s32('boss2_damage', -1))
+        tricolettepark.add_child(Node.s32('boss3_damage', -1))
+        tricolettepark.add_child(Node.s32('boss0_stun', -1))
+        tricolettepark.add_child(Node.s32('boss1_stun', -1))
+        tricolettepark.add_child(Node.s32('boss2_stun', -1))
+        tricolettepark.add_child(Node.s32('boss3_stun', -1))
+        tricolettepark.add_child(Node.s32('magic_gauge', -1))
+        tricolettepark.add_child(Node.s32('today_party', -1))
+        tricolettepark.add_child(Node.bool('union_magic', False))
+        tricolettepark.add_child(Node.bool('is_complete', False))
+        tricolettepark.add_child(Node.float('base_attack_rate', 1.0))
+
+        return root
+
+    def handle_player_delete_request(self, request: Node) -> Node:
+        return Node.void('player')
+
+    def handle_player_end_request(self, request: Node) -> Node:
+        # Destroy play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            # Kill any lingering lobbies by this user
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            if lobby is not None:
+                self.data.local.lobby.destroy_lobby(lobby.get_int('id'))
+            self.data.local.lobby.destroy_play_session_info(self.game, self.version, userid)
+
+        return Node.void('player')
+
+    def handle_player_succeed_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            previous_version = self.previous_version()
+            profile = previous_version.get_profile(userid)
+            achievements = self.data.local.user.get_achievements(previous_version.game, previous_version.version, userid)
+            scores = self.data.remote.music.get_scores(previous_version.game, previous_version.version, userid)
+        else:
+            profile = None
+
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.string('name', ''))
+            root.add_child(Node.s16('lv', -1))
+            root.add_child(Node.s32('exp', -1))
+            root.add_child(Node.s32('grd', -1))
+            root.add_child(Node.s32('ap', -1))
+
+            root.add_child(Node.void('released'))
+            root.add_child(Node.void('mrecord'))
+        else:
+            root.add_child(Node.string('name', profile.get_str('name')))
+            root.add_child(Node.s16('lv', profile.get_int('lvl')))
+            root.add_child(Node.s32('exp', profile.get_int('exp')))
+            root.add_child(Node.s32('grd', profile.get_int('mg')))  # This is a guess
+            root.add_child(Node.s32('ap', profile.get_int('ap')))
+
+            released = Node.void('released')
+            root.add_child(released)
+            for item in achievements:
+                if item.type != 'item_0':
+                    continue
+
+                released.add_child(Node.s16('i', item.id))
+
+            mrecord = Node.void('mrecord')
+            root.add_child(mrecord)
+            for score in scores:
+                mrec = Node.void('mrec')
+                mrecord.add_child(mrec)
+                mrec.add_child(Node.s16('mid', score.id))
+                mrec.add_child(Node.s8('ntgrd', score.chart))
+                mrec.add_child(Node.s32('pc', score.plays))
+                mrec.add_child(Node.s8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'), score.data.get_int('combo_type'))))
+                mrec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
+                mrec.add_child(Node.s16('scr', score.points))
+                mrec.add_child(Node.s16('cmb', score.data.get_int('combo')))
+                mrec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
+                mrec.add_child(Node.u16('ver', 0))
+
+        return root
+
+    def handle_player_read_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.get_profile_by_refid(refid)
+        if profile:
+            return profile
+        return Node.void('player')
+
+    def handle_player_write_request(self, request: Node) -> Node:
+        refid = request.child_value('pdata/account/rid')
+        profile = self.put_profile_by_refid(refid, request)
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.s32('uid', 0))
+        else:
+            root.add_child(Node.s32('uid', profile.get_int('extid')))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        statistics = self.get_play_statistics(userid)
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        # Account time info
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', profile.get_int('extid')))
+        account.add_child(Node.s32('tpc', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s32('dpc', today_count))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s32('intrvld', 0))
+        account.add_child(Node.s16('ver', 5))
+        account.add_child(Node.u64('pst', 0))
+        account.add_child(Node.u64('st', Time.now() * 1000))
+
+        # Base account info
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', profile.get_str('name')))
+        base.add_child(Node.s32('exp', profile.get_int('exp')))
+        base.add_child(Node.s32('lv', profile.get_int('lvl')))
+        base.add_child(Node.s32('mg', profile.get_int('mg')))
+        base.add_child(Node.s32('ap', profile.get_int('ap')))
+        base.add_child(Node.s32('tid', profile.get_int('team_id', -1)))
+        base.add_child(Node.string('tname', profile.get_str('team_name', '')))
+        base.add_child(Node.string('cmnt', ''))
+        base.add_child(Node.s32('uattr', profile.get_int('uattr')))
+        base.add_child(Node.s32_array('hidden_param', profile.get_int_array('hidden_param', 50)))
+        base.add_child(Node.s32('tbs', -1))
+        base.add_child(Node.s32('tbs_r', -1))
+
+        # Rivals
+        rival = Node.void('rival')
+        pdata.add_child(rival)
+        slotid = 0
+        for link in links:
+            if link.type != 'rival':
+                continue
+
+            rprofile = self.get_profile(link.other_userid)
+            if rprofile is None:
+                continue
+
+            r = Node.void('r')
+            rival.add_child(r)
+            r.add_child(Node.s32('slot_id', slotid))
+            r.add_child(Node.s32('id', rprofile.get_int('extid')))
+            r.add_child(Node.string('name', rprofile.get_str('name')))
+            r.add_child(Node.bool('friend', True))
+            r.add_child(Node.bool('locked', False))
+            r.add_child(Node.s32('rc', 0))
+            slotid = slotid + 1
+
+        # Player customizations
+        custom = Node.void('custom')
+        customdict = profile.get_dict('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('st_shot', customdict.get_int('st_shot')))
+        custom.add_child(Node.u8('st_frame', customdict.get_int('st_frame')))
+        custom.add_child(Node.u8('st_expl', customdict.get_int('st_expl')))
+        custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
+        custom.add_child(Node.u8('st_shot_vol', customdict.get_int('st_shot_vol')))
+        custom.add_child(Node.u8('st_bg_bri', customdict.get_int('st_bg_bri')))
+        custom.add_child(Node.u8('st_obj_size', customdict.get_int('st_obj_size')))
+        custom.add_child(Node.u8('st_jr_gauge', customdict.get_int('st_jr_gauge')))
+        custom.add_child(Node.u8('st_clr_gauge', customdict.get_int('st_clr_gauge')))
+        custom.add_child(Node.u8('st_jdg_disp', customdict.get_int('st_jdg_disp')))
+        custom.add_child(Node.u8('st_tm_disp', customdict.get_int('st_tm_disp')))
+        custom.add_child(Node.u8('st_rnd', customdict.get_int('st_rnd')))
+        custom.add_child(Node.s16_array('schat_0', customdict.get_int_array('schat_0', 9)))
+        custom.add_child(Node.s16_array('schat_1', customdict.get_int_array('schat_1', 9)))
+        custom.add_child(Node.s16_array('ichat_0', customdict.get_int_array('ichat_0', 6)))
+        custom.add_child(Node.s16_array('ichat_1', customdict.get_int_array('ichat_1', 6)))
+
+        # Player external config
+        config = Node.void('config')
+        configdict = profile.get_dict('config')
+        pdata.add_child(config)
+        config.add_child(Node.u8('msel_bgm', configdict.get_int('msel_bgm')))
+        config.add_child(Node.u8('narrowdown_type', configdict.get_int('narrowdown_type')))
+        config.add_child(Node.s16('icon_id', configdict.get_int('icon_id')))
+        config.add_child(Node.s16('byword_0', configdict.get_int('byword_0')))
+        config.add_child(Node.s16('byword_1', configdict.get_int('byword_1')))
+        config.add_child(Node.bool('is_auto_byword_0', configdict.get_bool('is_auto_byword_0')))
+        config.add_child(Node.bool('is_auto_byword_1', configdict.get_bool('is_auto_byword_1')))
+        config.add_child(Node.u8('mrec_type', configdict.get_int('mrec_type')))
+        config.add_child(Node.u8('tab_sel', configdict.get_int('tab_sel')))
+        config.add_child(Node.u8('card_disp', configdict.get_int('card_disp')))
+        config.add_child(Node.u8('score_tab_disp', configdict.get_int('score_tab_disp')))
+        config.add_child(Node.s16('last_music_id', configdict.get_int('last_music_id', -1)))
+        config.add_child(Node.u8('last_note_grade', configdict.get_int('last_note_grade')))
+        config.add_child(Node.u8('sort_type', configdict.get_int('sort_type')))
+        config.add_child(Node.u8('rival_panel_type', configdict.get_int('rival_panel_type')))
+        config.add_child(Node.u64('random_entry_work', configdict.get_int('random_entry_work')))
+        config.add_child(Node.u8('folder_lamp_type', configdict.get_int('folder_lamp_type')))
+        config.add_child(Node.bool('is_tweet', configdict.get_bool('is_tweet')))
+        config.add_child(Node.bool('is_link_twitter', configdict.get_bool('is_link_twitter')))
+
+        # Stamps
+        stamp = Node.void('stamp')
+        stampdict = profile.get_dict('stamp')
+        pdata.add_child(stamp)
+        stamp.add_child(Node.s32_array('stmpcnt', stampdict.get_int_array('stmpcnt', 5)))
+        stamp.add_child(Node.s32_array('tcktcnt', stampdict.get_int_array('tcktcnt', 5)))
+        stamp.add_child(Node.s64('area', stampdict.get_int('area')))
+        stamp.add_child(Node.s64('prfvst', stampdict.get_int('prfvst')))
+        stamp.add_child(Node.s32('reserve', stampdict.get_int('reserve')))
+
+        # Unlocks
+        released = Node.void('released')
+        pdata.add_child(released)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+            if game_config.get_bool('force_unlock_songs') and itemtype == 0:
+                # Don't echo unlocks when we're force unlocking, we'll do it later
+                continue
+
+            info = Node.void('info')
+            released.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u16('id', item.id))
+            info.add_child(Node.u16('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for songid in ids:
+                if ids[songid] == 0:
+                    continue
+
+                info = Node.void('info')
+                released.add_child(info)
+                info.add_child(Node.u8('type', 0))
+                info.add_child(Node.u16('id', songid))
+                info.add_child(Node.u16('param', ids[songid]))
+
+        # Favorite songs
+        fav_music_slot = Node.void('fav_music_slot')
+        pdata.add_child(fav_music_slot)
+
+        for item in achievements:
+            if item.type != 'music':
+                continue
+
+            slot = Node.void('slot')
+            fav_music_slot.add_child(slot)
+            slot.add_child(Node.u8('slot_id', item.id))
+            slot.add_child(Node.s16('music_id', item.data.get_int('music_id')))
+
+        # Event stuff
+        order = Node.void('order')
+        pdata.add_child(order)
+        order.add_child(Node.s32('exp', profile.get_int('order_exp')))
+        for item in achievements:
+            if item.type != 'order':
+                continue
+
+            data = Node.void('d')
+            order.add_child(data)
+            data.add_child(Node.s16('order', item.id))
+            data.add_child(Node.s16('slt', item.data.get_int('slt')))
+            data.add_child(Node.s32('ccnt', item.data.get_int('ccnt')))
+            data.add_child(Node.s32('fcnt', item.data.get_int('fcnt')))
+            data.add_child(Node.s32('fcnt1', item.data.get_int('fcnt1')))
+            data.add_child(Node.s32('prm', item.data.get_int('param')))
+
+        seedpod = Node.void('seedpod')
+        pdata.add_child(seedpod)
+        for item in achievements:
+            if item.type != 'seedpod':
+                continue
+
+            data = Node.void('data')
+            seedpod.add_child(data)
+            data.add_child(Node.s16('id', item.id))
+            data.add_child(Node.s16('pod', item.data.get_int('pod')))
+
+        eqpexp = Node.void('eqpexp')
+        pdata.add_child(eqpexp)
+        for item in achievements:
+            if item.type[:7] != 'eqpexp_':
+                continue
+            stype = int(item.type[7:])
+
+            data = Node.void('data')
+            eqpexp.add_child(data)
+            data.add_child(Node.s16('id', item.id))
+            data.add_child(Node.s32('exp', item.data.get_int('exp')))
+            data.add_child(Node.s16('stype', stype))
+
+        eventexp = Node.void('evntexp')
+        pdata.add_child(eventexp)
+        for item in achievements:
+            if item.type != 'eventexp':
+                continue
+
+            data = Node.void('data')
+            eventexp.add_child(data)
+            data.add_child(Node.s16('id', item.id))
+            data.add_child(Node.s32('exp', item.data.get_int('exp')))
+
+        # Scores
+        record = Node.void('record')
+        pdata.add_child(record)
+        record_old = Node.void('record_old')
+        pdata.add_child(record_old)
+
+        for score in scores:
+            rec = Node.void('rec')
+            record.add_child(rec)
+            rec.add_child(Node.s16('mid', score.id))
+            rec.add_child(Node.s8('ntgrd', score.chart))
+            rec.add_child(Node.s32('pc', score.plays))
+            rec.add_child(Node.s8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'), score.data.get_int('combo_type'))))
+            rec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
+            rec.add_child(Node.s16('scr', score.points))
+            rec.add_child(Node.s16('cmb', score.data.get_int('combo')))
+            rec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
+            rec.add_child(Node.s32('bscrt', score.timestamp))
+            rec.add_child(Node.s32('bart', score.data.get_int('best_achievement_rate_time')))
+            rec.add_child(Node.s32('bctt', score.data.get_int('best_clear_type_time')))
+            rec.add_child(Node.s32('bmst', score.data.get_int('best_miss_count_time')))
+            rec.add_child(Node.s32('time', score.data.get_int('last_played_time')))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        game_config = self.get_game_config()
+        newprofile = copy.deepcopy(oldprofile)
+
+        newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('pdata/account/lid')))
+        newprofile.replace_str('name', request.child_value('pdata/base/name'))
+        newprofile.replace_int('exp', request.child_value('pdata/base/exp'))
+        newprofile.replace_int('lvl', request.child_value('pdata/base/lvl'))
+        newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
+        newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
+        newprofile.replace_int_array('hidden_param', 50, request.child_value('pdata/base/hidden_param'))
+
+        configdict = newprofile.get_dict('config')
+        config = request.child('pdata/config')
+        if config:
+            configdict.replace_int('msel_bgm', config.child_value('msel_bgm'))
+            configdict.replace_int('narrowdown_type', config.child_value('narrowdown_type'))
+            configdict.replace_int('icon_id', config.child_value('icon_id'))
+            configdict.replace_int('byword_0', config.child_value('byword_0'))
+            configdict.replace_int('byword_1', config.child_value('byword_1'))
+            configdict.replace_bool('is_auto_byword_0', config.child_value('is_auto_byword_0'))
+            configdict.replace_bool('is_auto_byword_1', config.child_value('is_auto_byword_1'))
+            configdict.replace_int('mrec_type', config.child_value('mrec_type'))
+            configdict.replace_int('tab_sel', config.child_value('tab_sel'))
+            configdict.replace_int('card_disp', config.child_value('card_disp'))
+            configdict.replace_int('score_tab_disp', config.child_value('score_tab_disp'))
+            configdict.replace_int('last_music_id', config.child_value('last_music_id'))
+            configdict.replace_int('last_note_grade', config.child_value('last_note_grade'))
+            configdict.replace_int('sort_type', config.child_value('sort_type'))
+            configdict.replace_int('rival_panel_type', config.child_value('rival_panel_type'))
+            configdict.replace_int('random_entry_work', config.child_value('random_entry_work'))
+            configdict.replace_int('folder_lamp_type', config.child_value('folder_lamp_type'))
+            configdict.replace_bool('is_tweet', config.child_value('is_tweet'))
+            configdict.replace_bool('is_link_twitter', config.child_value('is_link_twitter'))
+        newprofile.replace_dict('config', configdict)
+
+        customdict = newprofile.get_dict('custom')
+        custom = request.child('pdata/custom')
+        if custom:
+            customdict.replace_int('st_shot', custom.child_value('st_shot'))
+            customdict.replace_int('st_frame', custom.child_value('st_frame'))
+            customdict.replace_int('st_expl', custom.child_value('st_expl'))
+            customdict.replace_int('st_bg', custom.child_value('st_bg'))
+            customdict.replace_int('st_shot_vol', custom.child_value('st_shot_vol'))
+            customdict.replace_int('st_bg_bri', custom.child_value('st_bg_bri'))
+            customdict.replace_int('st_obj_size', custom.child_value('st_obj_size'))
+            customdict.replace_int('st_jr_gauge', custom.child_value('st_jr_gauge'))
+            customdict.replace_int('st_clr_gauge', custom.child_value('st_clr_gauge'))
+            customdict.replace_int('st_jdg_disp', custom.child_value('st_jdg_disp'))
+            customdict.replace_int('st_tm_disp', custom.child_value('st_tm_disp'))
+            customdict.replace_int('st_rnd', custom.child_value('st_rnd'))
+            customdict.replace_int_array('schat_0', 9, custom.child_value('schat_0'))
+            customdict.replace_int_array('schat_1', 9, custom.child_value('schat_1'))
+            customdict.replace_int_array('ichat_0', 6, custom.child_value('ichat_0'))
+            customdict.replace_int_array('ichat_1', 6, custom.child_value('ichat_1'))
+        newprofile.replace_dict('custom', customdict)
+
+        # Stamps
+        stampdict = newprofile.get_dict('stamp')
+        stamp = request.child('pdata/stamp')
+        if stamp:
+            stampdict.replace_int_array('stmpcnt', 5, stamp.child_value('stmpcnt'))
+            stampdict.replace_int_array('tcktcnt', 5, stamp.child_value('tcktcnt'))
+            stampdict.replace_int('area', stamp.child_value('area'))
+            stampdict.replace_int('prfvst', stamp.child_value('prfvst'))
+            stampdict.replace_int('reserve', stamp.child_value('reserve'))
+        newprofile.replace_dict('stamp', stampdict)
+
+        # Unlockable orders
+        newprofile.replace_int('order_exp', request.child_value('pdata/order/exp'))
+        order = request.child('pdata/order')
+        if order:
+            for child in order.children:
+                if child.name != 'd':
+                    continue
+
+                orderid = child.child_value('order')
+                slt = child.child_value('slt')
+                ccnt = child.child_value('ccnt')
+                fcnt = child.child_value('fcnt')
+                fcnt1 = child.child_value('fcnt1')
+                param = child.child_value('prm')
+
+                if slt == -1:
+                    # The game doesn't return valid data for this selection
+                    # type, so be sure not to accidentally overwrite the
+                    # finished flags.
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    orderid,
+                    'order',
+                    {
+                        'slt': slt,
+                        'ccnt': ccnt,
+                        'fcnt': fcnt,
+                        'fcnt1': fcnt1,
+                        'param': param,
+                    },
+                )
+
+        # Music unlocks and other stuff
+        released = request.child('pdata/released')
+        if released:
+            for child in released.children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                if game_config.get_bool('force_unlock_songs') and item_type == 0:
+                    # Don't save unlocks when we're force unlocking
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Favorite music
+        fav_music_slot = request.child('pdata/fav_music_slot')
+        if fav_music_slot:
+            for child in fav_music_slot.children:
+                if child.name != 'slot':
+                    continue
+
+                slot_id = child.child_value('slot_id')
+                music_id = child.child_value('music_id')
+                if music_id == -1:
+                    # Delete this favorite
+                    self.data.local.user.destroy_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        slot_id,
+                        'music',
+                    )
+                else:
+                    # Add/update this favorite
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        slot_id,
+                        'music',
+                        {
+                            'music_id': music_id,
+                        },
+                    )
+
+        # Event stuff
+        seedpod = request.child('pdata/seedpod')
+        if seedpod:
+            for child in seedpod.children:
+                if child.name != 'data':
+                    continue
+
+                seedpod_id = child.child_value('id')
+                seedpod_pod = child.child_value('pod')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    seedpod_id,
+                    'seedpod',
+                    {
+                        'pod': seedpod_pod,
+                    },
+                )
+
+        eventexp = request.child('pdata/evntexp')
+        if eventexp:
+            for child in eventexp.children:
+                if child.name != 'data':
+                    continue
+
+                eventexp_id = child.child_value('id')
+                eventexp_exp = child.child_value('exp')
+
+                # Experience is additive, so load it first and add the updated amount
+                data = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventexp_id,
+                    'eventexp',
+                ) or ValidatedDict()
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eventexp_id,
+                    'eventexp',
+                    {
+                        'exp': data.get_int('exp') + eventexp_exp,
+                    },
+                )
+
+        eqpexp = request.child('pdata/eqpexp')
+        if eqpexp:
+            for child in eqpexp.children:
+                if child.name != 'data':
+                    continue
+
+                eqpexp_id = child.child_value('id')
+                eqpexp_exp = child.child_value('exp')
+                eqpexp_stype = child.child_value('stype')
+
+                # Experience is additive, so load it first and add the updated amount
+                data = self.data.local.user.get_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eqpexp_id,
+                    'eqpexp_{}'.format(eqpexp_stype),
+                ) or ValidatedDict()
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    eqpexp_id,
+                    'eqpexp_{}'.format(eqpexp_stype),
+                    {
+                        'exp': data.get_int('exp') + eqpexp_exp,
+                    },
+                )
+
+        # Grab any new records set during this play session
+        songplays = request.child('pdata/stglog')
+        if songplays:
+            for child in songplays.children:
+                if child.name != 'log':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+                clear_type = child.child_value('ct')
+                if songid == 0 and chart == 0 and clear_type == -1:
+                    # Dummy song save during profile create
+                    continue
+
+                points = child.child_value('sc')
+                achievement_rate = child.child_value('ar')
+                clear_type, combo_type = self.__game_to_db_clear_type(clear_type)
+                combo = child.child_value('cmb')
+                miss_count = child.child_value('jt_ms')
+                self.update_score(
+                    userid,
+                    songid,
+                    chart,
+                    points,
+                    achievement_rate,
+                    clear_type,
+                    combo_type,
+                    miss_count,
+                    combo=combo,
+                )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/factory.py b/bemani/backend/reflec/factory.py
new file mode 100644
index 0000000..6fdf9c4
--- /dev/null
+++ b/bemani/backend/reflec/factory.py
@@ -0,0 +1,81 @@
+from typing import Any, Dict, List, Optional, Type
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.reflec.reflecbeat import ReflecBeat
+from bemani.backend.reflec.limelight import ReflecBeatLimelight
+from bemani.backend.reflec.colette import ReflecBeatColette
+from bemani.backend.reflec.groovin import ReflecBeatGroovin
+from bemani.backend.reflec.volzza import ReflecBeatVolzza
+from bemani.backend.reflec.volzza2 import ReflecBeatVolzza2
+from bemani.common import Model, VersionConstants
+from bemani.data import Data
+
+
+class ReflecBeatFactory(Factory):
+
+    MANAGED_CLASSES: List[Type[Base]] = [
+        ReflecBeat,
+        ReflecBeatLimelight,
+        ReflecBeatColette,
+        ReflecBeatGroovin,
+        ReflecBeatVolzza,
+        ReflecBeatVolzza2,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['KBR', 'LBR', 'MBR']:
+            Base.register(game, ReflecBeatFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        def version_from_date(date: int) -> Optional[int]:
+            if date < 2014060400:
+                return VersionConstants.REFLEC_BEAT_COLETTE
+            if date >= 2014060400 and date < 2015102800:
+                return VersionConstants.REFLEC_BEAT_GROOVIN
+            if date >= 2015102800 and date < 2016032400:
+                return VersionConstants.REFLEC_BEAT_VOLZZA
+            if date >= 2016032400 and date < 2016120100:
+                return VersionConstants.REFLEC_BEAT_VOLZZA_2
+            if date >= 2016120100:
+                return VersionConstants.REFLEC_BEAT_REFLESIA
+            return None
+
+        if model.game == 'KBR':
+            return ReflecBeat(data, config, model)
+        if model.game == 'LBR':
+            return ReflecBeatLimelight(data, config, model)
+        if model.game == 'MBR':
+            if model.version is None:
+                if parentmodel is None:
+                    return None
+
+                if parentmodel.game not in ['KBR', 'LBR', 'MBR']:
+                    return None
+                parentversion = version_from_date(parentmodel.version)
+                if parentversion == VersionConstants.REFLEC_BEAT_COLETTE:
+                    return ReflecBeatLimelight(data, config, model)
+                if parentversion == VersionConstants.REFLEC_BEAT_GROOVIN:
+                    return ReflecBeatColette(data, config, model)
+                if parentversion == VersionConstants.REFLEC_BEAT_VOLZZA:
+                    return ReflecBeatGroovin(data, config, model)
+                if parentversion == VersionConstants.REFLEC_BEAT_VOLZZA_2:
+                    return ReflecBeatVolzza(data, config, model)
+
+                # Unknown older version
+                return None
+
+            version = version_from_date(model.version)
+            if version == VersionConstants.REFLEC_BEAT_COLETTE:
+                return ReflecBeatColette(data, config, model)
+            if version == VersionConstants.REFLEC_BEAT_GROOVIN:
+                return ReflecBeatGroovin(data, config, model)
+            if version == VersionConstants.REFLEC_BEAT_VOLZZA:
+                return ReflecBeatVolzza(data, config, model)
+            if version == VersionConstants.REFLEC_BEAT_VOLZZA_2:
+                return ReflecBeatVolzza2(data, config, model)
+
+        # Unknown game version
+        return None
diff --git a/bemani/backend/reflec/groovin.py b/bemani/backend/reflec/groovin.py
new file mode 100644
index 0000000..3af469a
--- /dev/null
+++ b/bemani/backend/reflec/groovin.py
@@ -0,0 +1,1509 @@
+import copy
+from typing import Optional, Dict, Any, List, Tuple
+
+from bemani.backend.reflec.base import ReflecBeatBase
+from bemani.backend.reflec.colette import ReflecBeatColette
+
+from bemani.common import ValidatedDict, VersionConstants, ID, Time
+from bemani.data import Achievement, Attempt, Score, UserID
+from bemani.protocol import Node
+
+
+class ReflecBeatGroovin(ReflecBeatBase):
+
+    name = "REFLEC BEAT groovin'!!"
+    version = VersionConstants.REFLEC_BEAT_GROOVIN
+
+    # Clear types according to the game
+    GAME_CLEAR_TYPE_NO_PLAY = 0
+    GAME_CLEAR_TYPE_EARLY_FAILED = 1
+    GAME_CLEAR_TYPE_FAILED = 2
+    GAME_CLEAR_TYPE_CLEARED = 9
+    GAME_CLEAR_TYPE_HARD_CLEARED = 10
+    GAME_CLEAR_TYPE_S_HARD_CLEARED = 11
+
+    # Combo types according to the game (actually a bitmask, where bit 0 is
+    # full combo status, and bit 2 is just reflec status). But we don't support
+    # saving just reflec without full combo, so we downgrade it.
+    GAME_COMBO_TYPE_NONE = 0
+    GAME_COMBO_TYPE_ALL_JUST = 2
+    GAME_COMBO_TYPE_FULL_COMBO = 1
+    GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST = 3
+
+    def previous_version(self) -> Optional[ReflecBeatBase]:
+        return ReflecBeatColette(self.data, self.config, self.model)
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+            'ints': [],
+        }
+
+    def __db_to_game_clear_type(self, db_status: int) -> int:
+        return {
+            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_PLAY,
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEARED: self.GAME_CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_HARD_CLEARED: self.GAME_CLEAR_TYPE_HARD_CLEARED,
+            self.CLEAR_TYPE_S_HARD_CLEARED: self.GAME_CLEAR_TYPE_S_HARD_CLEARED,
+        }[db_status]
+
+    def __game_to_db_clear_type(self, status: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_NO_PLAY: self.CLEAR_TYPE_NO_PLAY,
+            self.GAME_CLEAR_TYPE_EARLY_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEARED: self.CLEAR_TYPE_CLEARED,
+            self.GAME_CLEAR_TYPE_HARD_CLEARED: self.CLEAR_TYPE_HARD_CLEARED,
+            self.GAME_CLEAR_TYPE_S_HARD_CLEARED: self.CLEAR_TYPE_S_HARD_CLEARED,
+        }[status]
+
+    def __db_to_game_combo_type(self, db_combo: int) -> int:
+        return {
+            self.COMBO_TYPE_NONE: self.GAME_COMBO_TYPE_NONE,
+            self.COMBO_TYPE_ALMOST_COMBO: self.GAME_COMBO_TYPE_NONE,
+            self.COMBO_TYPE_FULL_COMBO: self.GAME_COMBO_TYPE_FULL_COMBO,
+            self.COMBO_TYPE_FULL_COMBO_ALL_JUST: self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST,
+        }[db_combo]
+
+    def __game_to_db_combo_type(self, game_combo: int, miss_count: int) -> int:
+        if game_combo in [
+            self.GAME_COMBO_TYPE_NONE,
+            self.GAME_COMBO_TYPE_ALL_JUST,
+        ]:
+            if miss_count >= 0 and miss_count <= 2:
+                return self.COMBO_TYPE_ALMOST_COMBO
+            else:
+                return self.COMBO_TYPE_NONE
+        if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO:
+            return self.COMBO_TYPE_FULL_COMBO
+        if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST:
+            return self.COMBO_TYPE_FULL_COMBO_ALL_JUST
+        raise Exception('Invalid game_combo value {}'.format(game_combo))
+
+    def handle_pcb_rb4error_request(self, request: Node) -> Node:
+        return Node.void('pcb')
+
+    def handle_pcb_rb4uptime_update_request(self, request: Node) -> Node:
+        return Node.void('pcb')
+
+    def handle_pcb_rb4boot_request(self, request: Node) -> Node:
+        shop_id = ID.parse_machine_id(request.child_value('lid'))
+        machine = self.get_machine_by_id(shop_id)
+        if machine is not None:
+            machine_name = machine.name
+            close = machine.data.get_bool('close')
+            hour = machine.data.get_int('hour')
+            minute = machine.data.get_int('minute')
+        else:
+            machine_name = ''
+            close = False
+            hour = 0
+            minute = 0
+
+        root = Node.void('pcb')
+        sinfo = Node.void('sinfo')
+        root.add_child(sinfo)
+        sinfo.add_child(Node.string('nm', machine_name))
+        sinfo.add_child(Node.bool('cl_enbl', close))
+        sinfo.add_child(Node.u8('cl_h', hour))
+        sinfo.add_child(Node.u8('cl_m', minute))
+        sinfo.add_child(Node.bool('shop_flag', True))
+        return root
+
+    def handle_lobby_rb4entry_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Create a lobby entry for this user
+        extid = request.child_value('e/uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            info = self.data.local.lobby.get_play_session_info(self.game, self.version, userid)
+            if profile is None or info is None:
+                return root
+
+            self.data.local.lobby.put_lobby(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'mid': request.child_value('e/mid'),
+                    'ng': request.child_value('e/ng'),
+                    'mopt': request.child_value('e/mopt'),
+                    'lid': request.child_value('e/lid'),
+                    'sn': request.child_value('e/sn'),
+                    'pref': request.child_value('e/pref'),
+                    'stg': request.child_value('e/stg'),
+                    'pside': request.child_value('e/pside'),
+                    'eatime': request.child_value('e/eatime'),
+                    'ga': request.child_value('e/ga'),
+                    'gp': request.child_value('e/gp'),
+                    'la': request.child_value('e/la'),
+                    'ver': request.child_value('e/ver'),
+                    'tension': request.child_value('e/tension'),
+                }
+            )
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            root.add_child(Node.s32('eid', lobby.get_int('id')))
+            e = Node.void('e')
+            root.add_child(e)
+            e.add_child(Node.s32('eid', lobby.get_int('id')))
+            e.add_child(Node.u16('mid', lobby.get_int('mid')))
+            e.add_child(Node.u8('ng', lobby.get_int('ng')))
+            e.add_child(Node.s32('uid', profile.get_int('extid')))
+            e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+            e.add_child(Node.string('pn', profile.get_str('name')))
+            e.add_child(Node.s32('plyid', info.get_int('id')))
+            e.add_child(Node.s16('mg', profile.get_int('mg')))
+            e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+            e.add_child(Node.string('lid', lobby.get_str('lid')))
+            e.add_child(Node.string('sn', lobby.get_str('sn')))
+            e.add_child(Node.u8('pref', lobby.get_int('pref')))
+            e.add_child(Node.s8('stg', lobby.get_int('stg')))
+            e.add_child(Node.s8('pside', lobby.get_int('pside')))
+            e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+            e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+            e.add_child(Node.u16('gp', lobby.get_int('gp')))
+            e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+            e.add_child(Node.u8('ver', lobby.get_int('ver')))
+            e.add_child(Node.s8('tension', lobby.get_int('tension')))
+
+        return root
+
+    def handle_lobby_rb4read_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Look up all lobbies matching the criteria specified
+        ver = request.child_value('var')
+        mg = request.child_value('m_grade')  # noqa: F841
+        extid = request.child_value('uid')
+        limit = request.child_value('max')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
+            for (user, lobby) in lobbies:
+                if limit <= 0:
+                    break
+
+                if user == userid:
+                    # If we have our own lobby, don't return it
+                    continue
+                if ver != lobby.get_int('ver'):
+                    # Don't return lobby data for different versions
+                    continue
+
+                profile = self.get_profile(user)
+                info = self.data.local.lobby.get_play_session_info(self.game, self.version, userid)
+                if profile is None or info is None:
+                    # No profile info, don't return this lobby
+                    return root
+
+                e = Node.void('e')
+                root.add_child(e)
+                e.add_child(Node.s32('eid', lobby.get_int('id')))
+                e.add_child(Node.u16('mid', lobby.get_int('mid')))
+                e.add_child(Node.u8('ng', lobby.get_int('ng')))
+                e.add_child(Node.s32('uid', profile.get_int('extid')))
+                e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+                e.add_child(Node.string('pn', profile.get_str('name')))
+                e.add_child(Node.s32('plyid', info.get_int('id')))
+                e.add_child(Node.s16('mg', profile.get_int('mg')))
+                e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+                e.add_child(Node.string('lid', lobby.get_str('lid')))
+                e.add_child(Node.string('sn', lobby.get_str('sn')))
+                e.add_child(Node.u8('pref', lobby.get_int('pref')))
+                e.add_child(Node.s8('stg', lobby.get_int('stg')))
+                e.add_child(Node.s8('pside', lobby.get_int('pside')))
+                e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+                e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+                e.add_child(Node.u16('gp', lobby.get_int('gp')))
+                e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+                e.add_child(Node.u8('ver', lobby.get_int('ver')))
+                e.add_child(Node.s8('tension', lobby.get_int('tension')))
+
+                limit = limit - 1
+
+        return root
+
+    def handle_lobby_rb4delete_request(self, request: Node) -> Node:
+        eid = request.child_value('eid')
+        self.data.local.lobby.destroy_lobby(eid)
+        return Node.void('lobby')
+
+    def handle_shop_rb4setting_write_request(self, request: Node) -> Node:
+        return Node.void('shop')
+
+    def handle_shop_rb4info_write_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('sinfo/nm'))
+        self.update_machine_data({
+            'close': request.child_value('sinfo/cl_enbl'),
+            'hour': request.child_value('sinfo/cl_h'),
+            'minute': request.child_value('sinfo/cl_m'),
+            'pref': request.child_value('sinfo/prf'),
+        })
+        return Node.void('shop')
+
+    def __add_event_info(self, root: Node) -> None:
+        event_ctrl = Node.void('event_ctrl')
+        root.add_child(event_ctrl)
+        # Contains zero or more nodes like:
+        # <data>
+        #     <type __type="s32">any</type>
+        #     <index __type="s32">any</phase>
+        #     <value __type="s32">any</phase>
+        #     <value2 __type="s32">any</phase>
+        #     <start_time __type="s32">any</phase>
+        #     <end_time __type="s32">any</phase>
+        # </data>
+
+        item_lock_ctrl = Node.void('item_lock_ctrl')
+        root.add_child(item_lock_ctrl)
+        # Contains zero or more nodes like:
+        # <item>
+        #     <type __type="u8">any</type>
+        #     <id __type="u16">any</id>
+        #     <param __type="u16">0-3</param>
+        # </item>
+
+    def __add_shop_score(self, root: Node) -> None:
+        shop_score = Node.void('shop_score')
+        root.add_child(shop_score)
+        today = Node.void('today')
+        shop_score.add_child(today)
+        yesterday = Node.void('yesterday')
+        shop_score.add_child(yesterday)
+
+        all_profiles = self.data.local.user.get_all_profiles(self.game, self.version)
+        all_attempts = self.data.local.music.get_all_attempts(self.game, self.version, timelimit=(Time.beginning_of_today() - Time.SECONDS_IN_DAY))
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine.arcade is not None:
+            lids = [
+                machine.id for machine in self.data.local.machine.get_all_machines(machine.arcade)
+            ]
+        else:
+            lids = [machine.id]
+
+        relevant_profiles = [
+            profile for profile in all_profiles
+            if profile[1].get_int('lid', -1) in lids
+        ]
+
+        for (rootnode, timeoffset) in [
+            (today, 0),
+            (yesterday, Time.SECONDS_IN_DAY),
+        ]:
+            # Grab all attempts made in the relevant day
+            relevant_attempts = [
+                attempt for attempt in all_attempts
+                if (
+                    attempt[1].timestamp >= (Time.beginning_of_today() - timeoffset) and
+                    attempt[1].timestamp <= (Time.end_of_today() - timeoffset)
+                )
+            ]
+
+            # Calculate scores based on attempt
+            scores_by_user: Dict[UserID, Dict[int, Dict[int, Attempt]]] = {}
+            for (userid, attempt) in relevant_attempts:
+                if userid not in scores_by_user:
+                    scores_by_user[userid] = {}
+                if attempt.id not in scores_by_user[userid]:
+                    scores_by_user[userid][attempt.id] = {}
+                if attempt.chart not in scores_by_user[userid][attempt.id]:
+                    # No high score for this yet, just use this attempt
+                    scores_by_user[userid][attempt.id][attempt.chart] = attempt
+                else:
+                    # If this attempt is better than the stored one, replace it
+                    if scores_by_user[userid][attempt.id][attempt.chart].points < attempt.points:
+                        scores_by_user[userid][attempt.id][attempt.chart] = attempt
+
+            # Calculate points earned by user in the day
+            points_by_user: Dict[UserID, int] = {}
+            for userid in scores_by_user:
+                points_by_user[userid] = 0
+                for mid in scores_by_user[userid]:
+                    for chart in scores_by_user[userid][mid]:
+                        points_by_user[userid] = points_by_user[userid] + scores_by_user[userid][mid][chart].points
+
+            # Output that day's earned points
+            for (userid, profile) in relevant_profiles:
+                data = Node.void('data')
+                rootnode.add_child(data)
+                data.add_child(Node.s16('day_id', int((Time.now() - timeoffset) / Time.SECONDS_IN_DAY)))
+                data.add_child(Node.s32('user_id', profile.get_int('extid')))
+                data.add_child(Node.s16('icon_id', profile.get_dict('config').get_int('icon_id')))
+                data.add_child(Node.s16('point', min(points_by_user.get(userid, 0), 32767)))
+                data.add_child(Node.s32('update_time', Time.now()))
+                data.add_child(Node.string('name', profile.get_str('name')))
+
+            rootnode.add_child(Node.s32('timestamp', Time.beginning_of_today() - timeoffset))
+
+    def handle_info_rb4common_request(self, request: Node) -> Node:
+        root = Node.void('info')
+        self.__add_event_info(root)
+        self.__add_shop_score(root)
+
+        return root
+
+    def handle_info_rb4ranking_request(self, request: Node) -> Node:
+        version = request.child_value('ver')
+
+        root = Node.void('info')
+        root.add_child(Node.s32('ver', version))
+        ranking = Node.void('ranking')
+        root.add_child(ranking)
+
+        def add_hitchart(name: str, start: int, end: int, hitchart: List[Tuple[int, int]]) -> None:
+            base = Node.void(name)
+            ranking.add_child(base)
+            base.add_child(Node.s32('bt', start))
+            base.add_child(Node.s32('et', end))
+            new = Node.void('new')
+            base.add_child(new)
+
+            for (mid, plays) in hitchart:
+                d = Node.void('d')
+                new.add_child(d)
+                d.add_child(Node.s16('mid', mid))
+                d.add_child(Node.s32('cnt', plays))
+
+        # Weekly hit chart
+        add_hitchart(
+            'weekly',
+            Time.now() - Time.SECONDS_IN_WEEK,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 7),
+        )
+
+        # Monthly hit chart
+        add_hitchart(
+            'monthly',
+            Time.now() - Time.SECONDS_IN_DAY * 30,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 30),
+        )
+
+        # All time hit chart
+        add_hitchart(
+            'total',
+            Time.now() - Time.SECONDS_IN_DAY * 365,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 365),
+        )
+
+        return root
+
+    def handle_info_rb4shop_score_ranking_request(self, request: Node) -> Node:
+        start_music_id = request.child_value('min')
+        end_music_id = request.child_value('max')
+
+        root = Node.void('info')
+        shop_score = Node.void('shop_score')
+        root.add_child(shop_score)
+        shop_score.add_child(Node.s32('time', Time.now()))
+
+        profiles: Dict[UserID, ValidatedDict] = {}
+        for songid in range(start_music_id, end_music_id + 1):
+            allscores = self.data.local.music.get_all_scores(
+                self.game,
+                self.version,
+                songid=songid,
+            )
+
+            for ng in [
+                self.CHART_TYPE_BASIC,
+                self.CHART_TYPE_MEDIUM,
+                self.CHART_TYPE_HARD,
+                self.CHART_TYPE_SPECIAL,
+            ]:
+                scores = sorted(
+                    [score for score in allscores if score[1].chart == ng],
+                    key=lambda score: score[1].points,
+                    reverse=True,
+                )
+
+                for i in range(len(scores)):
+                    userid, score = scores[i]
+                    if userid not in profiles:
+                        profiles[userid] = self.get_any_profile(userid)
+                    profile = profiles[userid]
+
+                    data = Node.void('data')
+                    shop_score.add_child(data)
+                    data.add_child(Node.s32('rank', i + 1))
+                    data.add_child(Node.s16('music_id', songid))
+                    data.add_child(Node.s8('note_grade', score.chart))
+                    data.add_child(Node.s8('clear_type', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
+                    data.add_child(Node.s32('user_id', profile.get_int('extid')))
+                    data.add_child(Node.s16('icon_id', profile.get_dict('config').get_int('icon_id')))
+                    data.add_child(Node.s32('score', score.points))
+                    data.add_child(Node.s32('time', score.timestamp))
+                    data.add_child(Node.string('name', profile.get_str('name')))
+
+        return root
+
+    def handle_info_rb4pzlcmt_read_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        locid = ID.parse_machine_id(request.child_value('lid'))
+        limit = request.child_value('limit')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        comments = [
+            achievement for achievement in
+            self.data.local.user.get_all_time_based_achievements(self.game, self.version)
+            if achievement[1].type == 'puzzle_comment'
+        ]
+        comments.sort(key=lambda x: x[1].timestamp, reverse=True)
+        favorites = [
+            comment for comment in comments
+            if comment[0] == userid
+        ]
+        locationcomments = [
+            comment for comment in comments
+            if comment[1].data.get_int('locid') == locid
+        ]
+
+        # Cap all comment blocks to the limit
+        if limit >= 0:
+            comments = comments[:limit]
+            favorites = favorites[:limit]
+            locationcomments = locationcomments[:limit]
+
+        root = Node.void('info')
+        comment = Node.void('comment')
+        root.add_child(comment)
+        comment.add_child(Node.s32('time', Time.now()))
+
+        # Mapping of profiles to userIDs
+        uid_mapping = {
+            uid: prof for (uid, prof) in self.get_any_profiles([c[0] for c in comments])
+        }
+
+        # Handle anonymous comments by returning a default profile
+        uid_mapping[UserID(0)] = ValidatedDict({'name': 'ＰＬＡＹＥＲ', 'extid': 0})
+
+        def add_comments(name: str, selected: List[Tuple[UserID, Achievement]]) -> None:
+            for (uid, ach) in selected:
+                cmnt = Node.void(name)
+                root.add_child(cmnt)
+                cmnt.add_child(Node.s32('uid', uid_mapping[uid].get_int('extid')))
+                cmnt.add_child(Node.string('name', uid_mapping[uid].get_str('name')))
+                cmnt.add_child(Node.s16('icon', ach.data.get_int('icon')))
+                cmnt.add_child(Node.s8('bln', ach.data.get_int('bln')))
+                cmnt.add_child(Node.string('lid', ID.format_machine_id(ach.data.get_int('locid'))))
+                cmnt.add_child(Node.s8('pref', ach.data.get_int('prefecture')))
+                cmnt.add_child(Node.s32('time', ach.timestamp))
+                cmnt.add_child(Node.string('comment', ach.data.get_str('comment')))
+                cmnt.add_child(Node.bool('is_tweet', ach.data.get_bool('tweet')))
+
+        # Add all comments
+        add_comments('c', comments)
+
+        # Add personal comments (favorites)
+        add_comments('cf', favorites)
+
+        # Add location comments
+        add_comments('cs', locationcomments)
+
+        return root
+
+    def handle_info_rb4pzlcmt_write_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            # Anonymous comment
+            userid = UserID(0)
+
+        icon = request.child_value('icon')
+        bln = request.child_value('bln')
+        locid = ID.parse_machine_id(request.child_value('lid'))
+        prefecture = request.child_value('pref')
+        comment = request.child_value('comment')
+        is_tweet = request.child_value('is_tweet')
+
+        # Link comment to user's profile
+        self.data.local.user.put_time_based_achievement(
+            self.game,
+            self.version,
+            userid,
+            0,  # We never have an ID for this, since comments are add-only
+            'puzzle_comment',
+            {
+                'icon': icon,
+                'bln': bln,
+                'locid': locid,
+                'prefecture': prefecture,
+                'comment': comment,
+                'tweet': is_tweet,
+            },
+        )
+
+        return Node.void('info')
+
+    def handle_player_rb4start_request(self, request: Node) -> Node:
+        root = Node.void('player')
+
+        # Create a new play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            self.data.local.lobby.put_play_session_info(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'ga': request.child_value('ga'),
+                    'gp': request.child_value('gp'),
+                    'la': request.child_value('la'),
+                    'pnid': request.child_value('pnid'),
+                },
+            )
+            info = self.data.local.lobby.get_play_session_info(
+                self.game,
+                self.version,
+                userid,
+            )
+            if info is not None:
+                play_id = info.get_int('id')
+            else:
+                play_id = 0
+        else:
+            play_id = 0
+
+        # Session stuff, and resend global defaults
+        root.add_child(Node.s32('plyid', play_id))
+        root.add_child(Node.u64('start_time', Time.now() * 1000))
+        self.__add_event_info(root)
+
+        return root
+
+    def handle_player_rb4end_request(self, request: Node) -> Node:
+        # Destroy play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            # Kill any lingering lobbies by this user
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            if lobby is not None:
+                self.data.local.lobby.destroy_lobby(lobby.get_int('id'))
+            self.data.local.lobby.destroy_play_session_info(self.game, self.version, userid)
+
+        return Node.void('player')
+
+    def handle_player_rb4readepisode_request(self, request: Node) -> Node:
+        extid = request.child_value('user_id')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        else:
+            achievements = []
+
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+        episode = Node.void('episode')
+        pdata.add_child(episode)
+
+        for achievement in achievements:
+            if achievement.type != 'episode':
+                continue
+
+            info = Node.void('info')
+            episode.add_child(info)
+            info.add_child(Node.s32('user_id', extid))
+            info.add_child(Node.u8('type', achievement.id))
+            info.add_child(Node.u16('value0', achievement.data.get_int('value0')))
+            info.add_child(Node.u16('value1', achievement.data.get_int('value1')))
+            info.add_child(Node.string('text', achievement.data.get_str('text')))
+            info.add_child(Node.s32('time', achievement.data.get_int('time')))
+
+        return root
+
+    def handle_player_rb4readscore_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            scores: List[Score] = []
+        else:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        record = Node.void('record')
+        pdata.add_child(record)
+        record_old = Node.void('record_old')
+        pdata.add_child(record_old)
+
+        for score in scores:
+            rec = Node.void('rec')
+            record.add_child(rec)
+            rec.add_child(Node.s16('mid', score.id))
+            rec.add_child(Node.s8('ntgrd', score.chart))
+            rec.add_child(Node.s32('pc', score.plays))
+            rec.add_child(Node.s8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
+            rec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
+            rec.add_child(Node.s16('scr', score.points))
+            rec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
+            rec.add_child(Node.s16(
+                'param',
+                self.__db_to_game_combo_type(score.data.get_int('combo_type')) + score.data.get_int('param'),
+            ))
+            rec.add_child(Node.s32('bscrt', score.timestamp))
+            rec.add_child(Node.s32('bart', score.data.get_int('best_achievement_rate_time')))
+            rec.add_child(Node.s32('bctt', score.data.get_int('best_clear_type_time')))
+            rec.add_child(Node.s32('bmst', score.data.get_int('best_miss_count_time')))
+            rec.add_child(Node.s32('time', score.data.get_int('last_played_time')))
+
+        return root
+
+    def handle_player_rb4selectscore_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        songid = request.child_value('music_id')
+        chart = request.child_value('note_grade')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            score = None
+            profile = None
+        else:
+            score = self.data.remote.music.get_score(self.game, self.version, userid, songid, chart)
+            profile = self.get_any_profile(userid)
+
+        root = Node.void('player')
+        if score is not None and profile is not None:
+            player_select_score = Node.void('player_select_score')
+            root.add_child(player_select_score)
+
+            player_select_score.add_child(Node.s32('user_id', extid))
+            player_select_score.add_child(Node.string('name', profile.get_str('name')))
+            player_select_score.add_child(Node.s32('m_score', score.points))
+            player_select_score.add_child(Node.s32('m_scoreTime', score.timestamp))
+            player_select_score.add_child(Node.s16('m_iconID', profile.get_dict('config').get_int('icon_id')))
+        return root
+
+    def handle_player_rbsvLinkageSave_request(self, request: Node) -> Node:
+        # I think this is ReflecBeat/SoundVoltex linkage save, and I
+        # am somewhat convinced that PK/BN is for packets/blocks, but
+        # whatever.
+        root = Node.void('player')
+        root.add_child(Node.s32('before_pk_value', -1))
+        root.add_child(Node.s32('after_pk_value', -1))
+        root.add_child(Node.s32('before_bn_value', -1))
+        root.add_child(Node.s32('after_bn_value', -1))
+        return root
+
+    def handle_player_rb4total_bestallrank_read_request(self, request: Node) -> Node:
+        # This gives us a 6-integer array mapping to user scores for the following:
+        # [total score, basic chart score, medium chart score, hard chart score,
+        # special chart score, new songs score].
+        # It appears to return several 6-array values similar to the following:
+        # <score>
+        #     <rank __type="s32" __count="6">1 2 3 4 5 6</rank>
+        #     <score __type="s32" __count="6">101 102 103 104 105 106</score>
+        #     <allrank __type="s32" __count="6">7 8 9 10 11 12</allrank>
+        # </score>
+        # The first 'rank' is the displayed value for the six categories. The
+        # second and third values appear unused in-game. I think this is supposed
+        # to give a player the idea of what ranking they are on the server for
+        # various scores.
+        current_scores = request.child_value('score')
+
+        # First, grab all scores on the network for this version, and all songs
+        # available so we know which songs are new to this version of the game.
+        all_scores = self.data.remote.music.get_all_scores(self.game, self.version)
+        all_songs = self.data.local.music.get_all_songs(self.game, self.version)
+
+        # Figure out what song IDs are new
+        new_songs = {song.id for song in all_songs if song.data.get_int('folder', 0) == self.version}
+
+        # Now grab all participating users that had scores
+        all_users = {userid for (userid, score) in all_scores}
+
+        # Now, group the scores by user, so we can add up the totals, only including
+        # scores where the user at least cleared the song.
+        scores_by_user = {
+            userid: [
+                score for (uid, score) in all_scores
+                if uid == userid and score.data.get_int('clear_type') >= self.CLEAR_TYPE_CLEARED]
+            for userid in all_users
+        }
+
+        # Now, sum up the scores into the six categories that the game expects.
+        total_scores = sorted(
+            [
+                sum([score.points for score in scores])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        basic_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_BASIC])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        medium_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_MEDIUM])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        hard_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_HARD])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        special_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_SPECIAL])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        new_scores = sorted(
+            [
+                sum([score.points for score in scores if score.id in new_songs])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+
+        # Guarantee that a zero score is at the end of every list, so that it makes
+        # the algorithm for figuring out place have no edge case.
+        total_scores.append(0)
+        basic_scores.append(0)
+        medium_scores.append(0)
+        hard_scores.append(0)
+        special_scores.append(0)
+        new_scores.append(0)
+
+        # Now, figure out where we fit based on the scores sent from the game.
+        user_place = [1, 1, 1, 1, 1, 1]
+        which_score = [
+            total_scores,
+            basic_scores,
+            medium_scores,
+            hard_scores,
+            special_scores,
+            new_scores,
+        ]
+        for i in range(len(user_place)):
+            current_score = current_scores[i]
+            scores = which_score[i]
+            for score in scores:
+                if current_score >= score:
+                    break
+                user_place[i] = user_place[i] + 1
+
+        root = Node.void('player')
+        scorenode = Node.void('score')
+        root.add_child(scorenode)
+        scorenode.add_child(Node.s32_array('rank', user_place))
+        scorenode.add_child(Node.s32_array('score', [0] * 6))
+        scorenode.add_child(Node.s32_array('allrank', [len(total_scores)] * 6))
+        return root
+
+    def handle_player_rb4delete_request(self, request: Node) -> Node:
+        return Node.void('player')
+
+    def handle_player_rb4read_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.get_profile_by_refid(refid)
+        if profile:
+            return profile
+        return Node.void('player')
+
+    def handle_player_rb4succeed_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            previous_version = self.previous_version()
+            profile = previous_version.get_profile(userid)
+            achievements = self.data.local.user.get_achievements(previous_version.game, previous_version.version, userid)
+            scores = self.data.remote.music.get_scores(previous_version.game, previous_version.version, userid)
+        else:
+            profile = None
+
+        root = Node.void('player')
+
+        if profile is None:
+            # Return empty succeed to say this is new
+            root.add_child(Node.string('name', ''))
+            root.add_child(Node.s16('lv', -1))
+            root.add_child(Node.s32('exp', -1))
+            root.add_child(Node.s32('grd', -1))
+            root.add_child(Node.s32('ap', -1))
+            root.add_child(Node.s32('money', -1))
+            root.add_child(Node.void('released'))
+            root.add_child(Node.void('mrecord'))
+        else:
+            # Return previous profile formatted to say this is data succession
+            root.add_child(Node.string('name', profile.get_str('name')))
+            root.add_child(Node.s16('lv', profile.get_int('lvl')))
+            root.add_child(Node.s32('exp', profile.get_int('exp')))
+            root.add_child(Node.s32('grd', profile.get_int('mg')))  # This is a guess
+            root.add_child(Node.s32('ap', profile.get_int('ap')))
+            root.add_child(Node.s32('money', 0))
+
+            released = Node.void('released')
+            root.add_child(released)
+            for item in achievements:
+                if item.type != 'item_0':
+                    continue
+
+                released.add_child(Node.s16('i', item.id))
+
+            mrecord = Node.void('mrecord')
+            root.add_child(mrecord)
+            for score in scores:
+                mrec = Node.void('mrec')
+                mrecord.add_child(mrec)
+                mrec.add_child(Node.s16('mid', score.id))
+                mrec.add_child(Node.s8('ntgrd', score.chart))
+                mrec.add_child(Node.s32('pc', score.plays))
+                mrec.add_child(Node.s8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
+                mrec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
+                mrec.add_child(Node.s16('scr', score.points))
+                mrec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
+                mrec.add_child(Node.u16('ver', 0))
+                mrec.add_child(Node.s32('bst', score.timestamp))
+                mrec.add_child(Node.s32('bat', score.data.get_int('best_achievement_rate_time')))
+                mrec.add_child(Node.s32('bct', score.data.get_int('best_clear_type_time')))
+                mrec.add_child(Node.s32('bmt', score.data.get_int('best_miss_count_time')))
+
+        return root
+
+    def handle_player_rb4write_request(self, request: Node) -> Node:
+        refid = request.child_value('pdata/account/rid')
+        profile = self.put_profile_by_refid(refid, request)
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.s32('uid', 0))
+        else:
+            root.add_child(Node.s32('uid', profile.get_int('extid')))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        statistics = self.get_play_statistics(userid)
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        # Account time info
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+
+        # Account info
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', profile.get_int('extid')))
+        account.add_child(Node.s32('tpc', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s32('dpc', today_count))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s32('intrvld', 0))
+        account.add_child(Node.s16('ver', 1))
+        account.add_child(Node.u64('pst', 0))
+        account.add_child(Node.u64('st', Time.now() * 1000))
+        account.add_child(Node.u8('debutVer', 2))
+
+        # Base profile info
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', profile.get_str('name')))
+        base.add_child(Node.s32('exp', profile.get_int('exp')))
+        base.add_child(Node.s32('lv', profile.get_int('lvl')))
+        base.add_child(Node.s32('mg', profile.get_int('mg')))
+        base.add_child(Node.s32('ap', profile.get_int('ap')))
+        base.add_child(Node.string('cmnt', ''))
+        base.add_child(Node.s32('uattr', profile.get_int('uattr')))
+        base.add_child(Node.s32('money', profile.get_int('money')))
+        base.add_child(Node.s32('tbs', -1))
+        base.add_child(Node.s32('tbs_r', -1))
+        base.add_child(Node.s32('tbgs', -1))
+        base.add_child(Node.s32('tbgs_r', -1))
+        base.add_child(Node.s32('tbms', -1))
+        base.add_child(Node.s32('tbms_r', -1))
+        base.add_child(Node.s32('qe_win', -1))
+        base.add_child(Node.s32('qe_legend', -1))
+        base.add_child(Node.s32('qe2_win', -1))
+        base.add_child(Node.s32('qe2_legend', -1))
+        base.add_child(Node.s32('qe3_win', -1))
+        base.add_child(Node.s32('qe3_legend', -1))
+        base.add_child(Node.s16_array('mlog', [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
+        base.add_child(Node.s32('class', profile.get_int('class')))
+        base.add_child(Node.s32('class_ar', profile.get_int('class_ar')))
+        base.add_child(Node.s32('getrfl', -1))
+        base.add_child(Node.s32('upper_pt', profile.get_int('upper_pt')))
+
+        # Rivals
+        rival = Node.void('rival')
+        pdata.add_child(rival)
+        slotid = 0
+        for link in links:
+            if link.type != 'rival':
+                continue
+
+            rprofile = self.get_profile(link.other_userid)
+            if rprofile is None:
+                continue
+            lobbyinfo = self.data.local.lobby.get_play_session_info(self.game, self.version, link.other_userid)
+            if lobbyinfo is None:
+                lobbyinfo = ValidatedDict()
+
+            r = Node.void('r')
+            rival.add_child(r)
+            r.add_child(Node.s32('slot_id', slotid))
+            r.add_child(Node.s32('id', rprofile.get_int('extid')))
+            r.add_child(Node.string('name', rprofile.get_str('name')))
+            r.add_child(Node.s32('icon', profile.get_dict('config').get_int('icon_id')))
+            r.add_child(Node.s32('m_level', profile.get_int('mg')))
+            r.add_child(Node.s32('class', profile.get_int('class')))
+            r.add_child(Node.s32('class_ar', profile.get_int('class_ar')))
+            r.add_child(Node.bool('friend', True))
+            r.add_child(Node.bool('target', False))
+            r.add_child(Node.u32('time', lobbyinfo.get_int('time')))
+            r.add_child(Node.u8_array('ga', lobbyinfo.get_int_array('ga', 4)))
+            r.add_child(Node.u16('gp', lobbyinfo.get_int('gp')))
+            r.add_child(Node.u8_array('ipn', lobbyinfo.get_int_array('la', 4)))
+            r.add_child(Node.u8_array('pnid', lobbyinfo.get_int_array('pnid', 16)))
+            slotid = slotid + 1
+
+        # Stamps
+        stamp = Node.void('stamp')
+        stampdict = profile.get_dict('stamp')
+        pdata.add_child(stamp)
+        stamp.add_child(Node.s32_array('stmpcnt', stampdict.get_int_array('stmpcnt', 10)))
+        stamp.add_child(Node.s64('area', stampdict.get_int('area')))
+        stamp.add_child(Node.s64('prfvst', stampdict.get_int('prfvst')))
+
+        # Configuration
+        configdict = profile.get_dict('config')
+        config = Node.void('config')
+        pdata.add_child(config)
+        config.add_child(Node.u8('msel_bgm', configdict.get_int('msel_bgm')))
+        config.add_child(Node.u8('narrowdown_type', configdict.get_int('narrowdown_type')))
+        config.add_child(Node.s16('icon_id', configdict.get_int('icon_id')))
+        config.add_child(Node.s16('byword_0', configdict.get_int('byword_0')))
+        config.add_child(Node.s16('byword_1', configdict.get_int('byword_1')))
+        config.add_child(Node.bool('is_auto_byword_0', configdict.get_bool('is_auto_byword_0')))
+        config.add_child(Node.bool('is_auto_byword_1', configdict.get_bool('is_auto_byword_1')))
+        config.add_child(Node.u8('mrec_type', configdict.get_int('mrec_type')))
+        config.add_child(Node.u8('tab_sel', configdict.get_int('tab_sel')))
+        config.add_child(Node.u8('card_disp', configdict.get_int('card_disp')))
+        config.add_child(Node.u8('score_tab_disp', configdict.get_int('score_tab_disp')))
+        config.add_child(Node.s16('last_music_id', configdict.get_int('last_music_id', -1)))
+        config.add_child(Node.u8('last_note_grade', configdict.get_int('last_note_grade')))
+        config.add_child(Node.u8('sort_type', configdict.get_int('sort_type')))
+        config.add_child(Node.u8('rival_panel_type', configdict.get_int('rival_panel_type')))
+        config.add_child(Node.u64('random_entry_work', configdict.get_int('random_entry_work')))
+        config.add_child(Node.u64('custom_folder_work', configdict.get_int('custom_folder_work')))
+        config.add_child(Node.u8('folder_type', configdict.get_int('folder_type')))
+        config.add_child(Node.u8('folder_lamp_type', configdict.get_int('folder_lamp_type')))
+        config.add_child(Node.bool('is_tweet', configdict.get_bool('is_tweet')))
+        config.add_child(Node.bool('is_link_twitter', configdict.get_bool('is_link_twitter')))
+
+        # Customizations
+        customdict = profile.get_dict('custom')
+        custom = Node.void('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('st_shot', customdict.get_int('st_shot')))
+        custom.add_child(Node.u8('st_frame', customdict.get_int('st_frame')))
+        custom.add_child(Node.u8('st_expl', customdict.get_int('st_expl')))
+        custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
+        custom.add_child(Node.u8('st_shot_vol', customdict.get_int('st_shot_vol')))
+        custom.add_child(Node.u8('st_bg_bri', customdict.get_int('st_bg_bri')))
+        custom.add_child(Node.u8('st_obj_size', customdict.get_int('st_obj_size')))
+        custom.add_child(Node.u8('st_jr_gauge', customdict.get_int('st_jr_gauge')))
+        custom.add_child(Node.u8('st_clr_gauge', customdict.get_int('st_clr_gauge')))
+        custom.add_child(Node.u8('st_jdg_disp', customdict.get_int('st_jdg_disp')))
+        custom.add_child(Node.u8('st_tm_disp', customdict.get_int('st_tm_disp')))
+        custom.add_child(Node.u8('st_rnd', customdict.get_int('st_rnd')))
+        custom.add_child(Node.u8('st_hazard', customdict.get_int('st_hazard')))
+        custom.add_child(Node.u8('st_clr_cond', customdict.get_int('st_clr_cond')))
+        custom.add_child(Node.s16_array('schat_0', customdict.get_int_array('schat_0', 10)))
+        custom.add_child(Node.s16_array('schat_1', customdict.get_int_array('schat_1', 10)))
+        custom.add_child(Node.u8('cheer_voice', customdict.get_int('cheer_voice')))
+        custom.add_child(Node.u8('same_time_note_disp', customdict.get_int('same_time_note_disp')))
+
+        # Unlocks
+        released = Node.void('released')
+        pdata.add_child(released)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+            if game_config.get_bool('force_unlock_songs') and itemtype == 0:
+                # Don't echo unlocks when we're force unlocking, we'll do it later
+                continue
+
+            info = Node.void('info')
+            released.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u16('id', item.id))
+            info.add_child(Node.u16('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for songid in ids:
+                if ids[songid] == 0:
+                    continue
+
+                info = Node.void('info')
+                released.add_child(info)
+                info.add_child(Node.u8('type', 0))
+                info.add_child(Node.u16('id', songid))
+                info.add_child(Node.u16('param', ids[songid]))
+
+        # Announcements
+        announce = Node.void('announce')
+        pdata.add_child(announce)
+
+        for announcement in achievements:
+            if announcement.type[:13] != 'announcement_':
+                continue
+            announcementtype = int(announcement.type[13:])
+
+            info = Node.void('info')
+            announce.add_child(info)
+            info.add_child(Node.u8('type', announcementtype))
+            info.add_child(Node.u16('id', announcement.id))
+            info.add_child(Node.u16('param', announcement.data.get_int('param')))
+            info.add_child(Node.bool('bneedannounce', announcement.data.get_bool('need')))
+
+        # Dojo ranking return
+        dojo = Node.void('dojo')
+        pdata.add_child(dojo)
+
+        for entry in achievements:
+            if entry.type != 'dojo':
+                continue
+
+            rec = Node.void('rec')
+            dojo.add_child(rec)
+            rec.add_child(Node.s32('class', entry.id))
+            rec.add_child(Node.s32('clear_type', entry.data.get_int('clear_type')))
+            rec.add_child(Node.s32('total_ar', entry.data.get_int('ar')))
+            rec.add_child(Node.s32('total_score', entry.data.get_int('score')))
+            rec.add_child(Node.s32('play_count', entry.data.get_int('plays')))
+            rec.add_child(Node.s32('last_play_time', entry.data.get_int('play_timestamp')))
+            rec.add_child(Node.s32('record_update_time', entry.data.get_int('record_timestamp')))
+            rec.add_child(Node.s32('rank', 0))
+
+        # Player Parameters
+        player_param = Node.void('player_param')
+        pdata.add_child(player_param)
+
+        for param in achievements:
+            if param.type[:13] != 'player_param_':
+                continue
+            itemtype = int(param.type[13:])
+
+            itemnode = Node.void('item')
+            player_param.add_child(itemnode)
+            itemnode.add_child(Node.s32('type', itemtype))
+            itemnode.add_child(Node.s32('bank', param.id))
+            itemnode.add_child(Node.s32_array('data', param.data.get_int_array('data', 256)))
+
+        # Shop score for players
+        self.__add_shop_score(pdata)
+
+        # Quest data
+        questdict = profile.get_dict('quest')
+        quest = Node.void('quest')
+        pdata.add_child(quest)
+        quest.add_child(Node.s16('eye_color', questdict.get_int('eye_color')))
+        quest.add_child(Node.s16('body_color', questdict.get_int('body_color')))
+        quest.add_child(Node.s16('item', questdict.get_int('item')))
+        quest.add_child(Node.string('comment', ''))
+
+        # Derby settings
+        derby = Node.void('derby')
+        pdata.add_child(derby)
+        derby.add_child(Node.bool('is_open', False))
+
+        # Codebreaking stuff
+        codebreaking = Node.void('codebreaking')
+        pdata.add_child(codebreaking)
+        codebreaking.add_child(Node.s32('cb_id', -1))
+        codebreaking.add_child(Node.s32('cb_sub_id', -1))
+        codebreaking.add_child(Node.s32('music_id', -1))
+        codebreaking.add_child(Node.string('question', ''))
+
+        # Unknown IIDX link crap
+        iidx_linkage = Node.void('iidx_linkage')
+        pdata.add_child(iidx_linkage)
+        iidx_linkage.add_child(Node.s32('linkage_id', -1))
+        iidx_linkage.add_child(Node.s32('phase', -1))
+        iidx_linkage.add_child(Node.s64('long_bit_0', -1))
+        iidx_linkage.add_child(Node.s64('long_bit_1', -1))
+        iidx_linkage.add_child(Node.s64('long_bit_2', -1))
+        iidx_linkage.add_child(Node.s64('long_bit_3', -1))
+        iidx_linkage.add_child(Node.s64('long_bit_4', -1))
+        iidx_linkage.add_child(Node.s64('long_bit_5', -1))
+        iidx_linkage.add_child(Node.s32('add_0', -1))
+        iidx_linkage.add_child(Node.s32('add_1', -1))
+        iidx_linkage.add_child(Node.s32('add_2', -1))
+        iidx_linkage.add_child(Node.s32('add_3', -1))
+
+        # Unknown event crap
+        pue = Node.void('pue')
+        pdata.add_child(pue)
+        pue.add_child(Node.s32('event_id', -1))
+        pue.add_child(Node.s32('point', -1))
+        pue.add_child(Node.s32('value0', -1))
+        pue.add_child(Node.s32('value1', -1))
+        pue.add_child(Node.s32('value2', -1))
+        pue.add_child(Node.s32('value3', -1))
+        pue.add_child(Node.s32('value4', -1))
+        pue.add_child(Node.s32('start_time', -1))
+        pue.add_child(Node.s32('end_time', -1))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        game_config = self.get_game_config()
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Save base player profile info
+        newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('pdata/account/lid')))
+        newprofile.replace_str('name', request.child_value('pdata/base/name'))
+        newprofile.replace_int('exp', request.child_value('pdata/base/exp'))
+        newprofile.replace_int('lvl', request.child_value('pdata/base/lvl'))
+        newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
+        newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
+        newprofile.replace_int('money', request.child_value('pdata/base/money'))
+        newprofile.replace_int('class', request.child_value('pdata/base/class'))
+        newprofile.replace_int('class_ar', request.child_value('pdata/base/class_ar'))
+        newprofile.replace_int('upper_pt', request.child_value('pdata/base/upper_pt'))
+
+        # Save stamps
+        stampdict = newprofile.get_dict('stamp')
+        stamp = request.child('pdata/stamp')
+        if stamp:
+            stampdict.replace_int_array('stmpcnt', 10, stamp.child_value('stmpcnt'))
+            stampdict.replace_int('area', stamp.child_value('area'))
+            stampdict.replace_int('prfvst', stamp.child_value('prfvst'))
+        newprofile.replace_dict('stamp', stampdict)
+
+        # Save quest stuff
+        questdict = newprofile.get_dict('quest')
+        quest = request.child('pdata/quest')
+        if quest:
+            questdict.replace_int('eye_color', quest.child_value('eye_color'))
+            questdict.replace_int('body_color', quest.child_value('body_color'))
+            questdict.replace_int('item', quest.child_value('item'))
+        newprofile.replace_dict('quest', questdict)
+
+        # Save player dojo
+        dojo = request.child('pdata/dojo')
+        if dojo:
+            dojoid = dojo.child_value('class')
+            clear_type = dojo.child_value('clear_type')
+            ar = dojo.child_value('t_ar')
+            score = dojo.child_value('t_score')
+
+            # Figure out timestamp stuff
+            data = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                dojoid,
+                'dojo',
+            ) or ValidatedDict()
+
+            if ar >= data.get_int('ar'):
+                # We set a new achievement rate, keep the new values
+                record_time = Time.now()
+            else:
+                # We didn't, keep the old values for achievement rate, but
+                # override score and clear_type only if they were better.
+                record_time = data.get_int('record_timestamp')
+                ar = data.get_int('ar')
+                score = max(score, data.get_int('score'))
+                clear_type = max(clear_type, data.get_int('clear_type'))
+
+            play_time = Time.now()
+            plays = data.get_int('plays') + 1
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                dojoid,
+                'dojo',
+                {
+                    'clear_type': clear_type,
+                    'ar': ar,
+                    'score': score,
+                    'plays': plays,
+                    'play_timestamp': play_time,
+                    'record_timestamp': record_time,
+                },
+            )
+
+        # Save player config
+        configdict = newprofile.get_dict('config')
+        config = request.child('pdata/config')
+        if config:
+            configdict.replace_int('msel_bgm', config.child_value('msel_bgm'))
+            configdict.replace_int('narrowdown_type', config.child_value('narrowdown_type'))
+            configdict.replace_int('icon_id', config.child_value('icon_id'))
+            configdict.replace_int('byword_0', config.child_value('byword_0'))
+            configdict.replace_int('byword_1', config.child_value('byword_1'))
+            configdict.replace_bool('is_auto_byword_0', config.child_value('is_auto_byword_0'))
+            configdict.replace_bool('is_auto_byword_1', config.child_value('is_auto_byword_1'))
+            configdict.replace_int('mrec_type', config.child_value('mrec_type'))
+            configdict.replace_int('tab_sel', config.child_value('tab_sel'))
+            configdict.replace_int('card_disp', config.child_value('card_disp'))
+            configdict.replace_int('score_tab_disp', config.child_value('score_tab_disp'))
+            configdict.replace_int('last_music_id', config.child_value('last_music_id'))
+            configdict.replace_int('last_note_grade', config.child_value('last_note_grade'))
+            configdict.replace_int('sort_type', config.child_value('sort_type'))
+            configdict.replace_int('rival_panel_type', config.child_value('rival_panel_type'))
+            configdict.replace_int('random_entry_work', config.child_value('random_entry_work'))
+            configdict.replace_int('custom_folder_work', config.child_value('custom_folder_work'))
+            configdict.replace_int('folder_type', config.child_value('folder_type'))
+            configdict.replace_int('folder_lamp_type', config.child_value('folder_lamp_type'))
+            configdict.replace_bool('is_tweet', config.child_value('is_tweet'))
+            configdict.replace_bool('is_link_twitter', config.child_value('is_link_twitter'))
+        newprofile.replace_dict('config', configdict)
+
+        # Save player custom settings
+        customdict = newprofile.get_dict('custom')
+        custom = request.child('pdata/custom')
+        if custom:
+            customdict.replace_int('st_shot', custom.child_value('st_shot'))
+            customdict.replace_int('st_frame', custom.child_value('st_frame'))
+            customdict.replace_int('st_expl', custom.child_value('st_expl'))
+            customdict.replace_int('st_bg', custom.child_value('st_bg'))
+            customdict.replace_int('st_shot_vol', custom.child_value('st_shot_vol'))
+            customdict.replace_int('st_bg_bri', custom.child_value('st_bg_bri'))
+            customdict.replace_int('st_obj_size', custom.child_value('st_obj_size'))
+            customdict.replace_int('st_jr_gauge', custom.child_value('st_jr_gauge'))
+            customdict.replace_int('st_clr_gauge', custom.child_value('st_clr_gauge'))
+            customdict.replace_int('st_jdg_disp', custom.child_value('st_jdg_disp'))
+            customdict.replace_int('st_tm_disp', custom.child_value('st_tm_disp'))
+            customdict.replace_int('st_rnd', custom.child_value('st_rnd'))
+            customdict.replace_int('st_hazard', custom.child_value('st_hazard'))
+            customdict.replace_int('st_clr_cond', custom.child_value('st_clr_cond'))
+            customdict.replace_int_array('schat_0', 10, custom.child_value('schat_0'))
+            customdict.replace_int_array('schat_1', 10, custom.child_value('schat_1'))
+            customdict.replace_int('cheer_voice', custom.child_value('cheer_voice'))
+            customdict.replace_int('same_time_note_disp', custom.child_value('same_time_note_disp'))
+        newprofile.replace_dict('custom', customdict)
+
+        # Save player parameter info
+        params = request.child('pdata/player_param')
+        if params:
+            for child in params.children:
+                if child.name != 'item':
+                    continue
+
+                item_type = child.child_value('type')
+                bank = child.child_value('bank')
+                paramdata = child.child_value('data') or []
+                while len(paramdata) < 256:
+                    paramdata.append(0)
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    bank,
+                    'player_param_{}'.format(item_type),
+                    {
+                        'data': paramdata,
+                    },
+                )
+
+        # Save player episode info
+        episode = request.child('pdata/episode')
+        if episode:
+            for child in episode.children:
+                if child.name != 'info':
+                    continue
+
+                # I assume this is copypasta, but I want to be sure
+                extid = child.child_value('user_id')
+                if extid != newprofile.get_int('extid'):
+                    raise Exception('Unexpected user ID, got {} expecting {}'.format(extid, newprofile.get_int('extid')))
+
+                episode_type = child.child_value('type')
+                episode_value0 = child.child_value('value0')
+                episode_value1 = child.child_value('value1')
+                episode_text = child.child_value('text')
+                episode_time = child.child_value('time')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    episode_type,
+                    'episode',
+                    {
+                        'value0': episode_value0,
+                        'value1': episode_value1,
+                        'text': episode_text,
+                        'time': episode_time,
+                    },
+                )
+
+        # Save released info
+        released = request.child('pdata/released')
+        if released:
+            for child in released.children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                if game_config.get_bool('force_unlock_songs') and item_type == 0:
+                    # Don't save unlocks when we're force unlocking
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Save announce info
+        announce = request.child('pdata/announce')
+        if announce:
+            for child in announce.children:
+                if child.name != 'info':
+                    continue
+
+                announce_id = child.child_value('id')
+                announce_type = child.child_value('type')
+                param = child.child_value('param')
+                need = child.child_value('bneedannounce')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    announce_id,
+                    'announcement_{}'.format(announce_type),
+                    {
+                        'param': param,
+                        'need': need,
+                    },
+                )
+
+        # Grab any new rivals added during this play session
+        rivalnode = request.child('pdata/rival')
+        if rivalnode:
+            for child in rivalnode.children:
+                if child.name != 'r':
+                    continue
+
+                extid = child.child_value('id')
+                other_userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if other_userid is None:
+                    continue
+
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'rival',
+                    other_userid,
+                    {},
+                )
+
+        # Grab any new records set during this play session
+        songplays = request.child('pdata/stglog')
+        if songplays:
+            for child in songplays.children:
+                if child.name != 'log':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+                clear_type = child.child_value('ct')
+                if songid == 0 and chart == 0 and clear_type == -1:
+                    # Dummy song save during profile create
+                    continue
+
+                points = child.child_value('sc')
+                achievement_rate = child.child_value('ar')
+                param = child.child_value('param')
+                miss_count = child.child_value('jt_ms')
+
+                # Param is some random bits along with the combo type
+                combo_type = param & 0x3
+                param = param ^ combo_type
+
+                clear_type = self.__game_to_db_clear_type(clear_type)
+                combo_type = self.__game_to_db_combo_type(combo_type, miss_count)
+                self.update_score(
+                    userid,
+                    songid,
+                    chart,
+                    points,
+                    achievement_rate,
+                    clear_type,
+                    combo_type,
+                    miss_count,
+                    param=param,
+                )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/limelight.py b/bemani/backend/reflec/limelight.py
new file mode 100644
index 0000000..b9dea01
--- /dev/null
+++ b/bemani/backend/reflec/limelight.py
@@ -0,0 +1,960 @@
+import copy
+from typing import Optional, Dict, Any, Tuple
+
+from bemani.backend.reflec.base import ReflecBeatBase
+from bemani.backend.reflec.reflecbeat import ReflecBeat
+
+from bemani.common import ValidatedDict, VersionConstants, ID, Time
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class ReflecBeatLimelight(ReflecBeatBase):
+
+    name = "REFLEC BEAT limelight"
+    version = VersionConstants.REFLEC_BEAT_LIMELIGHT
+
+    # Clear types according to the game
+    GAME_CLEAR_TYPE_NO_PLAY = 0
+    GAME_CLEAR_TYPE_FAILED = 2
+    GAME_CLEAR_TYPE_CLEARED = 3
+    GAME_CLEAR_TYPE_FULL_COMBO = 4
+
+    def previous_version(self) -> Optional[ReflecBeatBase]:
+        return ReflecBeat(self.data, self.config, self.model)
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+            'ints': [],
+        }
+
+    def __db_to_game_clear_type(self, db_clear_type: int, db_combo_type: int) -> int:
+        if db_clear_type == self.CLEAR_TYPE_NO_PLAY:
+            return self.GAME_CLEAR_TYPE_NO_PLAY
+        if db_clear_type == self.CLEAR_TYPE_FAILED:
+            return self.GAME_CLEAR_TYPE_FAILED
+        if db_clear_type in [
+            self.CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_HARD_CLEARED,
+            self.CLEAR_TYPE_S_HARD_CLEARED,
+        ]:
+            if db_combo_type in [
+                self.COMBO_TYPE_NONE,
+                self.COMBO_TYPE_ALMOST_COMBO,
+            ]:
+                return self.GAME_CLEAR_TYPE_CLEARED
+            if db_combo_type in [
+                self.COMBO_TYPE_FULL_COMBO,
+                self.COMBO_TYPE_FULL_COMBO_ALL_JUST,
+            ]:
+                return self.GAME_CLEAR_TYPE_FULL_COMBO
+
+            raise Exception('Invalid db_combo_type {}'.format(db_combo_type))
+        raise Exception('Invalid db_clear_type {}'.format(db_clear_type))
+
+    def __game_to_db_clear_type(self, game_clear_type: int) -> Tuple[int, int]:
+        if game_clear_type == self.GAME_CLEAR_TYPE_NO_PLAY:
+            return (self.CLEAR_TYPE_NO_PLAY, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_FAILED:
+            return (self.CLEAR_TYPE_FAILED, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_CLEARED:
+            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_FULL_COMBO:
+            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_FULL_COMBO)
+
+        raise Exception('Invalid game_clear_type {}'.format(game_clear_type))
+
+    def handle_log_exception_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_log_pcb_status_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_log_opsetting_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_log_play_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_pcbinfo_get_request(self, request: Node) -> Node:
+        shop_id = ID.parse_machine_id(request.child_value('lid'))
+        machine = self.get_machine_by_id(shop_id)
+        if machine is not None:
+            machine_name = machine.name
+            close = machine.data.get_bool('close')
+            hour = machine.data.get_int('hour')
+            minute = machine.data.get_int('minute')
+            pref = machine.data.get_int('pref', 51)
+        else:
+            machine_name = ''
+            close = False
+            hour = 0
+            minute = 0
+            pref = 51
+
+        root = Node.void('pcbinfo')
+        info = Node.void('info')
+        root.add_child(info)
+
+        info.add_child(Node.string('name', machine_name))
+        info.add_child(Node.s16('pref', pref))
+        info.add_child(Node.bool('close', close))
+        info.add_child(Node.u8('hour', hour))
+        info.add_child(Node.u8('min', minute))
+
+        return root
+
+    def handle_pcbinfo_set_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('info/name'))
+        self.update_machine_data({
+            'close': request.child_value('info/close'),
+            'hour': request.child_value('info/hour'),
+            'minute': request.child_value('info/min'),
+            'pref': request.child_value('info/pref'),
+        })
+        return Node.void('pcbinfo')
+
+    def __add_event_info(self, request: Node) -> None:
+        events: Dict[int, int] = {}
+
+        for (eventid, phase) in events.items():
+            data = Node.void('data')
+            request.add_child(data)
+            data.add_child(Node.s32('type', -1))
+            data.add_child(Node.s32('value', -1))
+
+    def handle_sysinfo_get_request(self, request: Node) -> Node:
+        root = Node.void('sysinfo')
+        trd = Node.void('trd')
+        root.add_child(trd)
+
+        # Add event info
+        self.__add_event_info(trd)
+
+        return root
+
+    def handle_ranking_read_request(self, request: Node) -> Node:
+        root = Node.void('ranking')
+
+        licenses = Node.void('lic_10')
+        root.add_child(licenses)
+        originals = Node.void('org_10')
+        root.add_child(originals)
+
+        licenses.add_child(Node.time('time', Time.now()))
+        originals.add_child(Node.time('time', Time.now()))
+
+        hitchart = self.data.local.music.get_hit_chart(self.game, self.version, 10)
+        rank = 1
+        for (mid, plays) in hitchart:
+            record = Node.void('record')
+            originals.add_child(record)
+            record.add_child(Node.s16('id', mid))
+            record.add_child(Node.s16('rank', rank))
+            rank = rank + 1
+
+        return root
+
+    def handle_event_r_get_all_request(self, request: Node) -> Node:
+        limit = request.child_value('limit')
+
+        comments = [
+            achievement for achievement in
+            self.data.local.user.get_all_time_based_achievements(self.game, self.version)
+            if achievement[1].type == 'puzzle_comment'
+        ]
+        comments.sort(key=lambda x: x[1].timestamp, reverse=True)
+        statuses = self.data.local.lobby.get_all_play_session_infos(self.game, self.version)
+        statuses.sort(key=lambda x: x[1]['time'], reverse=True)
+
+        # Cap all comment blocks to the limit
+        if limit >= 0:
+            comments = comments[:limit]
+            statuses = statuses[:limit]
+
+        # Mapping of profiles to userIDs
+        uid_mapping = {
+            uid: prof for (uid, prof) in self.get_any_profiles(
+                [c[0] for c in comments] +
+                [s[0] for s in statuses]
+            )
+        }
+
+        # Mapping of location ID to machine name
+        lid_mapping: Dict[int, str] = {}
+
+        root = Node.void('event_r')
+        root.add_child(Node.s32('time', Time.now()))
+        statusnode = Node.void('status')
+        root.add_child(statusnode)
+        commentnode = Node.void('comment')
+        root.add_child(commentnode)
+
+        for (uid, comment) in comments:
+            lid = ID.parse_machine_id(comment.data.get_str('lid'))
+
+            # Look up external data for the request
+            if lid not in lid_mapping:
+                machine = self.get_machine_by_id(lid)
+                if machine is not None:
+                    lid_mapping[lid] = machine.name
+                else:
+                    lid_mapping[lid] = ''
+
+            c = Node.void('c')
+            commentnode.add_child(c)
+            c.add_child(Node.s32('uid', uid_mapping[uid].get_int('extid')))
+            c.add_child(Node.string('p_name', uid_mapping[uid].get_str('name')))
+            c.add_child(Node.s32('exp', uid_mapping[uid].get_int('exp')))
+            c.add_child(Node.s32('customize', comment.data.get_int('customize')))
+            c.add_child(Node.s32('tid', comment.data.get_int('teamid')))
+            c.add_child(Node.string('t_name', comment.data.get_str('teamname')))
+            c.add_child(Node.string('lid', comment.data.get_str('lid')))
+            c.add_child(Node.string('s_name', lid_mapping[lid]))
+            c.add_child(Node.s8('pref', comment.data.get_int('prefecture')))
+            c.add_child(Node.s32('time', comment.timestamp))
+            c.add_child(Node.string('comment', comment.data.get_str('comment')))
+            c.add_child(Node.bool('is_tweet', comment.data.get_bool('tweet')))
+
+        for (uid, status) in statuses:
+            lid = ID.parse_machine_id(status.get_str('lid'))
+
+            # Look up external data for the request
+            if lid not in lid_mapping:
+                machine = self.get_machine_by_id(lid)
+                if machine is not None:
+                    lid_mapping[lid] = machine.name
+                else:
+                    lid_mapping[lid] = ''
+
+            s = Node.void('s')
+            statusnode.add_child(s)
+            s.add_child(Node.s32('uid', uid_mapping[uid].get_int('extid')))
+            s.add_child(Node.string('p_name', uid_mapping[uid].get_str('name')))
+            s.add_child(Node.s32('exp', uid_mapping[uid].get_int('exp')))
+            s.add_child(Node.s32('customize', status.get_int('customize')))
+            s.add_child(Node.s32('tid', uid_mapping[uid].get_int('team_id', -1)))
+            s.add_child(Node.string('t_name', uid_mapping[uid].get_str('team_name', '')))
+            s.add_child(Node.string('lid', status.get_str('lid')))
+            s.add_child(Node.string('s_name', lid_mapping[lid]))
+            s.add_child(Node.s8('pref', status.get_int('prefecture')))
+            s.add_child(Node.s32('time', status.get_int('time')))
+            s.add_child(Node.s8('status', status.get_int('status')))
+            s.add_child(Node.s8('stage', status.get_int('stage')))
+            s.add_child(Node.s32('mid', status.get_int('mid')))
+            s.add_child(Node.s8('ng', status.get_int('ng')))
+
+        return root
+
+    def handle_event_w_add_comment_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            # Anonymous comment
+            userid = UserID(0)
+
+        customize = request.child_value('customize')
+        lid = request.child_value('lid')
+        teamid = request.child_value('tid')
+        teamname = request.child_value('t_name')
+        prefecture = request.child_value('pref')
+        comment = request.child_value('comment')
+        is_tweet = request.child_value('is_tweet')
+
+        # Link comment to user's profile
+        self.data.local.user.put_time_based_achievement(
+            self.game,
+            self.version,
+            userid,
+            0,  # We never have an ID for this, since comments are add-only
+            'puzzle_comment',
+            {
+                'customize': customize,
+                'lid': lid,
+                'teamid': teamid,
+                'teamname': teamname,
+                'prefecture': prefecture,
+                'comment': comment,
+                'tweet': is_tweet,
+            },
+        )
+
+        return Node.void('event_w')
+
+    def handle_event_w_update_status_request(self, request: Node) -> Node:
+        # Update user status so puzzle comments can show it
+        extid = request.child_value('uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            customize = request.child_value('customize')
+            status = request.child_value('status')
+            stage = request.child_value('stage')
+            mid = request.child_value('mid')
+            ng = request.child_value('ng')
+            lid = request.child_value('lid')
+            prefecture = request.child_value('pref')
+
+            self.data.local.lobby.put_play_session_info(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'customize': customize,
+                    'status': status,
+                    'stage': stage,
+                    'mid': mid,
+                    'ng': ng,
+                    'lid': lid,
+                    'prefecture': prefecture,
+                },
+            )
+        return Node.void('event_w')
+
+    def handle_lobby_entry_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Create a lobby entry for this user
+        extid = request.child_value('e/uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            self.data.local.lobby.put_lobby(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'mid': request.child_value('e/mid'),
+                    'ng': request.child_value('e/ng'),
+                    'mopt': request.child_value('e/mopt'),
+                    'tid': request.child_value('e/tid'),
+                    'tn': request.child_value('e/tn'),
+                    'topt': request.child_value('e/topt'),
+                    'lid': request.child_value('e/lid'),
+                    'sn': request.child_value('e/sn'),
+                    'pref': request.child_value('e/pref'),
+                    'stg': request.child_value('e/stg'),
+                    'pside': request.child_value('e/pside'),
+                    'eatime': request.child_value('e/eatime'),
+                    'ga': request.child_value('e/ga'),
+                    'gp': request.child_value('e/gp'),
+                    'la': request.child_value('e/la'),
+                }
+            )
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            root.add_child(Node.s32('eid', lobby.get_int('id')))
+            e = Node.void('e')
+            root.add_child(e)
+            e.add_child(Node.s32('eid', lobby.get_int('id')))
+            e.add_child(Node.u16('mid', lobby.get_int('mid')))
+            e.add_child(Node.u8('ng', lobby.get_int('ng')))
+            e.add_child(Node.s32('uid', profile.get_int('extid')))
+            e.add_child(Node.string('pn', profile.get_str('name')))
+            e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+            e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+            e.add_child(Node.s16('mg', profile.get_int('mg')))
+            e.add_child(Node.s32('tid', lobby.get_int('tid')))
+            e.add_child(Node.string('tn', lobby.get_str('tn')))
+            e.add_child(Node.s32('topt', lobby.get_int('topt')))
+            e.add_child(Node.string('lid', lobby.get_str('lid')))
+            e.add_child(Node.string('sn', lobby.get_str('sn')))
+            e.add_child(Node.u8('pref', lobby.get_int('pref')))
+            e.add_child(Node.s8('stg', lobby.get_int('stg')))
+            e.add_child(Node.s8('pside', lobby.get_int('pside')))
+            e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+            e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+            e.add_child(Node.u16('gp', lobby.get_int('gp')))
+            e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+
+        return root
+
+    def handle_lobby_read_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Look up all lobbies matching the criteria specified
+        mg = request.child_value('m_grade')  # noqa: F841
+        extid = request.child_value('uid')
+        limit = request.child_value('max')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
+            for (user, lobby) in lobbies:
+                if limit <= 0:
+                    break
+
+                if user == userid:
+                    # If we have our own lobby, don't return it
+                    continue
+
+                profile = self.get_profile(user)
+                if profile is None:
+                    # No profile info, don't return this lobby
+                    continue
+
+                e = Node.void('e')
+                root.add_child(e)
+                e.add_child(Node.s32('eid', lobby.get_int('id')))
+                e.add_child(Node.u16('mid', lobby.get_int('mid')))
+                e.add_child(Node.u8('ng', lobby.get_int('ng')))
+                e.add_child(Node.s32('uid', profile.get_int('extid')))
+                e.add_child(Node.string('pn', profile.get_str('name')))
+                e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+                e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+                e.add_child(Node.s16('mg', profile.get_int('mg')))
+                e.add_child(Node.s32('tid', lobby.get_int('tid')))
+                e.add_child(Node.string('tn', lobby.get_str('tn')))
+                e.add_child(Node.s32('topt', lobby.get_int('topt')))
+                e.add_child(Node.string('lid', lobby.get_str('lid')))
+                e.add_child(Node.string('sn', lobby.get_str('sn')))
+                e.add_child(Node.u8('pref', lobby.get_int('pref')))
+                e.add_child(Node.s8('stg', lobby.get_int('stg')))
+                e.add_child(Node.s8('pside', lobby.get_int('pside')))
+                e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+                e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+                e.add_child(Node.u16('gp', lobby.get_int('gp')))
+                e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+
+                limit = limit - 1
+
+        return root
+
+    def handle_lobby_delete_request(self, request: Node) -> Node:
+        eid = request.child_value('eid')
+        self.data.local.lobby.destroy_lobby(eid)
+        return Node.void('lobby')
+
+    def handle_player_start_request(self, request: Node) -> Node:
+        # Add a dummy entry into the lobby setup so we can clean up on end play
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            self.data.local.lobby.put_play_session_info(
+                self.game,
+                self.version,
+                userid,
+                {}
+            )
+
+        root = Node.void('player')
+        root.add_child(Node.bool('is_suc', True))
+
+        unlock_music = Node.void('unlock_music')
+        root.add_child(unlock_music)
+        unlock_item = Node.void('unlock_item')
+        root.add_child(unlock_item)
+        item_lock_ctrl = Node.void('item_lock_ctrl')
+        root.add_child(item_lock_ctrl)
+
+        lincle_link_4 = Node.void('lincle_link_4')
+        root.add_child(lincle_link_4)
+        lincle_link_4.add_child(Node.u32('qpro', 0))
+        lincle_link_4.add_child(Node.u32('glass', 0))
+        lincle_link_4.add_child(Node.u32('treasure', 0))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_0', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_1', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_2', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_3', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_4', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_5', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_6', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_1', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_2', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_3', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_4', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_0', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_1', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_2', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_3', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_4', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_5', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_6', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0', False))
+        lincle_link_4.add_child(Node.bool('for_rb_1', False))
+        lincle_link_4.add_child(Node.bool('for_rb_2', False))
+        lincle_link_4.add_child(Node.bool('for_rb_3', False))
+        lincle_link_4.add_child(Node.bool('for_rb_4', False))
+        lincle_link_4.add_child(Node.bool('qproflg', False))
+        lincle_link_4.add_child(Node.bool('glassflg', False))
+        lincle_link_4.add_child(Node.bool('complete', False))
+
+        # Add event info
+        self.__add_event_info(root)
+
+        return root
+
+    def handle_player_delete_request(self, request: Node) -> Node:
+        return Node.void('player')
+
+    def handle_player_end_request(self, request: Node) -> Node:
+        # Destroy play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            # Kill any lingering lobbies by this user
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            if lobby is not None:
+                self.data.local.lobby.destroy_lobby(lobby.get_int('id'))
+            self.data.local.lobby.destroy_play_session_info(self.game, self.version, userid)
+
+        return Node.void('player')
+
+    def handle_player_read_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.get_profile_by_refid(refid)
+        if profile:
+            return profile
+        return Node.void('player')
+
+    def handle_player_write_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.put_profile_by_refid(refid, request)
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.s32('uid', 0))
+        else:
+            root.add_child(Node.s32('uid', profile.get_int('extid')))
+        root.add_child(Node.s32('time', Time.now()))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        statistics = self.get_play_statistics(userid)
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.s32('uid', profile.get_int('extid')))
+        base.add_child(Node.string('name', profile.get_str('name')))
+        base.add_child(Node.s16('icon_id', profile.get_int('icon')))
+        base.add_child(Node.s16('lv', profile.get_int('lvl')))
+        base.add_child(Node.s32('exp', profile.get_int('exp')))
+        base.add_child(Node.s16('mg', profile.get_int('mg')))
+        base.add_child(Node.s16('ap', profile.get_int('ap')))
+        base.add_child(Node.s32('pc', profile.get_int('pc')))
+        base.add_child(Node.s32('uattr', profile.get_int('uattr')))
+
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+
+        con = Node.void('con')
+        pdata.add_child(con)
+        con.add_child(Node.s32('day', today_count))
+        con.add_child(Node.s32('cnt', statistics.get_int('total_plays')))
+        con.add_child(Node.s32('total_cnt', statistics.get_int('total_plays')))
+        con.add_child(Node.s32('last', statistics.get_int('last_play_timestamp')))
+        con.add_child(Node.s32('now', Time.now()))
+
+        team = Node.void('team')
+        pdata.add_child(team)
+        team.add_child(Node.s32('id', profile.get_int('team_id', -1)))
+        team.add_child(Node.string('name', profile.get_str('team_name', '')))
+
+        custom = Node.void('custom')
+        customdict = profile.get_dict('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('s_gls', customdict.get_int('s_gls')))
+        custom.add_child(Node.u8('bgm_m', customdict.get_int('bgm_m')))
+        custom.add_child(Node.u8('st_f', customdict.get_int('st_f')))
+        custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
+        custom.add_child(Node.u8('st_bg_b', customdict.get_int('st_bg_b')))
+        custom.add_child(Node.u8('eff_e', customdict.get_int('eff_e')))
+        custom.add_child(Node.u8('se_s', customdict.get_int('se_s')))
+        custom.add_child(Node.u8('se_s_v', customdict.get_int('se_s_v')))
+        custom.add_child(Node.s16('last_music_id', customdict.get_int('last_music_id')))
+        custom.add_child(Node.u8('last_note_grade', customdict.get_int('last_note_grade')))
+        custom.add_child(Node.u8('sort_type', customdict.get_int('sort_type')))
+        custom.add_child(Node.u8('narrowdown_type', customdict.get_int('narrowdown_type')))
+        custom.add_child(Node.bool('is_begginer', customdict.get_bool('is_begginer')))  # Yes, this is spelled right
+        custom.add_child(Node.bool('is_tut', customdict.get_bool('is_tut')))
+        custom.add_child(Node.s16_array('symbol_chat_0', customdict.get_int_array('symbol_chat_0', 6)))
+        custom.add_child(Node.s16_array('symbol_chat_1', customdict.get_int_array('symbol_chat_1', 6)))
+        custom.add_child(Node.u8('gauge_style', customdict.get_int('gauge_style')))
+        custom.add_child(Node.u8('obj_shade', customdict.get_int('obj_shade')))
+        custom.add_child(Node.u8('obj_size', customdict.get_int('obj_size')))
+        custom.add_child(Node.s16_array('byword', customdict.get_int_array('byword', 2)))
+        custom.add_child(Node.bool_array('is_auto_byword', customdict.get_bool_array('is_auto_byword', 2)))
+        custom.add_child(Node.bool('is_tweet', customdict.get_bool('is_tweet')))
+        custom.add_child(Node.bool('is_link_twitter', customdict.get_bool('is_link_twitter')))
+        custom.add_child(Node.s16('mrec_type', customdict.get_int('mrec_type')))
+        custom.add_child(Node.s16('card_disp_type', customdict.get_int('card_disp_type')))
+        custom.add_child(Node.s16('tab_sel', customdict.get_int('tab_sel')))
+        custom.add_child(Node.s32_array('hidden_param', customdict.get_int_array('hidden_param', 20)))
+
+        released = Node.void('released')
+        pdata.add_child(released)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+            if game_config.get_bool('force_unlock_songs') and itemtype == 0:
+                # Don't echo unlocks when we're force unlocking, we'll do it later
+                continue
+
+            info = Node.void('info')
+            released.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u16('id', item.id))
+            info.add_child(Node.u16('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for songid in ids:
+                if ids[songid] == 0:
+                    continue
+
+                info = Node.void('info')
+                released.add_child(info)
+                info.add_child(Node.u8('type', 0))
+                info.add_child(Node.u16('id', songid))
+                info.add_child(Node.u16('param', ids[songid]))
+
+        # Scores
+        record = Node.void('record')
+        pdata.add_child(record)
+
+        for score in scores:
+            rec = Node.void('rec')
+            record.add_child(rec)
+            rec.add_child(Node.u16('mid', score.id))
+            rec.add_child(Node.u8('ng', score.chart))
+            rec.add_child(Node.s32('point', score.data.get_dict('stats').get_int('earned_points')))
+            rec.add_child(Node.s32('played_time', score.timestamp))
+
+            mrec_0 = Node.void('mrec_0')
+            rec.add_child(mrec_0)
+            mrec_0.add_child(Node.s32('win', score.data.get_dict('stats').get_int('win')))
+            mrec_0.add_child(Node.s32('lose', score.data.get_dict('stats').get_int('lose')))
+            mrec_0.add_child(Node.s32('draw', score.data.get_dict('stats').get_int('draw')))
+            mrec_0.add_child(Node.u8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'), score.data.get_int('combo_type'))))
+            mrec_0.add_child(Node.s16('ar', int(score.data.get_int('achievement_rate') / 10)))
+            mrec_0.add_child(Node.s32('bs', score.points))
+            mrec_0.add_child(Node.s16('mc', score.data.get_int('combo')))
+            mrec_0.add_child(Node.s16('bmc', score.data.get_int('miss_count')))
+
+            mrec_1 = Node.void('mrec_1')
+            rec.add_child(mrec_1)
+            mrec_1.add_child(Node.s32('win', 0))
+            mrec_1.add_child(Node.s32('lose', 0))
+            mrec_1.add_child(Node.s32('draw', 0))
+            mrec_1.add_child(Node.u8('ct', 0))
+            mrec_1.add_child(Node.s16('ar', 0))
+            mrec_1.add_child(Node.s32('bs', 0))
+            mrec_1.add_child(Node.s16('mc', 0))
+            mrec_1.add_child(Node.s16('bmc', -1))
+
+        # Comment (seems unused?)
+        pdata.add_child(Node.string('cmnt', ''))
+
+        # Rivals
+        rival = Node.void('rival')
+        pdata.add_child(rival)
+
+        slotid = 0
+        for link in links:
+            if link.type != 'rival':
+                continue
+
+            rprofile = self.get_profile(link.other_userid)
+            if rprofile is None:
+                continue
+
+            r = Node.void('r')
+            rival.add_child(r)
+            r.add_child(Node.u8('slot_id', slotid))
+            r.add_child(Node.string('name', rprofile.get_str('name')))
+            r.add_child(Node.s32('id', rprofile.get_int('extid')))
+            r.add_child(Node.bool('friend', True))
+            r.add_child(Node.bool('locked', False))
+            r.add_child(Node.s32('rc', 0))
+            slotid = slotid + 1
+
+        # Glass points
+        glass = Node.void('glass')
+        pdata.add_child(glass)
+
+        for item in achievements:
+            if item.type != 'glass':
+                continue
+
+            g = Node.void('g')
+            glass.add_child(g)
+            g.add_child(Node.s32('id', item.id))
+            g.add_child(Node.s32('exp', item.data.get_int('exp')))
+
+        # Favorite music
+        fav_music_slot = Node.void('fav_music_slot')
+        pdata.add_child(fav_music_slot)
+
+        for item in achievements:
+            if item.type != 'music':
+                continue
+
+            slot = Node.void('slot')
+            fav_music_slot.add_child(slot)
+            slot.add_child(Node.u8('slot_id', item.id))
+            slot.add_child(Node.s16('music_id', item.data.get_int('music_id')))
+
+        narrow_down = Node.void('narrow_down')
+        pdata.add_child(narrow_down)
+        narrow_down.add_child(Node.s32_array('adv_param', [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        game_config = self.get_game_config()
+        newprofile = copy.deepcopy(oldprofile)
+
+        newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('lid')))
+        newprofile.replace_str('name', request.child_value('pdata/base/name'))
+        newprofile.replace_int('icon', request.child_value('pdata/base/icon_id'))
+        newprofile.replace_int('lvl', request.child_value('pdata/base/lv'))
+        newprofile.replace_int('exp', request.child_value('pdata/base/exp'))
+        newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
+        newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
+        newprofile.replace_int('pc', request.child_value('pdata/base/pc'))
+        newprofile.replace_int('uattr', request.child_value('pdata/base/uattr'))
+
+        customdict = newprofile.get_dict('custom')
+        custom = request.child('pdata/custom')
+        if custom:
+            customdict.replace_int('s_gls', custom.child_value('s_gls'))
+            customdict.replace_int('bgm_m', custom.child_value('bgm_m'))
+            customdict.replace_int('st_f', custom.child_value('st_f'))
+            customdict.replace_int('st_bg', custom.child_value('st_bg'))
+            customdict.replace_int('st_bg_b', custom.child_value('st_bg_b'))
+            customdict.replace_int('eff_e', custom.child_value('eff_e'))
+            customdict.replace_int('se_s', custom.child_value('se_s'))
+            customdict.replace_int('se_s_v', custom.child_value('se_s_v'))
+            customdict.replace_int('last_music_id', custom.child_value('last_music_id'))
+            customdict.replace_int('last_note_grade', custom.child_value('last_note_grade'))
+            customdict.replace_int('sort_type', custom.child_value('sort_type'))
+            customdict.replace_int('narrowdown_type', custom.child_value('narrowdown_type'))
+            customdict.replace_bool('is_begginer', custom.child_value('is_begginer'))  # Yes, this is spelled right
+            customdict.replace_bool('is_tut', custom.child_value('is_tut'))
+            customdict.replace_int_array('symbol_chat_0', 6, custom.child_value('symbol_chat_0'))
+            customdict.replace_int_array('symbol_chat_1', 6, custom.child_value('symbol_chat_1'))
+            customdict.replace_int('gauge_style', custom.child_value('gauge_style'))
+            customdict.replace_int('obj_shade', custom.child_value('obj_shade'))
+            customdict.replace_int('obj_size', custom.child_value('obj_size'))
+            customdict.replace_int_array('byword', 2, custom.child_value('byword'))
+            customdict.replace_bool_array('is_auto_byword', 2, custom.child_value('is_auto_byword'))
+            customdict.replace_bool('is_tweet', custom.child_value('is_tweet'))
+            customdict.replace_bool('is_link_twitter', custom.child_value('is_link_twitter'))
+            customdict.replace_int('mrec_type', custom.child_value('mrec_type'))
+            customdict.replace_int('card_disp_type', custom.child_value('card_disp_type'))
+            customdict.replace_int('tab_sel', custom.child_value('tab_sel'))
+            customdict.replace_int_array('hidden_param', 20, custom.child_value('hidden_param'))
+        newprofile.replace_dict('custom', customdict)
+
+        # Music unlocks and other stuff
+        released = request.child('pdata/released')
+        if released:
+            for child in released.children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                if game_config.get_bool('force_unlock_songs') and item_type == 0:
+                    # Don't save unlocks when we're force unlocking
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Grab any new records set during this play session. Reflec Beat Limelight only sends
+        # the top record back for songs that were played at least once during the session.
+        # Note that it sends the top record, so if you play the song twice, it will return
+        # only one record. Also, if you get a lower score than a previous try, it will return
+        # the previous try. So, we must also look at the battle log for the actual play scores,
+        # and combine the data if we can.
+        savedrecords: Dict[int, Dict[int, Dict[str, int]]] = {}
+        songplays = request.child('pdata/record')
+        if songplays:
+            for child in songplays.children:
+                if child.name != 'rec':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+
+                # These don't get sent with the battle logs, so we try to construct
+                # the values here.
+                if songid not in savedrecords:
+                    savedrecords[songid] = {}
+                savedrecords[songid][chart] = {
+                    'achievement_rate': child.child_value('mrec_0/ar') * 10,
+                    'points': child.child_value('mrec_0/bs'),
+                    'combo': child.child_value('mrec_0/mc'),
+                    'miss_count': child.child_value('mrec_0/bmc'),
+                    'win': child.child_value('mrec_0/win'),
+                    'lose': child.child_value('mrec_0/lose'),
+                    'draw': child.child_value('mrec_0/draw'),
+                    'earned_points': child.child_value('point'),
+                }
+
+        # Now, see the actual battles that were played. If we can, unify the data with a record.
+        # We only do that when the record achievement rate and score matches the battle achievement
+        # rate and score, so we know for a fact that that record was generated by this battle.
+        battlelogs = request.child('pdata/blog')
+        if battlelogs:
+            for child in battlelogs.children:
+                if child.name != 'log':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+
+                clear_type = child.child_value('myself/ct')
+                achievement_rate = child.child_value('myself/ar') * 10
+                points = child.child_value('myself/s')
+
+                clear_type, combo_type = self.__game_to_db_clear_type(clear_type)
+
+                combo = None
+                miss_count = -1
+                stats = None
+
+                if songid in savedrecords:
+                    if chart in savedrecords[songid]:
+                        data = savedrecords[songid][chart]
+
+                        if (
+                            data['achievement_rate'] == achievement_rate and
+                            data['points'] == points
+                        ):
+                            # This is the same record! Use the stats from it to update our
+                            # internal representation.
+                            combo = data['combo']
+                            miss_count = data['miss_count']
+                            stats = {
+                                'win': data['win'],
+                                'lose': data['lose'],
+                                'draw': data['draw'],
+                                'earned_points': data['earned_points'],
+                            }
+
+                self.update_score(
+                    userid,
+                    songid,
+                    chart,
+                    points,
+                    achievement_rate,
+                    clear_type,
+                    combo_type,
+                    miss_count,
+                    combo=combo,
+                    stats=stats,
+                )
+
+        # Keep track of glass points so unlocks work
+        glass = request.child('pdata/glass')
+        if glass:
+            for child in glass.children:
+                if child.name != 'g':
+                    continue
+
+                gid = child.child_value('id')
+                exp = child.child_value('exp')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    gid,
+                    'glass',
+                    {
+                        'exp': exp,
+                    },
+                )
+
+        # Keep track of favorite music selections
+        fav_music_slot = request.child('pdata/fav_music_slot')
+        if fav_music_slot:
+            for child in fav_music_slot.children:
+                if child.name != 'slot':
+                    continue
+
+                slot_id = child.child_value('slot_id')
+                music_id = child.child_value('music_id')
+                if music_id == -1:
+                    # Delete this favorite
+                    self.data.local.user.destroy_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        slot_id,
+                        'music',
+                    )
+                else:
+                    # Add/update this favorite
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        slot_id,
+                        'music',
+                        {
+                            'music_id': music_id,
+                        },
+                    )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/reflecbeat.py b/bemani/backend/reflec/reflecbeat.py
new file mode 100644
index 0000000..23efaed
--- /dev/null
+++ b/bemani/backend/reflec/reflecbeat.py
@@ -0,0 +1,543 @@
+import copy
+from typing import Any, Dict, Tuple
+
+from bemani.backend.reflec.base import ReflecBeatBase
+
+from bemani.common import ValidatedDict, VersionConstants, ID, Time
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class ReflecBeat(ReflecBeatBase):
+
+    name = "REFLEC BEAT"
+    version = VersionConstants.REFLEC_BEAT
+
+    # Clear types according to the game
+    GAME_CLEAR_TYPE_NO_PLAY = 0
+    GAME_CLEAR_TYPE_PLAYED = 2
+    GAME_CLEAR_TYPE_FULL_COMBO = 3
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+            'ints': [],
+        }
+
+    def __db_to_game_clear_type(self, db_clear_type: int, db_combo_type: int) -> int:
+        if db_clear_type == self.CLEAR_TYPE_NO_PLAY:
+            return self.GAME_CLEAR_TYPE_NO_PLAY
+        if db_clear_type == self.CLEAR_TYPE_FAILED:
+            return self.GAME_CLEAR_TYPE_PLAYED
+        if db_clear_type in [
+            self.CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_HARD_CLEARED,
+            self.CLEAR_TYPE_S_HARD_CLEARED,
+        ]:
+            if db_combo_type in [
+                self.COMBO_TYPE_NONE,
+                self.COMBO_TYPE_ALMOST_COMBO,
+            ]:
+                return self.GAME_CLEAR_TYPE_PLAYED
+            if db_combo_type in [
+                self.COMBO_TYPE_FULL_COMBO,
+                self.COMBO_TYPE_FULL_COMBO_ALL_JUST,
+            ]:
+                return self.GAME_CLEAR_TYPE_FULL_COMBO
+
+            raise Exception('Invalid db_combo_type {}'.format(db_combo_type))
+        raise Exception('Invalid db_clear_type {}'.format(db_clear_type))
+
+    def __game_to_db_clear_type(self, game_clear_type: int, game_achievement_rate: int) -> Tuple[int, int]:
+        if game_clear_type == self.GAME_CLEAR_TYPE_NO_PLAY:
+            return (self.CLEAR_TYPE_NO_PLAY, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_PLAYED:
+            if game_achievement_rate >= 7000:
+                return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_NONE)
+            else:
+                return (self.CLEAR_TYPE_FAILED, self.COMBO_TYPE_NONE)
+        if game_clear_type == self.GAME_CLEAR_TYPE_FULL_COMBO:
+            return (self.CLEAR_TYPE_CLEARED, self.COMBO_TYPE_FULL_COMBO)
+
+        raise Exception('Invalid game_clear_type {}'.format(game_clear_type))
+
+    def handle_log_pcb_status_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_log_opsetting_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_log_play_request(self, request: Node) -> Node:
+        return Node.void('log')
+
+    def handle_pcbinfo_get_request(self, request: Node) -> Node:
+        shop_id = ID.parse_machine_id(request.child_value('lid'))
+        machine = self.get_machine_by_id(shop_id)
+        if machine is not None:
+            machine_name = machine.name
+            close = machine.data.get_bool('close')
+            hour = machine.data.get_int('hour')
+            minute = machine.data.get_int('minute')
+            pref = machine.data.get_int('pref', 51)
+        else:
+            machine_name = ''
+            close = False
+            hour = 0
+            minute = 0
+            pref = 51
+
+        root = Node.void('pcbinfo')
+        info = Node.void('info')
+        root.add_child(info)
+
+        info.add_child(Node.string('name', machine_name))
+        info.add_child(Node.s16('pref', pref))
+        info.add_child(Node.bool('close', close))
+        info.add_child(Node.u8('hour', hour))
+        info.add_child(Node.u8('min', minute))
+
+        return root
+
+    def handle_pcbinfo_set_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('info/name'))
+        self.update_machine_data({
+            'close': request.child_value('info/close'),
+            'hour': request.child_value('info/hour'),
+            'minute': request.child_value('info/min'),
+            'pref': request.child_value('info/pref'),
+        })
+        return Node.void('pcbinfo')
+
+    def __add_event_info(self, request: Node) -> None:
+        events: Dict[int, int] = {}
+
+        for (eventid, phase) in events.items():
+            data = Node.void('data')
+            request.add_child(data)
+            data.add_child(Node.s32('type', -1))
+            data.add_child(Node.s32('value', -1))
+
+    def handle_sysinfo_get_request(self, request: Node) -> Node:
+        root = Node.void('sysinfo')
+        trd = Node.void('trd')
+        root.add_child(trd)
+
+        # Add event info
+        self.__add_event_info(trd)
+
+        return root
+
+    def handle_sysinfo_fan_request(self, request: Node) -> Node:
+        sysinfo = Node.void('sysinfo')
+        sysinfo.add_child(Node.u8('pref', 51))
+        sysinfo.add_child(Node.string('lid', request.child_value('lid')))
+        return sysinfo
+
+    def handle_lobby_entry_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+
+        # Create a lobby entry for this user
+        extid = request.child_value('e/uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            self.data.local.lobby.put_lobby(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'mid': request.child_value('e/mid'),
+                    'ng': request.child_value('e/ng'),
+                    'lid': request.child_value('e/lid'),
+                    'sn': request.child_value('e/sn'),
+                    'pref': request.child_value('e/pref'),
+                    'ga': request.child_value('e/ga'),
+                    'gp': request.child_value('e/gp'),
+                    'la': request.child_value('e/la'),
+                }
+            )
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            root.add_child(Node.s32('eid', lobby.get_int('id')))
+            e = Node.void('e')
+            root.add_child(e)
+            e.add_child(Node.s32('eid', lobby.get_int('id')))
+            e.add_child(Node.u16('mid', lobby.get_int('mid')))
+            e.add_child(Node.u8('ng', lobby.get_int('ng')))
+            e.add_child(Node.s32('uid', profile.get_int('extid')))
+            e.add_child(Node.string('pn', profile.get_str('name')))
+            e.add_child(Node.s32('exp', profile.get_int('exp')))
+            e.add_child(Node.u8('mg', profile.get_int('mg')))
+            e.add_child(Node.s32('tid', lobby.get_int('tid')))
+            e.add_child(Node.string('tn', lobby.get_str('tn')))
+            e.add_child(Node.string('lid', lobby.get_str('lid')))
+            e.add_child(Node.string('sn', lobby.get_str('sn')))
+            e.add_child(Node.u8('pref', lobby.get_int('pref')))
+            e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+            e.add_child(Node.u16('gp', lobby.get_int('gp')))
+            e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+
+        return root
+
+    def handle_lobby_read_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+
+        # Look up all lobbies matching the criteria specified
+        mg = request.child_value('m_grade')  # noqa: F841
+        extid = request.child_value('uid')
+        limit = request.child_value('max')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
+            for (user, lobby) in lobbies:
+                if limit <= 0:
+                    break
+
+                if user == userid:
+                    # If we have our own lobby, don't return it
+                    continue
+
+                profile = self.get_profile(user)
+                if profile is None:
+                    # No profile info, don't return this lobby
+                    continue
+
+                e = Node.void('e')
+                root.add_child(e)
+                e.add_child(Node.s32('eid', lobby.get_int('id')))
+                e.add_child(Node.u16('mid', lobby.get_int('mid')))
+                e.add_child(Node.u8('ng', lobby.get_int('ng')))
+                e.add_child(Node.s32('uid', profile.get_int('extid')))
+                e.add_child(Node.string('pn', profile.get_str('name')))
+                e.add_child(Node.s32('exp', profile.get_int('exp')))
+                e.add_child(Node.u8('mg', profile.get_int('mg')))
+                e.add_child(Node.s32('tid', lobby.get_int('tid')))
+                e.add_child(Node.string('tn', lobby.get_str('tn')))
+                e.add_child(Node.string('lid', lobby.get_str('lid')))
+                e.add_child(Node.string('sn', lobby.get_str('sn')))
+                e.add_child(Node.u8('pref', lobby.get_int('pref')))
+                e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+                e.add_child(Node.u16('gp', lobby.get_int('gp')))
+                e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+
+                limit = limit - 1
+
+        return root
+
+    def handle_lobby_delete_request(self, request: Node) -> Node:
+        eid = request.child_value('eid')
+        self.data.local.lobby.destroy_lobby(eid)
+        return Node.void('lobby')
+
+    def handle_player_start_request(self, request: Node) -> Node:
+        # Add a dummy entry into the lobby setup so we can clean up on end play
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            self.data.local.lobby.put_play_session_info(
+                self.game,
+                self.version,
+                userid,
+                {}
+            )
+
+        root = Node.void('player')
+        root.add_child(Node.bool('is_suc', True))
+
+        # Add event info
+        self.__add_event_info(root)
+
+        return root
+
+    def handle_player_delete_request(self, request: Node) -> Node:
+        return Node.void('player')
+
+    def handle_player_end_request(self, request: Node) -> Node:
+        # Destroy play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            # Kill any lingering lobbies by this user
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            if lobby is not None:
+                self.data.local.lobby.destroy_lobby(lobby.get_int('id'))
+            self.data.local.lobby.destroy_play_session_info(self.game, self.version, userid)
+
+        return Node.void('player')
+
+    def handle_player_read_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.get_profile_by_refid(refid)
+        if profile:
+            return profile
+        return Node.void('player')
+
+    def handle_player_write_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.put_profile_by_refid(refid, request)
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.s32('uid', 0))
+        else:
+            root.add_child(Node.s32('uid', profile.get_int('extid')))
+        root.add_child(Node.s32('time', Time.now()))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        statistics = self.get_play_statistics(userid)
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.s32('uid', profile.get_int('extid')))
+        base.add_child(Node.string('name', profile.get_str('name')))
+        base.add_child(Node.s16('lv', profile.get_int('lvl')))
+        base.add_child(Node.s32('exp', profile.get_int('exp')))
+        base.add_child(Node.s16('mg', profile.get_int('mg')))
+        base.add_child(Node.s16('ap', profile.get_int('ap')))
+        base.add_child(Node.s32('flag', profile.get_int('flag')))
+
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+
+        con = Node.void('con')
+        pdata.add_child(con)
+        con.add_child(Node.s32('day', today_count))
+        con.add_child(Node.s32('cnt', statistics.get_int('total_plays')))
+        con.add_child(Node.s32('last', statistics.get_int('last_play_timestamp')))
+        con.add_child(Node.s32('now', Time.now()))
+
+        team = Node.void('team')
+        pdata.add_child(team)
+        team.add_child(Node.s32('id', -1))
+        team.add_child(Node.string('name', ''))
+
+        custom = Node.void('custom')
+        customdict = profile.get_dict('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('bgm_m', customdict.get_int('bgm_m')))
+        custom.add_child(Node.u8('st_f', customdict.get_int('st_f')))
+        custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
+        custom.add_child(Node.u8('st_bg_b', customdict.get_int('st_bg_b')))
+        custom.add_child(Node.u8('eff_e', customdict.get_int('eff_e')))
+        custom.add_child(Node.u8('se_s', customdict.get_int('se_s')))
+        custom.add_child(Node.u8('se_s_v', customdict.get_int('se_s_v')))
+
+        released = Node.void('released')
+        pdata.add_child(released)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+            if game_config.get_bool('force_unlock_songs') and itemtype == 0:
+                # Don't echo unlocks when we're force unlocking, we'll do it later
+                continue
+
+            info = Node.void('info')
+            released.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u16('id', item.id))
+
+        if game_config.get_bool('force_unlock_songs'):
+            songs = {song.id for song in self.data.local.music.get_all_songs(self.game, self.version)}
+
+            for songid in songs:
+                info = Node.void('info')
+                released.add_child(info)
+                info.add_child(Node.u8('type', 0))
+                info.add_child(Node.u16('id', songid))
+
+        # Scores
+        record = Node.void('record')
+        pdata.add_child(record)
+
+        for score in scores:
+            rec = Node.void('rec')
+            record.add_child(rec)
+            rec.add_child(Node.u16('mid', score.id))
+            rec.add_child(Node.u8('ng', score.chart))
+            rec.add_child(Node.s32('win', score.data.get_dict('stats').get_int('win')))
+            rec.add_child(Node.s32('lose', score.data.get_dict('stats').get_int('lose')))
+            rec.add_child(Node.s32('draw', score.data.get_dict('stats').get_int('draw')))
+            rec.add_child(Node.u8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'), score.data.get_int('combo_type'))))
+            rec.add_child(Node.s16('ar', int(score.data.get_int('achievement_rate') / 10)))
+            rec.add_child(Node.s16('bs', score.points))
+            rec.add_child(Node.s16('mc', score.data.get_int('combo')))
+            rec.add_child(Node.s16('bmc', score.data.get_int('miss_count')))
+
+        # In original ReflecBeat, the entire battle log was returned for each battle.
+        # We don't support storing all of that info, so don't return anything here.
+        blog = Node.void('blog')
+        pdata.add_child(blog)
+
+        # Comment (seems unused?)
+        pdata.add_child(Node.string('cmnt', ''))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        game_config = self.get_game_config()
+        newprofile = copy.deepcopy(oldprofile)
+
+        newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('lid')))
+        newprofile.replace_str('name', request.child_value('pdata/base/name'))
+        newprofile.replace_int('lvl', request.child_value('pdata/base/lv'))
+        newprofile.replace_int('exp', request.child_value('pdata/base/exp'))
+        newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
+        newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
+        newprofile.replace_int('flag', request.child_value('pdata/base/flag'))
+
+        customdict = newprofile.get_dict('custom')
+        custom = request.child('pdata/custom')
+        if custom:
+            customdict.replace_int('bgm_m', custom.child_value('bgm_m'))
+            customdict.replace_int('st_f', custom.child_value('st_f'))
+            customdict.replace_int('st_bg', custom.child_value('st_bg'))
+            customdict.replace_int('st_bg_b', custom.child_value('st_bg_b'))
+            customdict.replace_int('eff_e', custom.child_value('eff_e'))
+            customdict.replace_int('se_s', custom.child_value('se_s'))
+            customdict.replace_int('se_s_v', custom.child_value('se_s_v'))
+        newprofile.replace_dict('custom', customdict)
+
+        # Music unlocks and other stuff
+        released = request.child('pdata/released')
+        if released:
+            for child in released.children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                if game_config.get_bool('force_unlock_songs') and item_type == 0:
+                    # Don't save unlocks when we're force unlocking
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {},
+                )
+
+        # Grab any new records set during this play session. Reflec Beat original only sends
+        # the top record back for songs that were played at least once during the session.
+        # Note that it sends the top record, so if you play the song twice, it will return
+        # only one record. Also, if you get a lower score than a previous try, it will return
+        # the previous try. So, we must also look at the battle log for the actual play scores,
+        # and combine the data if we can.
+        savedrecords: Dict[int, Dict[int, Dict[str, int]]] = {}
+        songplays = request.child('pdata/record')
+        if songplays:
+            for child in songplays.children:
+                if child.name != 'rec':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+
+                # These don't get sent with the battle logs, so we try to construct
+                # the values here.
+                if songid not in savedrecords:
+                    savedrecords[songid] = {}
+                savedrecords[songid][chart] = {
+                    'achievement_rate': child.child_value('ar') * 10,
+                    'points': child.child_value('bs'),
+                    'combo': child.child_value('mc'),
+                    'miss_count': child.child_value('bmc'),
+                    'win': child.child_value('win'),
+                    'lose': child.child_value('lose'),
+                    'draw': child.child_value('draw'),
+                }
+
+        # Now, see the actual battles that were played. If we can, unify the data with a record.
+        # We only do that when the record achievement rate and score matches the battle achievement
+        # rate and score, so we know for a fact that that record was generated by this battle.
+        battlelogs = request.child('pdata/blog')
+        if battlelogs:
+            for child in battlelogs.children:
+                if child.name != 'log':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+
+                clear_type = child.child_value('myself/ct')
+                achievement_rate = child.child_value('myself/ar') * 10
+                points = child.child_value('myself/s')
+
+                clear_type, combo_type = self.__game_to_db_clear_type(clear_type, achievement_rate)
+
+                combo = None
+                miss_count = -1
+                stats = None
+
+                if songid in savedrecords:
+                    if chart in savedrecords[songid]:
+                        data = savedrecords[songid][chart]
+
+                        if (
+                            data['achievement_rate'] == achievement_rate and
+                            data['points'] == points
+                        ):
+                            # This is the same record! Use the stats from it to update our
+                            # internal representation.
+                            combo = data['combo']
+                            miss_count = data['miss_count']
+                            stats = {
+                                'win': data['win'],
+                                'lose': data['lose'],
+                                'draw': data['draw'],
+                            }
+
+                self.update_score(
+                    userid,
+                    songid,
+                    chart,
+                    points,
+                    achievement_rate,
+                    clear_type,
+                    combo_type,
+                    miss_count,
+                    combo=combo,
+                    stats=stats,
+                )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/volzza.py b/bemani/backend/reflec/volzza.py
new file mode 100644
index 0000000..0d1afac
--- /dev/null
+++ b/bemani/backend/reflec/volzza.py
@@ -0,0 +1,835 @@
+import copy
+from typing import Any, Dict, List, Optional
+
+from bemani.backend.reflec.base import ReflecBeatBase
+from bemani.backend.reflec.volzzabase import ReflecBeatVolzzaBase
+from bemani.backend.reflec.groovin import ReflecBeatGroovin
+
+from bemani.common import ValidatedDict, VersionConstants, ID, Time
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class ReflecBeatVolzza(ReflecBeatVolzzaBase):
+
+    name = "REFLEC BEAT VOLZZA"
+    version = VersionConstants.REFLEC_BEAT_VOLZZA
+
+    def previous_version(self) -> Optional[ReflecBeatBase]:
+        return ReflecBeatGroovin(self.data, self.config, self.model)
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+            'ints': [],
+        }
+
+    def _add_event_info(self, root: Node) -> None:
+        event_ctrl = Node.void('event_ctrl')
+        root.add_child(event_ctrl)
+        # Contains zero or more nodes like:
+        # <data>
+        #     <type __type="s32">any</type>
+        #     <index __type="s32">any</phase>
+        #     <value __type="s32">any</phase>
+        #     <value2 __type="s32">any</phase>
+        #     <start_time __type="s32">any</phase>
+        #     <end_time __type="s32">any</phase>
+        # </data>
+
+        item_lock_ctrl = Node.void('item_lock_ctrl')
+        root.add_child(item_lock_ctrl)
+        # Contains zero or more nodes like:
+        # <item>
+        #     <type __type="u8">any</type>
+        #     <id __type="u16">any</id>
+        #     <param __type="u16">0-3</param>
+        # </item>
+
+    def handle_player_rb5_player_read_score_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            scores: List[Score] = []
+        else:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        record = Node.void('record')
+        pdata.add_child(record)
+
+        for score in scores:
+            rec = Node.void('rec')
+            record.add_child(rec)
+            rec.add_child(Node.s16('mid', score.id))
+            rec.add_child(Node.s8('ntgrd', score.chart))
+            rec.add_child(Node.s32('pc', score.plays))
+            rec.add_child(Node.s8('ct', self._db_to_game_clear_type(score.data.get_int('clear_type'))))
+            rec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
+            rec.add_child(Node.s16('scr', score.points))
+            rec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
+            rec.add_child(Node.s16(
+                'param',
+                self._db_to_game_combo_type(score.data.get_int('combo_type')) + score.data.get_int('param'),
+            ))
+            rec.add_child(Node.s32('bscrt', score.timestamp))
+            rec.add_child(Node.s32('bart', score.data.get_int('best_achievement_rate_time')))
+            rec.add_child(Node.s32('bctt', score.data.get_int('best_clear_type_time')))
+            rec.add_child(Node.s32('bmst', score.data.get_int('best_miss_count_time')))
+            rec.add_child(Node.s32('time', score.data.get_int('last_played_time')))
+            rec.add_child(Node.s32('k_flag', score.data.get_int('kflag')))
+
+        return root
+
+    def handle_player_rb5_player_read_rival_score_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        songid = request.child_value('music_id')
+        chart = request.child_value('note_grade')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            score = None
+            profile = None
+        else:
+            score = self.data.remote.music.get_score(self.game, self.version, userid, songid, chart)
+            profile = self.get_any_profile(userid)
+
+        root = Node.void('player')
+        if score is not None and profile is not None:
+            player_select_score = Node.void('player_select_score')
+            root.add_child(player_select_score)
+
+            player_select_score.add_child(Node.s32('user_id', extid))
+            player_select_score.add_child(Node.string('name', profile.get_str('name')))
+            player_select_score.add_child(Node.s32('m_score', score.points))
+            player_select_score.add_child(Node.s32('m_scoreTime', score.timestamp))
+            player_select_score.add_child(Node.s16('m_iconID', profile.get_dict('config').get_int('icon_id')))
+        return root
+
+    def handle_player_rb5_player_read_rival_ranking_data_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        root = Node.void('player')
+        rival_data = Node.void('rival_data')
+        root.add_child(rival_data)
+
+        if userid is not None:
+            links = self.data.local.user.get_links(self.game, self.version, userid)
+            for link in links:
+                if link.type != 'rival':
+                    continue
+
+                rprofile = self.get_profile(link.other_userid)
+                if rprofile is None:
+                    continue
+
+                rl = Node.void('rl')
+                rival_data.add_child(rl)
+                rl.add_child(Node.s32('uid', rprofile.get_int('extid')))
+                rl.add_child(Node.string('nm', rprofile.get_str('name')))
+                rl.add_child(Node.s16('ic', rprofile.get_dict('config').get_int('icon_id')))
+
+                scores = self.data.remote.music.get_scores(self.game, self.version, link.other_userid)
+                scores_by_musicid: Dict[int, List[Score]] = {}
+                for score in scores:
+                    if score.id not in scores_by_musicid:
+                        scores_by_musicid[score.id] = [None, None, None, None]
+                    scores_by_musicid[score.id][score.chart] = score
+
+                for (mid, scores) in scores_by_musicid.items():
+                    points = [
+                        score.points << 32 if score is not None else 0
+                        for score in scores
+                    ]
+                    timestamps = [
+                        score.timestamp if score is not None else 0
+                        for score in scores
+                    ]
+
+                    sl = Node.void('sl')
+                    rl.add_child(sl)
+                    sl.add_child(Node.s16('mid', mid))
+                    # Score, but shifted left 32 bits for no reason
+                    sl.add_child(Node.u64_array('m', points))
+                    # Timestamp of the clear
+                    sl.add_child(Node.u64_array('t', timestamps))
+
+        return root
+
+    def handle_player_rb5_player_read_rank_request(self, request: Node) -> Node:
+        # This gives us a 6-integer array mapping to user scores for the following:
+        # [total score, basic chart score, medium chart score, hard chart score,
+        # special chart score]. It also returns the previous rank, but this is
+        # not used in-game as far as I can tell.
+        current_scores = request.child_value('sc')
+        current_minigame_score = request.child_value('mg_sc')
+
+        # First, grab all scores on the network for this version.
+        all_scores = self.data.remote.music.get_all_scores(self.game, self.version)
+
+        # Now grab all participating users that had scores
+        all_users = {userid for (userid, score) in all_scores}
+
+        # Now, group the scores by user, so we can add up the totals, only including
+        # scores where the user at least cleared the song.
+        scores_by_user = {
+            userid: [
+                score for (uid, score) in all_scores
+                if uid == userid and score.data.get_int('clear_type') >= self.CLEAR_TYPE_CLEARED]
+            for userid in all_users
+        }
+
+        # Now grab all user profiles for this game
+        all_profiles = {
+            profile[0]: profile[1] for profile in
+            self.data.remote.user.get_all_profiles(self.game, self.version)
+        }
+
+        # Now, sum up the scores into the five categories that the game expects.
+        total_scores = sorted(
+            [
+                sum([score.points for score in scores])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        basic_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_BASIC])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        medium_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_MEDIUM])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        hard_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_HARD])
+                for userid, scores in scores_by_user.items()
+            ],
+        )
+        special_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_SPECIAL])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        minigame_scores = sorted(
+            [
+                all_profiles.get(userid, ValidatedDict()).get_int('mgsc')
+                for userid in all_users
+            ],
+            reverse=True,
+        )
+
+        # Guarantee that a zero score is at the end of every list, so that it makes
+        # the algorithm for figuring out place have no edge case.
+        total_scores.append(0)
+        basic_scores.append(0)
+        medium_scores.append(0)
+        hard_scores.append(0)
+        special_scores.append(0)
+        minigame_scores.append(0)
+
+        # Now, figure out where we fit based on the scores sent from the game.
+        user_place = [1, 1, 1, 1, 1, 1]
+        which_score = [
+            total_scores,
+            basic_scores,
+            medium_scores,
+            hard_scores,
+            special_scores,
+            minigame_scores,
+        ]
+        earned_scores = current_scores + [current_minigame_score]
+        for i in range(len(user_place)):
+            earned_score = earned_scores[i]
+            scores = which_score[i]
+            for score in scores:
+                if earned_score >= score:
+                    break
+                user_place[i] = user_place[i] + 1
+
+        # Separate out minigame rank from scores
+        minigame_rank = user_place[-1]
+        user_place = user_place[:-1]
+
+        root = Node.void('player')
+
+        # Populate current ranking.
+        tbs = Node.void('tbs')
+        root.add_child(tbs)
+        tbs.add_child(Node.s32_array('new_rank', user_place))
+        tbs.add_child(Node.s32_array('old_rank', [-1, -1, -1, -1, -1]))
+
+        # Populate current minigame ranking (LOL).
+        mng = Node.void('mng')
+        root.add_child(mng)
+        mng.add_child(Node.s32('new_rank', minigame_rank))
+        mng.add_child(Node.s32('old_rank', -1))
+
+        return root
+
+    def handle_player_rb5_player_write_request(self, request: Node) -> Node:
+        refid = request.child_value('pdata/account/rid')
+        profile = self.put_profile_by_refid(refid, request)
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.s32('uid', 0))
+        else:
+            root.add_child(Node.s32('uid', profile.get_int('extid')))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        statistics = self.get_play_statistics(userid)
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        # Account time info
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+
+        # Previous account info
+        previous_version = self.previous_version()
+        if previous_version:
+            succeeded = previous_version.has_profile(userid)
+        else:
+            succeeded = False
+
+        # Account info
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', profile.get_int('extid')))
+        account.add_child(Node.s32('tpc', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s32('dpc', today_count))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s32('intrvld', 0))
+        account.add_child(Node.s16('ver', 0))
+        account.add_child(Node.u64('pst', 0))
+        account.add_child(Node.u64('st', Time.now() * 1000))
+        account.add_child(Node.bool('succeed', succeeded))
+        account.add_child(Node.s32('opc', 0))
+        account.add_child(Node.s32('lpc', 0))
+        account.add_child(Node.s32('cpc', 0))
+
+        # Base profile info
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', profile.get_str('name')))
+        base.add_child(Node.s32('mg', profile.get_int('mg')))
+        base.add_child(Node.s32('ap', profile.get_int('ap')))
+        base.add_child(Node.string('cmnt', ''))
+        base.add_child(Node.s32('uattr', profile.get_int('uattr')))
+        base.add_child(Node.s32('money', profile.get_int('money')))
+        base.add_child(Node.s32('tbs', -1))
+        base.add_child(Node.s32_array('tbgs', [-1, -1, -1, -1]))
+        base.add_child(Node.s16_array('mlog', [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
+        base.add_child(Node.s32('class', profile.get_int('class')))
+        base.add_child(Node.s32('class_ar', profile.get_int('class_ar')))
+
+        # Rivals
+        rival = Node.void('rival')
+        pdata.add_child(rival)
+        slotid = 0
+        for link in links:
+            if link.type != 'rival':
+                continue
+
+            rprofile = self.get_profile(link.other_userid)
+            if rprofile is None:
+                continue
+            lobbyinfo = self.data.local.lobby.get_play_session_info(self.game, self.version, link.other_userid)
+            if lobbyinfo is None:
+                lobbyinfo = ValidatedDict()
+
+            r = Node.void('r')
+            rival.add_child(r)
+            r.add_child(Node.s32('slot_id', slotid))
+            r.add_child(Node.s32('id', rprofile.get_int('extid')))
+            r.add_child(Node.string('name', rprofile.get_str('name')))
+            r.add_child(Node.s32('icon', rprofile.get_dict('config').get_int('icon_id')))
+            r.add_child(Node.s32('class', rprofile.get_int('class')))
+            r.add_child(Node.s32('class_ar', rprofile.get_int('class_ar')))
+            r.add_child(Node.bool('friend', True))
+            r.add_child(Node.bool('target', False))
+            r.add_child(Node.u32('time', lobbyinfo.get_int('time')))
+            r.add_child(Node.u8_array('ga', lobbyinfo.get_int_array('ga', 4)))
+            r.add_child(Node.u16('gp', lobbyinfo.get_int('gp')))
+            r.add_child(Node.u8_array('ipn', lobbyinfo.get_int_array('la', 4)))
+            r.add_child(Node.u8_array('pnid', lobbyinfo.get_int_array('pnid', 16)))
+            slotid = slotid + 1
+
+        # Configuration
+        configdict = profile.get_dict('config')
+        config = Node.void('config')
+        pdata.add_child(config)
+        config.add_child(Node.u8('msel_bgm', configdict.get_int('msel_bgm')))
+        config.add_child(Node.u8('narrowdown_type', configdict.get_int('narrowdown_type')))
+        config.add_child(Node.s16('icon_id', configdict.get_int('icon_id')))
+        config.add_child(Node.s16('byword_0', configdict.get_int('byword_0')))
+        config.add_child(Node.s16('byword_1', configdict.get_int('byword_1')))
+        config.add_child(Node.bool('is_auto_byword_0', configdict.get_bool('is_auto_byword_0')))
+        config.add_child(Node.bool('is_auto_byword_1', configdict.get_bool('is_auto_byword_1')))
+        config.add_child(Node.u8('mrec_type', configdict.get_int('mrec_type')))
+        config.add_child(Node.u8('tab_sel', configdict.get_int('tab_sel')))
+        config.add_child(Node.u8('card_disp', configdict.get_int('card_disp')))
+        config.add_child(Node.u8('score_tab_disp', configdict.get_int('score_tab_disp')))
+        config.add_child(Node.s16('last_music_id', configdict.get_int('last_music_id', -1)))
+        config.add_child(Node.u8('last_note_grade', configdict.get_int('last_note_grade')))
+        config.add_child(Node.u8('sort_type', configdict.get_int('sort_type')))
+        config.add_child(Node.u8('rival_panel_type', configdict.get_int('rival_panel_type')))
+        config.add_child(Node.u64('random_entry_work', configdict.get_int('random_entry_work')))
+        config.add_child(Node.u64('custom_folder_work', configdict.get_int('custom_folder_work')))
+        config.add_child(Node.u8('folder_type', configdict.get_int('folder_type')))
+        config.add_child(Node.u8('folder_lamp_type', configdict.get_int('folder_lamp_type')))
+        config.add_child(Node.bool('is_tweet', configdict.get_bool('is_tweet')))
+        config.add_child(Node.bool('is_link_twitter', configdict.get_bool('is_link_twitter')))
+
+        # Customizations
+        customdict = profile.get_dict('custom')
+        custom = Node.void('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('st_shot', customdict.get_int('st_shot')))
+        custom.add_child(Node.u8('st_frame', customdict.get_int('st_frame')))
+        custom.add_child(Node.u8('st_expl', customdict.get_int('st_expl')))
+        custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
+        custom.add_child(Node.u8('st_shot_vol', customdict.get_int('st_shot_vol')))
+        custom.add_child(Node.u8('st_bg_bri', customdict.get_int('st_bg_bri')))
+        custom.add_child(Node.u8('st_obj_size', customdict.get_int('st_obj_size')))
+        custom.add_child(Node.u8('st_jr_gauge', customdict.get_int('st_jr_gauge')))
+        custom.add_child(Node.u8('st_clr_gauge', customdict.get_int('st_clr_gauge')))
+        custom.add_child(Node.u8('st_jdg_disp', customdict.get_int('st_jdg_disp')))
+        custom.add_child(Node.u8('st_rnd', customdict.get_int('st_rnd')))
+        custom.add_child(Node.u8('st_hazard', customdict.get_int('st_hazard')))
+        custom.add_child(Node.u8('st_clr_cond', customdict.get_int('st_clr_cond')))
+        custom.add_child(Node.u8('same_time_note_disp', customdict.get_int('same_time_note_disp')))
+        custom.add_child(Node.u8('st_gr_gauge_type', customdict.get_int('st_gr_gauge_type')))
+        custom.add_child(Node.s16('voice_message_set', customdict.get_int('voice_message_set', -1)))
+        custom.add_child(Node.u8('voice_message_volume', customdict.get_int('voice_message_volume')))
+
+        # Unlocks
+        released = Node.void('released')
+        pdata.add_child(released)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+            if game_config.get_bool('force_unlock_songs') and itemtype == 0:
+                # Don't echo unlocks when we're force unlocking, we'll do it later
+                continue
+
+            info = Node.void('info')
+            released.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u16('id', item.id))
+            info.add_child(Node.u16('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for songid in ids:
+                if ids[songid] == 0:
+                    continue
+
+                info = Node.void('info')
+                released.add_child(info)
+                info.add_child(Node.u8('type', 0))
+                info.add_child(Node.u16('id', songid))
+                info.add_child(Node.u16('param', ids[songid]))
+
+        # Announcements
+        announce = Node.void('announce')
+        pdata.add_child(announce)
+
+        for announcement in achievements:
+            if announcement.type[:13] != 'announcement_':
+                continue
+            announcementtype = int(announcement.type[13:])
+
+            info = Node.void('info')
+            announce.add_child(info)
+            info.add_child(Node.u8('type', announcementtype))
+            info.add_child(Node.u16('id', announcement.id))
+            info.add_child(Node.u16('param', announcement.data.get_int('param')))
+            info.add_child(Node.bool('bneedannounce', announcement.data.get_bool('need')))
+
+        # Dojo ranking return
+        dojo = Node.void('dojo')
+        pdata.add_child(dojo)
+
+        for entry in achievements:
+            if entry.type != 'dojo':
+                continue
+
+            rec = Node.void('rec')
+            dojo.add_child(rec)
+            rec.add_child(Node.s32('class', entry.id))
+            rec.add_child(Node.s32('clear_type', entry.data.get_int('clear_type')))
+            rec.add_child(Node.s32('total_ar', entry.data.get_int('ar')))
+            rec.add_child(Node.s32('total_score', entry.data.get_int('score')))
+            rec.add_child(Node.s32('play_count', entry.data.get_int('plays')))
+            rec.add_child(Node.s32('last_play_time', entry.data.get_int('play_timestamp')))
+            rec.add_child(Node.s32('record_update_time', entry.data.get_int('record_timestamp')))
+            rec.add_child(Node.s32('rank', 0))
+
+        # Player Parameters
+        player_param = Node.void('player_param')
+        pdata.add_child(player_param)
+
+        for param in achievements:
+            if param.type[:13] != 'player_param_':
+                continue
+            itemtype = int(param.type[13:])
+
+            itemnode = Node.void('item')
+            player_param.add_child(itemnode)
+            itemnode.add_child(Node.s32('type', itemtype))
+            itemnode.add_child(Node.s32('bank', param.id))
+            itemnode.add_child(Node.s32_array('data', param.data.get_int_array('data', 256)))
+
+        # Shop score for players
+        self._add_shop_score(pdata)
+
+        # My List data
+        mylist = Node.void('mylist')
+        pdata.add_child(mylist)
+        listdata = Node.void('list')
+        mylist.add_child(listdata)
+        listdata.add_child(Node.s16('idx', 0))
+        listdata.add_child(Node.s16_array('mlst', profile.get_int_array('favorites', 30, [-1] * 30)))
+
+        # Minigame settings
+        minigame = Node.void('minigame')
+        pdata.add_child(minigame)
+        minigame.add_child(Node.s8('mgid', profile.get_int('mgid')))
+        minigame.add_child(Node.s32('sc', profile.get_int('mgsc')))
+
+        # Derby settings
+        derby = Node.void('derby')
+        pdata.add_child(derby)
+        derby.add_child(Node.bool('is_open', False))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        game_config = self.get_game_config()
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Save base player profile info
+        newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('pdata/account/lid')))
+        newprofile.replace_str('name', request.child_value('pdata/base/name'))
+        newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
+        newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
+        newprofile.replace_int('uattr', request.child_value('pdata/base/uattr'))
+        newprofile.replace_int('money', request.child_value('pdata/base/money'))
+        newprofile.replace_int('class', request.child_value('pdata/base/class'))
+        newprofile.replace_int('class_ar', request.child_value('pdata/base/class_ar'))
+        newprofile.replace_int('mgid', request.child_value('pdata/minigame/mgid'))
+        newprofile.replace_int('mgsc', request.child_value('pdata/minigame/sc'))
+        newprofile.replace_int_array('favorites', 30, request.child_value('pdata/mylist/list/mlst'))
+
+        # Save player config
+        configdict = newprofile.get_dict('config')
+        config = request.child('pdata/config')
+        if config:
+            configdict.replace_int('msel_bgm', config.child_value('msel_bgm'))
+            configdict.replace_int('narrowdown_type', config.child_value('narrowdown_type'))
+            configdict.replace_int('icon_id', config.child_value('icon_id'))
+            configdict.replace_int('byword_0', config.child_value('byword_0'))
+            configdict.replace_int('byword_1', config.child_value('byword_1'))
+            configdict.replace_bool('is_auto_byword_0', config.child_value('is_auto_byword_0'))
+            configdict.replace_bool('is_auto_byword_1', config.child_value('is_auto_byword_1'))
+            configdict.replace_int('mrec_type', config.child_value('mrec_type'))
+            configdict.replace_int('tab_sel', config.child_value('tab_sel'))
+            configdict.replace_int('card_disp', config.child_value('card_disp'))
+            configdict.replace_int('score_tab_disp', config.child_value('score_tab_disp'))
+            configdict.replace_int('last_music_id', config.child_value('last_music_id'))
+            configdict.replace_int('last_note_grade', config.child_value('last_note_grade'))
+            configdict.replace_int('sort_type', config.child_value('sort_type'))
+            configdict.replace_int('rival_panel_type', config.child_value('rival_panel_type'))
+            configdict.replace_int('random_entry_work', config.child_value('random_entry_work'))
+            configdict.replace_int('custom_folder_work', config.child_value('custom_folder_work'))
+            configdict.replace_int('folder_type', config.child_value('folder_type'))
+            configdict.replace_int('folder_lamp_type', config.child_value('folder_lamp_type'))
+            configdict.replace_bool('is_tweet', config.child_value('is_tweet'))
+            configdict.replace_bool('is_link_twitter', config.child_value('is_link_twitter'))
+        newprofile.replace_dict('config', configdict)
+
+        # Save player custom settings
+        customdict = newprofile.get_dict('custom')
+        custom = request.child('pdata/custom')
+        if custom:
+            customdict.replace_int('st_shot', custom.child_value('st_shot'))
+            customdict.replace_int('st_frame', custom.child_value('st_frame'))
+            customdict.replace_int('st_expl', custom.child_value('st_expl'))
+            customdict.replace_int('st_bg', custom.child_value('st_bg'))
+            customdict.replace_int('st_shot_vol', custom.child_value('st_shot_vol'))
+            customdict.replace_int('st_bg_bri', custom.child_value('st_bg_bri'))
+            customdict.replace_int('st_obj_size', custom.child_value('st_obj_size'))
+            customdict.replace_int('st_jr_gauge', custom.child_value('st_jr_gauge'))
+            customdict.replace_int('st_clr_gauge', custom.child_value('st_clr_gauge'))
+            customdict.replace_int('st_rnd', custom.child_value('st_rnd'))
+            customdict.replace_int('st_hazard', custom.child_value('st_hazard'))
+            customdict.replace_int('st_clr_cond', custom.child_value('st_clr_cond'))
+            customdict.replace_int('same_time_note_disp', custom.child_value('same_time_note_disp'))
+            customdict.replace_int('st_gr_gauge_type', custom.child_value('st_gr_gauge_type'))
+            customdict.replace_int('voice_message_set', custom.child_value('voice_message_set'))
+            customdict.replace_int('voice_message_volume', custom.child_value('voice_message_volume'))
+        newprofile.replace_dict('custom', customdict)
+
+        # Save player parameter info
+        params = request.child('pdata/player_param')
+        if params:
+            for child in params.children:
+                if child.name != 'item':
+                    continue
+
+                item_type = child.child_value('type')
+                bank = child.child_value('bank')
+                data = child.child_value('data')
+                while len(data) < 256:
+                    data.append(0)
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    bank,
+                    'player_param_{}'.format(item_type),
+                    {
+                        'data': data,
+                    },
+                )
+
+        # Save player episode info
+        episode = request.child('pdata/episode')
+        if episode:
+            for child in episode.children:
+                if child.name != 'info':
+                    continue
+
+                # I assume this is copypasta, but I want to be sure
+                extid = child.child_value('user_id')
+                if extid != newprofile.get_int('extid'):
+                    raise Exception('Unexpected user ID, got {} expecting {}'.format(extid, newprofile.get_int('extid')))
+
+                episode_type = child.child_value('type')
+                episode_value0 = child.child_value('value0')
+                episode_value1 = child.child_value('value1')
+                episode_text = child.child_value('text')
+                episode_time = child.child_value('time')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    episode_type,
+                    'episode',
+                    {
+                        'value0': episode_value0,
+                        'value1': episode_value1,
+                        'text': episode_text,
+                        'time': episode_time,
+                    },
+                )
+
+        # Save released info
+        released = request.child('pdata/released')
+        if released:
+            for child in released.children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                if game_config.get_bool('force_unlock_songs') and item_type == 0:
+                    # Don't save unlocks when we're force unlocking
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Save announce info
+        announce = request.child('pdata/announce')
+        if announce:
+            for child in announce.children:
+                if child.name != 'info':
+                    continue
+
+                announce_id = child.child_value('id')
+                announce_type = child.child_value('type')
+                param = child.child_value('param')
+                need = child.child_value('bneedannounce')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    announce_id,
+                    'announcement_{}'.format(announce_type),
+                    {
+                        'param': param,
+                        'need': need,
+                    },
+                )
+
+        # Save player dojo
+        dojo = request.child('pdata/dojo')
+        if dojo:
+            dojoid = dojo.child_value('class')
+            clear_type = dojo.child_value('clear_type')
+            ar = dojo.child_value('t_ar')
+            score = dojo.child_value('t_score')
+
+            # Figure out timestamp stuff
+            data = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                dojoid,
+                'dojo',
+            ) or ValidatedDict()
+
+            if ar >= data.get_int('ar'):
+                # We set a new achievement rate, keep the new values
+                record_time = Time.now()
+            else:
+                # We didn't, keep the old values for achievement rate, but
+                # override score and clear_type only if they were better.
+                record_time = data.get_int('record_timestamp')
+                ar = data.get_int('ar')
+                score = max(score, data.get_int('score'))
+                clear_type = max(clear_type, data.get_int('clear_type'))
+
+            play_time = Time.now()
+            plays = data.get_int('plays') + 1
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                dojoid,
+                'dojo',
+                {
+                    'clear_type': clear_type,
+                    'ar': ar,
+                    'score': score,
+                    'plays': plays,
+                    'play_timestamp': play_time,
+                    'record_timestamp': record_time,
+                },
+            )
+
+        # Grab any new rivals added during this play session
+        rivalnode = request.child('pdata/rival')
+        if rivalnode:
+            for child in rivalnode.children:
+                if child.name != 'r':
+                    continue
+
+                extid = child.child_value('id')
+                other_userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if other_userid is None:
+                    continue
+
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'rival',
+                    other_userid,
+                    {},
+                )
+
+        # Grab any new records set during this play session
+        songplays = request.child('pdata/stglog')
+        if songplays:
+            for child in songplays.children:
+                if child.name != 'log':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+                clear_type = child.child_value('ct')
+                if songid == 0 and chart == 0 and clear_type == -1:
+                    # Dummy song save during profile create
+                    continue
+
+                points = child.child_value('sc')
+                achievement_rate = child.child_value('ar')
+                param = child.child_value('param')
+                miss_count = child.child_value('jt_ms')
+                k_flag = child.child_value('k_flag')
+
+                # Param is some random bits along with the combo type
+                combo_type = param & 0x3
+                param = param ^ combo_type
+
+                clear_type = self._game_to_db_clear_type(clear_type)
+                combo_type = self._game_to_db_combo_type(combo_type, miss_count)
+                self.update_score(
+                    userid,
+                    songid,
+                    chart,
+                    points,
+                    achievement_rate,
+                    clear_type,
+                    combo_type,
+                    miss_count,
+                    param=param,
+                    kflag=k_flag,
+                )
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/volzza2.py b/bemani/backend/reflec/volzza2.py
new file mode 100644
index 0000000..afeb7fc
--- /dev/null
+++ b/bemani/backend/reflec/volzza2.py
@@ -0,0 +1,1007 @@
+import copy
+from typing import Any, Dict, List, Optional
+
+from bemani.backend.reflec.base import ReflecBeatBase
+from bemani.backend.reflec.volzzabase import ReflecBeatVolzzaBase
+from bemani.backend.reflec.volzza import ReflecBeatVolzza
+
+from bemani.common import ValidatedDict, VersionConstants, ID, Time
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class ReflecBeatVolzza2(ReflecBeatVolzzaBase):
+
+    name = "REFLEC BEAT VOLZZA 2"
+    version = VersionConstants.REFLEC_BEAT_VOLZZA_2
+
+    def previous_version(self) -> Optional[ReflecBeatBase]:
+        return ReflecBeatVolzza(self.data, self.config, self.model)
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+            ],
+            'ints': [],
+        }
+
+    def _add_event_info(self, root: Node) -> None:
+        event_ctrl = Node.void('event_ctrl')
+        root.add_child(event_ctrl)
+        # Contains zero or more nodes like:
+        # <data>
+        #     <type __type="s32">any</type>
+        #     <index __type="s32">any</phase>
+        #     <value __type="s32">any</phase>
+        #     <value2 __type="s32">any</phase>
+        #     <start_time __type="s32">any</phase>
+        #     <end_time __type="s32">any</phase>
+        # </data>
+
+        item_lock_ctrl = Node.void('item_lock_ctrl')
+        root.add_child(item_lock_ctrl)
+        # Contains zero or more nodes like:
+        # <item>
+        #     <type __type="u8">any</type>
+        #     <id __type="u16">any</id>
+        #     <param __type="u16">0-3</param>
+        # </item>
+
+        mycourse_ctrl = Node.void('mycourse_ctrl')
+        root.add_child(mycourse_ctrl)
+        songs = {song.id for song in self.data.local.music.get_all_songs(self.game, self.version)}
+        for song in songs:
+            data = Node.void('data')
+            mycourse_ctrl.add_child(data)
+            data.add_child(Node.s16('mycourse_id', 1))
+            data.add_child(Node.s32('type', 0))
+            data.add_child(Node.s32('music_id', song))
+
+    def handle_player_rb5_player_read_score_old_5_request(self, request: Node) -> Node:
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        record = Node.void('record_old')
+        pdata.add_child(record)
+        return root
+
+    def handle_player_rb5_player_read_score_5_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is None:
+            scores: List[Score] = []
+        else:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        record = Node.void('record')
+        pdata.add_child(record)
+
+        for score in scores:
+            rec = Node.void('rec')
+            record.add_child(rec)
+            rec.add_child(Node.s16('mid', score.id))
+            rec.add_child(Node.s8('ntgrd', score.chart))
+            rec.add_child(Node.s32('pc', score.plays))
+            rec.add_child(Node.s8('ct', self._db_to_game_clear_type(score.data.get_int('clear_type'))))
+            rec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
+            rec.add_child(Node.s16('scr', score.points))
+            rec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
+            rec.add_child(Node.s16(
+                'param',
+                self._db_to_game_combo_type(score.data.get_int('combo_type')) + score.data.get_int('param'),
+            ))
+            rec.add_child(Node.s32('bscrt', score.timestamp))
+            rec.add_child(Node.s32('bart', score.data.get_int('best_achievement_rate_time')))
+            rec.add_child(Node.s32('bctt', score.data.get_int('best_clear_type_time')))
+            rec.add_child(Node.s32('bmst', score.data.get_int('best_miss_count_time')))
+            rec.add_child(Node.s32('time', score.data.get_int('last_played_time')))
+            rec.add_child(Node.s32('k_flag', score.data.get_int('kflag')))
+
+        return root
+
+    def handle_player_rb5_player_read_rival_score_5_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        songid = request.child_value('music_id')
+        chart = request.child_value('note_grade')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is None:
+            score = None
+            profile = None
+        else:
+            score = self.data.remote.music.get_score(self.game, self.version, userid, songid, chart)
+            profile = self.get_any_profile(userid)
+
+        root = Node.void('player')
+        if score is not None and profile is not None:
+            player_select_score = Node.void('player_select_score')
+            root.add_child(player_select_score)
+
+            player_select_score.add_child(Node.s32('user_id', extid))
+            player_select_score.add_child(Node.string('name', profile.get_str('name')))
+            player_select_score.add_child(Node.s32('m_score', score.points))
+            player_select_score.add_child(Node.s32('m_scoreTime', score.timestamp))
+            player_select_score.add_child(Node.s16('m_iconID', profile.get_dict('config').get_int('icon_id')))
+        return root
+
+    def handle_player_rb5_player_read_rival_ranking_data_5_request(self, request: Node) -> Node:
+        extid = request.child_value('uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+
+        root = Node.void('player')
+        rival_data = Node.void('rival_data')
+        root.add_child(rival_data)
+
+        if userid is not None:
+            links = self.data.local.user.get_links(self.game, self.version, userid)
+            for link in links:
+                if link.type != 'rival':
+                    continue
+
+                rprofile = self.get_profile(link.other_userid)
+                if rprofile is None:
+                    continue
+
+                rl = Node.void('rl')
+                rival_data.add_child(rl)
+                rl.add_child(Node.s32('uid', rprofile.get_int('extid')))
+                rl.add_child(Node.string('nm', rprofile.get_str('name')))
+                rl.add_child(Node.s16('ic', rprofile.get_dict('config').get_int('icon_id')))
+
+                scores = self.data.remote.music.get_scores(self.game, self.version, link.other_userid)
+                scores_by_musicid: Dict[int, List[Score]] = {}
+                for score in scores:
+                    if score.id not in scores_by_musicid:
+                        scores_by_musicid[score.id] = [None, None, None, None]
+                    scores_by_musicid[score.id][score.chart] = score
+
+                for (mid, scores) in scores_by_musicid.items():
+                    points = [
+                        score.points << 32 if score is not None else 0
+                        for score in scores
+                    ]
+                    timestamps = [
+                        score.timestamp if score is not None else 0
+                        for score in scores
+                    ]
+
+                    sl = Node.void('sl')
+                    rl.add_child(sl)
+                    sl.add_child(Node.s16('mid', mid))
+                    # Score, but shifted left 32 bits for no reason
+                    sl.add_child(Node.u64_array('m', points))
+                    # Timestamp of the clear
+                    sl.add_child(Node.u64_array('t', timestamps))
+
+        return root
+
+    def handle_player_rb5_player_read_rank_5_request(self, request: Node) -> Node:
+        # This gives us a 6-integer array mapping to user scores for the following:
+        # [total score, basic chart score, medium chart score, hard chart score,
+        # special chart score]. It also returns the previous rank, but this is
+        # not used in-game as far as I can tell.
+        current_scores = request.child_value('sc')
+        current_minigame_score = request.child_value('mg_sc')
+
+        # First, grab all scores on the network for this version.
+        all_scores = self.data.remote.music.get_all_scores(self.game, self.version)
+
+        # Now grab all participating users that had scores
+        all_users = {userid for (userid, score) in all_scores}
+
+        # Now, group the scores by user, so we can add up the totals, only including
+        # scores where the user at least cleared the song.
+        scores_by_user = {
+            userid: [
+                score for (uid, score) in all_scores
+                if uid == userid and score.data.get_int('clear_type') >= self.CLEAR_TYPE_CLEARED]
+            for userid in all_users
+        }
+
+        # Now grab all user profiles for this game
+        all_profiles = {
+            profile[0]: profile[1] for profile in
+            self.data.remote.user.get_all_profiles(self.game, self.version)
+        }
+
+        # Now, sum up the scores into the five categories that the game expects.
+        total_scores = sorted(
+            [
+                sum([score.points for score in scores])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        basic_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_BASIC])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        medium_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_MEDIUM])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        hard_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_HARD])
+                for userid, scores in scores_by_user.items()
+            ],
+        )
+        special_scores = sorted(
+            [
+                sum([score.points for score in scores if score.chart == self.CHART_TYPE_SPECIAL])
+                for userid, scores in scores_by_user.items()
+            ],
+            reverse=True,
+        )
+        minigame_scores = sorted(
+            [
+                all_profiles.get(userid, ValidatedDict()).get_int('mgsc')
+                for userid in all_users
+            ],
+            reverse=True,
+        )
+
+        # Guarantee that a zero score is at the end of every list, so that it makes
+        # the algorithm for figuring out place have no edge case.
+        total_scores.append(0)
+        basic_scores.append(0)
+        medium_scores.append(0)
+        hard_scores.append(0)
+        special_scores.append(0)
+        minigame_scores.append(0)
+
+        # Now, figure out where we fit based on the scores sent from the game.
+        user_place = [1, 1, 1, 1, 1, 1]
+        which_score = [
+            total_scores,
+            basic_scores,
+            medium_scores,
+            hard_scores,
+            special_scores,
+            minigame_scores,
+        ]
+        earned_scores = current_scores + [current_minigame_score]
+        for i in range(len(user_place)):
+            earned_score = earned_scores[i]
+            scores = which_score[i]
+            for score in scores:
+                if earned_score >= score:
+                    break
+                user_place[i] = user_place[i] + 1
+
+        # Separate out minigame rank from scores
+        minigame_rank = user_place[-1]
+        user_place = user_place[:-1]
+
+        root = Node.void('player')
+
+        # Populate current ranking.
+        tbs = Node.void('tbs')
+        root.add_child(tbs)
+        tbs.add_child(Node.s32_array('new_rank', user_place))
+        tbs.add_child(Node.s32_array('old_rank', [-1, -1, -1, -1, -1]))
+
+        # Populate current minigame ranking (LOL).
+        mng = Node.void('mng')
+        root.add_child(mng)
+        mng.add_child(Node.s32('new_rank', minigame_rank))
+        mng.add_child(Node.s32('old_rank', -1))
+
+        return root
+
+    def handle_player_rb5_player_write_5_request(self, request: Node) -> Node:
+        refid = request.child_value('pdata/account/rid')
+        profile = self.put_profile_by_refid(refid, request)
+        root = Node.void('player')
+
+        if profile is None:
+            root.add_child(Node.s32('uid', 0))
+        else:
+            root.add_child(Node.s32('uid', profile.get_int('extid')))
+        return root
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        statistics = self.get_play_statistics(userid)
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+        links = self.data.local.user.get_links(self.game, self.version, userid)
+        rprofiles: Dict[UserID, ValidatedDict] = {}
+        root = Node.void('player')
+        pdata = Node.void('pdata')
+        root.add_child(pdata)
+
+        # Account time info
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+
+        # Previous account info
+        previous_version = self.previous_version()
+        if previous_version:
+            succeeded = previous_version.has_profile(userid)
+        else:
+            succeeded = False
+
+        # Account info
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', profile.get_int('extid')))
+        account.add_child(Node.s32('tpc', statistics.get_int('total_plays', 0)))
+        account.add_child(Node.s32('dpc', today_count))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', statistics.get_int('total_days', 0)))
+        account.add_child(Node.s32('intrvld', 0))
+        account.add_child(Node.s16('ver', 0))
+        account.add_child(Node.bool('succeed', succeeded))
+        account.add_child(Node.u64('pst', 0))
+        account.add_child(Node.u64('st', Time.now() * 1000))
+        account.add_child(Node.s32('opc', 0))
+        account.add_child(Node.s32('lpc', 0))
+        account.add_child(Node.s32('cpc', 0))
+        account.add_child(Node.s32('mpc', 0))
+
+        # Base profile info
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', profile.get_str('name')))
+        base.add_child(Node.s32('mg', profile.get_int('mg')))
+        base.add_child(Node.s32('ap', profile.get_int('ap')))
+        base.add_child(Node.string('cmnt', ''))
+        base.add_child(Node.s32('uattr', profile.get_int('uattr')))
+        base.add_child(Node.s32('money', profile.get_int('money')))
+        base.add_child(Node.s32('tbs_5', -1))
+        base.add_child(Node.s32_array('tbgs_5', [-1, -1, -1, -1]))
+        base.add_child(Node.s16_array('mlog', [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
+        base.add_child(Node.s32('class', profile.get_int('class')))
+        base.add_child(Node.s32('class_ar', profile.get_int('class_ar')))
+        base.add_child(Node.s32('skill_point', profile.get_int('skill_point')))
+        base.add_child(Node.bool('meteor_flg', False))
+
+        # Rivals
+        rival = Node.void('rival')
+        pdata.add_child(rival)
+        slotid = 0
+        for link in links:
+            if link.type != 'rival':
+                continue
+
+            if link.other_userid not in rprofiles:
+                rprofile = self.get_profile(link.other_userid)
+                if rprofile is None:
+                    continue
+                rprofiles[link.other_userid] = rprofile
+            else:
+                rprofile = rprofiles[link.other_userid]
+            lobbyinfo = self.data.local.lobby.get_play_session_info(self.game, self.version, link.other_userid)
+            if lobbyinfo is None:
+                lobbyinfo = ValidatedDict()
+
+            r = Node.void('r')
+            rival.add_child(r)
+            r.add_child(Node.s32('slot_id', slotid))
+            r.add_child(Node.s32('id', rprofile.get_int('extid')))
+            r.add_child(Node.string('name', rprofile.get_str('name')))
+            r.add_child(Node.s32('icon', rprofile.get_dict('config').get_int('icon_id')))
+            r.add_child(Node.s32('class', rprofile.get_int('class')))
+            r.add_child(Node.s32('class_ar', rprofile.get_int('class_ar')))
+            r.add_child(Node.bool('friend', True))
+            r.add_child(Node.bool('target', False))
+            r.add_child(Node.u32('time', lobbyinfo.get_int('time')))
+            r.add_child(Node.u8_array('ga', lobbyinfo.get_int_array('ga', 4)))
+            r.add_child(Node.u16('gp', lobbyinfo.get_int('gp')))
+            r.add_child(Node.u8_array('ipn', lobbyinfo.get_int_array('la', 4)))
+            r.add_child(Node.u8_array('pnid', lobbyinfo.get_int_array('pnid', 16)))
+            slotid = slotid + 1
+
+        # Configuration
+        configdict = profile.get_dict('config')
+        config = Node.void('config')
+        pdata.add_child(config)
+        config.add_child(Node.u8('msel_bgm', configdict.get_int('msel_bgm')))
+        config.add_child(Node.u8('narrowdown_type', configdict.get_int('narrowdown_type')))
+        config.add_child(Node.s16('icon_id', configdict.get_int('icon_id')))
+        config.add_child(Node.s16('byword_0', configdict.get_int('byword_0')))
+        config.add_child(Node.s16('byword_1', configdict.get_int('byword_1')))
+        config.add_child(Node.bool('is_auto_byword_0', configdict.get_bool('is_auto_byword_0')))
+        config.add_child(Node.bool('is_auto_byword_1', configdict.get_bool('is_auto_byword_1')))
+        config.add_child(Node.u8('mrec_type', configdict.get_int('mrec_type')))
+        config.add_child(Node.u8('tab_sel', configdict.get_int('tab_sel')))
+        config.add_child(Node.u8('card_disp', configdict.get_int('card_disp')))
+        config.add_child(Node.u8('score_tab_disp', configdict.get_int('score_tab_disp')))
+        config.add_child(Node.s16('last_music_id', configdict.get_int('last_music_id', -1)))
+        config.add_child(Node.u8('last_note_grade', configdict.get_int('last_note_grade')))
+        config.add_child(Node.u8('sort_type', configdict.get_int('sort_type')))
+        config.add_child(Node.u8('rival_panel_type', configdict.get_int('rival_panel_type')))
+        config.add_child(Node.u64('random_entry_work', configdict.get_int('random_entry_work')))
+        config.add_child(Node.u64('custom_folder_work', configdict.get_int('custom_folder_work')))
+        config.add_child(Node.u8('folder_type', configdict.get_int('folder_type')))
+        config.add_child(Node.u8('folder_lamp_type', configdict.get_int('folder_lamp_type')))
+        config.add_child(Node.bool('is_tweet', configdict.get_bool('is_tweet')))
+        config.add_child(Node.bool('is_link_twitter', configdict.get_bool('is_link_twitter')))
+
+        # Customizations
+        customdict = profile.get_dict('custom')
+        custom = Node.void('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('st_shot', customdict.get_int('st_shot')))
+        custom.add_child(Node.u8('st_frame', customdict.get_int('st_frame')))
+        custom.add_child(Node.u8('st_expl', customdict.get_int('st_expl')))
+        custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
+        custom.add_child(Node.u8('st_shot_vol', customdict.get_int('st_shot_vol')))
+        custom.add_child(Node.u8('st_bg_bri', customdict.get_int('st_bg_bri')))
+        custom.add_child(Node.u8('st_obj_size', customdict.get_int('st_obj_size')))
+        custom.add_child(Node.u8('st_jr_gauge', customdict.get_int('st_jr_gauge')))
+        custom.add_child(Node.u8('st_clr_gauge', customdict.get_int('st_clr_gauge')))
+        custom.add_child(Node.u8('st_rnd', customdict.get_int('st_rnd')))
+        custom.add_child(Node.u8('st_gr_gauge_type', customdict.get_int('st_gr_gauge_type')))
+        custom.add_child(Node.s16('voice_message_set', customdict.get_int('voice_message_set', -1)))
+        custom.add_child(Node.u8('same_time_note_disp', customdict.get_int('same_time_note_disp')))
+        custom.add_child(Node.u8('st_score_disp_type', customdict.get_int('st_score_disp_type')))
+        custom.add_child(Node.u8('st_bonus_type', customdict.get_int('st_bonus_type')))
+        custom.add_child(Node.u8('st_rivalnote_type', customdict.get_int('st_rivalnote_type')))
+        custom.add_child(Node.u8('st_topassist_type', customdict.get_int('st_topassist_type')))
+        custom.add_child(Node.u8('high_speed', customdict.get_int('high_speed')))
+        custom.add_child(Node.u8('st_hazard', customdict.get_int('st_hazard')))
+        custom.add_child(Node.u8('st_clr_cond', customdict.get_int('st_clr_cond')))
+        custom.add_child(Node.u8('voice_message_volume', customdict.get_int('voice_message_volume')))
+
+        # Unlocks
+        released = Node.void('released')
+        pdata.add_child(released)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+            if game_config.get_bool('force_unlock_songs') and itemtype == 0:
+                # Don't echo unlocks when we're force unlocking, we'll do it later
+                continue
+
+            info = Node.void('info')
+            released.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u16('id', item.id))
+            info.add_child(Node.u16('param', item.data.get_int('param')))
+            info.add_child(Node.s32('insert_time', item.data.get_int('time')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for songid in ids:
+                if ids[songid] == 0:
+                    continue
+
+                info = Node.void('info')
+                released.add_child(info)
+                info.add_child(Node.u8('type', 0))
+                info.add_child(Node.u16('id', songid))
+                info.add_child(Node.u16('param', ids[songid]))
+                info.add_child(Node.s32('insert_time', Time.now()))
+
+        # Announcements
+        announce = Node.void('announce')
+        pdata.add_child(announce)
+
+        for announcement in achievements:
+            if announcement.type[:13] != 'announcement_':
+                continue
+            announcementtype = int(announcement.type[13:])
+
+            info = Node.void('info')
+            announce.add_child(info)
+            info.add_child(Node.u8('type', announcementtype))
+            info.add_child(Node.u16('id', announcement.id))
+            info.add_child(Node.u16('param', announcement.data.get_int('param')))
+            info.add_child(Node.bool('bneedannounce', announcement.data.get_bool('need')))
+
+        # Dojo ranking return
+        dojo = Node.void('dojo')
+        pdata.add_child(dojo)
+
+        for entry in achievements:
+            if entry.type != 'dojo':
+                continue
+
+            rec = Node.void('rec')
+            dojo.add_child(rec)
+            rec.add_child(Node.s32('class', entry.id))
+            rec.add_child(Node.s32('clear_type', entry.data.get_int('clear_type')))
+            rec.add_child(Node.s32('total_ar', entry.data.get_int('ar')))
+            rec.add_child(Node.s32('total_score', entry.data.get_int('score')))
+            rec.add_child(Node.s32('play_count', entry.data.get_int('plays')))
+            rec.add_child(Node.s32('last_play_time', entry.data.get_int('play_timestamp')))
+            rec.add_child(Node.s32('record_update_time', entry.data.get_int('record_timestamp')))
+            rec.add_child(Node.s32('rank', 0))
+
+        # Player Parameters
+        player_param = Node.void('player_param')
+        pdata.add_child(player_param)
+
+        for param in achievements:
+            if param.type[:13] != 'player_param_':
+                continue
+            itemtype = int(param.type[13:])
+
+            itemnode = Node.void('item')
+            player_param.add_child(itemnode)
+            itemnode.add_child(Node.s32('type', itemtype))
+            itemnode.add_child(Node.s32('bank', param.id))
+            itemnode.add_child(Node.s32_array('data', param.data.get_int_array('data', 256)))
+
+        # Shop score for players
+        self._add_shop_score(pdata)
+
+        # My List data
+        mylist = Node.void('mylist')
+        pdata.add_child(mylist)
+        listdata = Node.void('list')
+        mylist.add_child(listdata)
+        listdata.add_child(Node.s16('idx', 0))
+        listdata.add_child(Node.s16_array('mlst', profile.get_int_array('favorites', 30, [-1] * 30)))
+
+        # Minigame settings
+        minigame = Node.void('minigame')
+        pdata.add_child(minigame)
+        minigame.add_child(Node.s8('mgid', profile.get_int('mgid')))
+        minigame.add_child(Node.s32('sc', profile.get_int('mgsc')))
+
+        # Derby settings
+        derby = Node.void('derby')
+        pdata.add_child(derby)
+        derby.add_child(Node.bool('is_open', False))
+
+        # Music rank points
+        music_rank_point = Node.void('music_rank_point')
+        pdata.add_child(music_rank_point)
+
+        # yurukome list stuff
+        yurukome_list = Node.void('yurukome_list')
+        pdata.add_child(yurukome_list)
+
+        for entry in achievements:
+            if entry.type != 'yurukome':
+                continue
+
+            yurukome = Node.void('yurukome')
+            yurukome_list.add_child(yurukome)
+            yurukome.add_child(Node.s32('yurukome_id', entry.id))
+
+        # My course mode
+        mycourse = Node.void('mycourse')
+        mycoursedict = profile.get_dict('mycourse')
+        pdata.add_child(mycourse)
+        mycourse.add_child(Node.s16('mycourse_id', 1))
+        mycourse.add_child(Node.s32('music_id_1', mycoursedict.get_int('music_id_1', -1)))
+        mycourse.add_child(Node.s16('note_grade_1', mycoursedict.get_int('note_grade_1', -1)))
+        mycourse.add_child(Node.s32('score_1', mycoursedict.get_int('score_1', -1)))
+        mycourse.add_child(Node.s32('music_id_2', mycoursedict.get_int('music_id_2', -1)))
+        mycourse.add_child(Node.s16('note_grade_2', mycoursedict.get_int('note_grade_2', -1)))
+        mycourse.add_child(Node.s32('score_2', mycoursedict.get_int('score_2', -1)))
+        mycourse.add_child(Node.s32('music_id_3', mycoursedict.get_int('music_id_3', -1)))
+        mycourse.add_child(Node.s16('note_grade_3', mycoursedict.get_int('note_grade_3', -1)))
+        mycourse.add_child(Node.s32('score_3', mycoursedict.get_int('score_3', -1)))
+        mycourse.add_child(Node.s32('music_id_4', mycoursedict.get_int('music_id_4', -1)))
+        mycourse.add_child(Node.s16('note_grade_4', mycoursedict.get_int('note_grade_4', -1)))
+        mycourse.add_child(Node.s32('score_4', mycoursedict.get_int('score_4', -1)))
+        mycourse.add_child(Node.s32('insert_time', mycoursedict.get_int('insert_time', -1)))
+        mycourse.add_child(Node.s32('def_music_id_1', -1))
+        mycourse.add_child(Node.s16('def_note_grade_1', -1))
+        mycourse.add_child(Node.s32('def_music_id_2', -1))
+        mycourse.add_child(Node.s16('def_note_grade_2', -1))
+        mycourse.add_child(Node.s32('def_music_id_3', -1))
+        mycourse.add_child(Node.s16('def_note_grade_3', -1))
+        mycourse.add_child(Node.s32('def_music_id_4', -1))
+        mycourse.add_child(Node.s16('def_note_grade_4', -1))
+
+        # Friend course scores
+        mycourse_f = Node.void('mycourse_f')
+        pdata.add_child(mycourse_f)
+
+        for link in links:
+            if link.type != 'rival':
+                continue
+
+            if link.other_userid not in rprofiles:
+                rprofile = self.get_profile(link.other_userid)
+                if rprofile is None:
+                    continue
+                rprofiles[link.other_userid] = rprofile
+            else:
+                rprofile = rprofiles[link.other_userid]
+            mycoursedict = rprofile.get_dict('mycourse')
+
+            rec = Node.void('rec')
+            mycourse_f.add_child(rec)
+            rec.add_child(Node.s32('rival_id', rprofile.get_int('extid')))
+            rec.add_child(Node.s16('mycourse_id', 1))
+            rec.add_child(Node.s32('music_id_1', mycoursedict.get_int('music_id_1', -1)))
+            rec.add_child(Node.s16('note_grade_1', mycoursedict.get_int('note_grade_1', -1)))
+            rec.add_child(Node.s32('score_1', mycoursedict.get_int('score_1', -1)))
+            rec.add_child(Node.s32('music_id_2', mycoursedict.get_int('music_id_2', -1)))
+            rec.add_child(Node.s16('note_grade_2', mycoursedict.get_int('note_grade_2', -1)))
+            rec.add_child(Node.s32('score_2', mycoursedict.get_int('score_2', -1)))
+            rec.add_child(Node.s32('music_id_3', mycoursedict.get_int('music_id_3', -1)))
+            rec.add_child(Node.s16('note_grade_3', mycoursedict.get_int('note_grade_3', -1)))
+            rec.add_child(Node.s32('score_3', mycoursedict.get_int('score_3', -1)))
+            rec.add_child(Node.s32('music_id_4', mycoursedict.get_int('music_id_4', -1)))
+            rec.add_child(Node.s16('note_grade_4', mycoursedict.get_int('note_grade_4', -1)))
+            rec.add_child(Node.s32('score_4', mycoursedict.get_int('score_4', -1)))
+            rec.add_child(Node.s32('insert_time', mycoursedict.get_int('insert_time', -1)))
+
+        return root
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        game_config = self.get_game_config()
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Save base player profile info
+        newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('pdata/account/lid')))
+        newprofile.replace_str('name', request.child_value('pdata/base/name'))
+        newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
+        newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
+        newprofile.replace_int('uattr', request.child_value('pdata/base/uattr'))
+        newprofile.replace_int('money', request.child_value('pdata/base/money'))
+        newprofile.replace_int('class', request.child_value('pdata/base/class'))
+        newprofile.replace_int('class_ar', request.child_value('pdata/base/class_ar'))
+        newprofile.replace_int('skill_point', request.child_value('pdata/base/skill_point'))
+        newprofile.replace_int('mgid', request.child_value('pdata/minigame/mgid'))
+        newprofile.replace_int('mgsc', request.child_value('pdata/minigame/sc'))
+        newprofile.replace_int_array('favorites', 30, request.child_value('pdata/mylist/list/mlst'))
+
+        # Save player config
+        configdict = newprofile.get_dict('config')
+        config = request.child('pdata/config')
+        if config:
+            configdict.replace_int('msel_bgm', config.child_value('msel_bgm'))
+            configdict.replace_int('narrowdown_type', config.child_value('narrowdown_type'))
+            configdict.replace_int('icon_id', config.child_value('icon_id'))
+            configdict.replace_int('byword_0', config.child_value('byword_0'))
+            configdict.replace_int('byword_1', config.child_value('byword_1'))
+            configdict.replace_bool('is_auto_byword_0', config.child_value('is_auto_byword_0'))
+            configdict.replace_bool('is_auto_byword_1', config.child_value('is_auto_byword_1'))
+            configdict.replace_int('mrec_type', config.child_value('mrec_type'))
+            configdict.replace_int('tab_sel', config.child_value('tab_sel'))
+            configdict.replace_int('card_disp', config.child_value('card_disp'))
+            configdict.replace_int('score_tab_disp', config.child_value('score_tab_disp'))
+            configdict.replace_int('last_music_id', config.child_value('last_music_id'))
+            configdict.replace_int('last_note_grade', config.child_value('last_note_grade'))
+            configdict.replace_int('sort_type', config.child_value('sort_type'))
+            configdict.replace_int('rival_panel_type', config.child_value('rival_panel_type'))
+            configdict.replace_int('random_entry_work', config.child_value('random_entry_work'))
+            configdict.replace_int('custom_folder_work', config.child_value('custom_folder_work'))
+            configdict.replace_int('folder_type', config.child_value('folder_type'))
+            configdict.replace_int('folder_lamp_type', config.child_value('folder_lamp_type'))
+            configdict.replace_bool('is_tweet', config.child_value('is_tweet'))
+            configdict.replace_bool('is_link_twitter', config.child_value('is_link_twitter'))
+        newprofile.replace_dict('config', configdict)
+
+        # Save player custom settings
+        customdict = newprofile.get_dict('custom')
+        custom = request.child('pdata/custom')
+        if custom:
+            customdict.replace_int('st_shot', custom.child_value('st_shot'))
+            customdict.replace_int('st_frame', custom.child_value('st_frame'))
+            customdict.replace_int('st_expl', custom.child_value('st_expl'))
+            customdict.replace_int('st_bg', custom.child_value('st_bg'))
+            customdict.replace_int('st_shot_vol', custom.child_value('st_shot_vol'))
+            customdict.replace_int('st_bg_bri', custom.child_value('st_bg_bri'))
+            customdict.replace_int('st_obj_size', custom.child_value('st_obj_size'))
+            customdict.replace_int('st_jr_gauge', custom.child_value('st_jr_gauge'))
+            customdict.replace_int('st_clr_gauge', custom.child_value('st_clr_gauge'))
+            customdict.replace_int('st_gr_gauge_type', custom.child_value('st_gr_gauge_type'))
+            customdict.replace_int('voice_message_set', custom.child_value('voice_message_set'))
+            customdict.replace_int('same_time_note_disp', custom.child_value('same_time_note_disp'))
+            customdict.replace_int('st_score_disp_type', custom.child_value('st_score_disp_type'))
+            customdict.replace_int('st_bonus_type', custom.child_value('st_bonus_type'))
+            customdict.replace_int('st_rivalnote_type', custom.child_value('st_rivalnote_type'))
+            customdict.replace_int('st_topassist_type', custom.child_value('st_topassist_type'))
+            customdict.replace_int('high_speed', custom.child_value('high_speed'))
+            customdict.replace_int('st_hazard', custom.child_value('st_hazard'))
+            customdict.replace_int('st_clr_cond', custom.child_value('st_clr_cond'))
+            customdict.replace_int('voice_message_volume', custom.child_value('voice_message_volume'))
+        newprofile.replace_dict('custom', customdict)
+
+        # Save player parameter info
+        params = request.child('pdata/player_param')
+        if params:
+            for child in params.children:
+                if child.name != 'item':
+                    continue
+
+                item_type = child.child_value('type')
+                bank = child.child_value('bank')
+                data = child.child_value('data')
+                while len(data) < 256:
+                    data.append(0)
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    bank,
+                    'player_param_{}'.format(item_type),
+                    {
+                        'data': data,
+                    },
+                )
+
+        # Save player episode info
+        episode = request.child('pdata/episode')
+        if episode:
+            for child in episode.children:
+                if child.name != 'info':
+                    continue
+
+                # I assume this is copypasta, but I want to be sure
+                extid = child.child_value('user_id')
+                if extid != newprofile.get_int('extid'):
+                    raise Exception('Unexpected user ID, got {} expecting {}'.format(extid, newprofile.get_int('extid')))
+
+                episode_type = child.child_value('type')
+                episode_value0 = child.child_value('value0')
+                episode_value1 = child.child_value('value1')
+                episode_text = child.child_value('text')
+                episode_time = child.child_value('time')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    episode_type,
+                    'episode',
+                    {
+                        'value0': episode_value0,
+                        'value1': episode_value1,
+                        'text': episode_text,
+                        'time': episode_time,
+                    },
+                )
+
+        # Save released info
+        released = request.child('pdata/released')
+        if released:
+            for child in released.children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                time = child.child_value('insert_time') or Time.now()
+                if game_config.get_bool('force_unlock_songs') and item_type == 0:
+                    # Don't save unlocks when we're force unlocking
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                        'time': time,
+                    },
+                )
+
+        # Save announce info
+        announce = request.child('pdata/announce')
+        if announce:
+            for child in announce.children:
+                if child.name != 'info':
+                    continue
+
+                announce_id = child.child_value('id')
+                announce_type = child.child_value('type')
+                param = child.child_value('param')
+                need = child.child_value('bneedannounce')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    announce_id,
+                    'announcement_{}'.format(announce_type),
+                    {
+                        'param': param,
+                        'need': need,
+                    },
+                )
+
+        # Grab any new records set during this play session
+        songplays = request.child('pdata/stglog')
+        if songplays:
+            for child in songplays.children:
+                if child.name != 'log':
+                    continue
+
+                songid = child.child_value('mid')
+                chart = child.child_value('ng')
+                clear_type = child.child_value('ct')
+                if songid == 0 and chart == 0 and clear_type == -1:
+                    # Dummy song save during profile create
+                    continue
+
+                points = child.child_value('sc')
+                achievement_rate = child.child_value('ar')
+                param = child.child_value('param')
+                miss_count = child.child_value('jt_ms')
+                k_flag = child.child_value('k_flag')
+
+                # Param is some random bits along with the combo type
+                combo_type = param & 0x3
+                param = param ^ combo_type
+
+                clear_type = self._game_to_db_clear_type(clear_type)
+                combo_type = self._game_to_db_combo_type(combo_type, miss_count)
+                self.update_score(
+                    userid,
+                    songid,
+                    chart,
+                    points,
+                    achievement_rate,
+                    clear_type,
+                    combo_type,
+                    miss_count,
+                    param=param,
+                    kflag=k_flag,
+                )
+
+        # Grab any new rivals added during this play session
+        rivalnode = request.child('pdata/rival')
+        if rivalnode:
+            for child in rivalnode.children:
+                if child.name != 'r':
+                    continue
+
+                extid = child.child_value('id')
+                other_userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+                if other_userid is None:
+                    continue
+
+                self.data.local.user.put_link(
+                    self.game,
+                    self.version,
+                    userid,
+                    'rival',
+                    other_userid,
+                    {},
+                )
+
+        # Save player dojo
+        dojo = request.child('pdata/dojo')
+        if dojo:
+            dojoid = dojo.child_value('class')
+            clear_type = dojo.child_value('clear_type')
+            ar = dojo.child_value('t_ar')
+            score = dojo.child_value('t_score')
+
+            # Figure out timestamp stuff
+            data = self.data.local.user.get_achievement(
+                self.game,
+                self.version,
+                userid,
+                dojoid,
+                'dojo',
+            ) or ValidatedDict()
+
+            if ar >= data.get_int('ar'):
+                # We set a new achievement rate, keep the new values
+                record_time = Time.now()
+            else:
+                # We didn't, keep the old values for achievement rate, but
+                # override score and clear_type only if they were better.
+                record_time = data.get_int('record_timestamp')
+                ar = data.get_int('ar')
+                score = max(score, data.get_int('score'))
+                clear_type = max(clear_type, data.get_int('clear_type'))
+
+            play_time = Time.now()
+            plays = data.get_int('plays') + 1
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                dojoid,
+                'dojo',
+                {
+                    'clear_type': clear_type,
+                    'ar': ar,
+                    'score': score,
+                    'plays': plays,
+                    'play_timestamp': play_time,
+                    'record_timestamp': record_time,
+                },
+            )
+
+        # Save yurukome stuff
+        yurukome_list = request.child('pdata/yurukome_list')
+        if yurukome_list:
+            for child in yurukome_list.children:
+                if child.name != 'yurukome':
+                    continue
+
+                yurukome_id = child.child_value('yurukome_id')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    yurukome_id,
+                    'yurukome',
+                    {},
+                )
+
+        # Save mycourse stuff
+        mycoursedict = newprofile.get_dict('mycourse')
+        mycourse = request.child('pdata/mycourse')
+        if mycourse:
+            # Only replace course if it was a new record score-wise.
+            score_1 = mycourse.child_value('score_1')
+            score_2 = mycourse.child_value('score_2')
+            score_3 = mycourse.child_value('score_3')
+            score_4 = mycourse.child_value('score_4')
+            total = 0
+            for score in [score_1, score_2, score_3, score_4]:
+                if score is not None and score >= 0:
+                    total = total + score
+
+            oldtotal = (
+                mycoursedict.get_int('score_1', 0) +
+                mycoursedict.get_int('score_2', 0) +
+                mycoursedict.get_int('score_3', 0) +
+                mycoursedict.get_int('score_4', 0)
+            )
+
+            if total >= oldtotal:
+                mycoursedict.replace_int('music_id_1', mycourse.child_value('music_id_1'))
+                mycoursedict.replace_int('note_grade_1', mycourse.child_value('note_grade_1'))
+                mycoursedict.replace_int('score_1', score_1)
+                mycoursedict.replace_int('music_id_2', mycourse.child_value('music_id_2'))
+                mycoursedict.replace_int('note_grade_2', mycourse.child_value('note_grade_2'))
+                mycoursedict.replace_int('score_2', score_2)
+                mycoursedict.replace_int('music_id_3', mycourse.child_value('music_id_3'))
+                mycoursedict.replace_int('note_grade_3', mycourse.child_value('note_grade_3'))
+                mycoursedict.replace_int('score_3', score_3)
+                mycoursedict.replace_int('music_id_4', mycourse.child_value('music_id_4'))
+                mycoursedict.replace_int('note_grade_4', mycourse.child_value('note_grade_4'))
+                mycoursedict.replace_int('score_4', score_4)
+                mycoursedict.replace_int('insert_time', Time.now())
+        newprofile.replace_dict('mycourse', mycoursedict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/reflec/volzzabase.py b/bemani/backend/reflec/volzzabase.py
new file mode 100644
index 0000000..c3630b7
--- /dev/null
+++ b/bemani/backend/reflec/volzzabase.py
@@ -0,0 +1,504 @@
+from typing import Dict, List, Tuple
+
+from bemani.backend.reflec.base import ReflecBeatBase
+
+from bemani.common import ID, Time, ValidatedDict
+from bemani.data import Attempt, UserID
+from bemani.protocol import Node
+
+
+class ReflecBeatVolzzaBase(ReflecBeatBase):
+
+    # Clear types according to the game
+    GAME_CLEAR_TYPE_NO_PLAY = 0
+    GAME_CLEAR_TYPE_EARLY_FAILED = 1
+    GAME_CLEAR_TYPE_FAILED = 2
+    GAME_CLEAR_TYPE_CLEARED = 9
+    GAME_CLEAR_TYPE_HARD_CLEARED = 10
+    GAME_CLEAR_TYPE_S_HARD_CLEARED = 11
+
+    # Combo types according to the game (actually a bitmask, where bit 0 is
+    # full combo status, and bit 2 is just reflec status). But we don't support
+    # saving just reflec without full combo, so we downgrade it.
+    GAME_COMBO_TYPE_NONE = 0
+    GAME_COMBO_TYPE_ALL_JUST = 2
+    GAME_COMBO_TYPE_FULL_COMBO = 1
+    GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST = 3
+
+    def _db_to_game_clear_type(self, db_status: int) -> int:
+        return {
+            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_PLAY,
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEARED: self.GAME_CLEAR_TYPE_CLEARED,
+            self.CLEAR_TYPE_HARD_CLEARED: self.GAME_CLEAR_TYPE_HARD_CLEARED,
+            self.CLEAR_TYPE_S_HARD_CLEARED: self.GAME_CLEAR_TYPE_S_HARD_CLEARED,
+        }[db_status]
+
+    def _game_to_db_clear_type(self, status: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_NO_PLAY: self.CLEAR_TYPE_NO_PLAY,
+            self.GAME_CLEAR_TYPE_EARLY_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEARED: self.CLEAR_TYPE_CLEARED,
+            self.GAME_CLEAR_TYPE_HARD_CLEARED: self.CLEAR_TYPE_HARD_CLEARED,
+            self.GAME_CLEAR_TYPE_S_HARD_CLEARED: self.CLEAR_TYPE_S_HARD_CLEARED,
+        }[status]
+
+    def _db_to_game_combo_type(self, db_combo: int) -> int:
+        return {
+            self.COMBO_TYPE_NONE: self.GAME_COMBO_TYPE_NONE,
+            self.COMBO_TYPE_ALMOST_COMBO: self.GAME_COMBO_TYPE_NONE,
+            self.COMBO_TYPE_FULL_COMBO: self.GAME_COMBO_TYPE_FULL_COMBO,
+            self.COMBO_TYPE_FULL_COMBO_ALL_JUST: self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST,
+        }[db_combo]
+
+    def _game_to_db_combo_type(self, game_combo: int, miss_count: int) -> int:
+        if game_combo in [
+            self.GAME_COMBO_TYPE_NONE,
+            self.GAME_COMBO_TYPE_ALL_JUST,
+        ]:
+            if miss_count >= 0 and miss_count <= 2:
+                return self.COMBO_TYPE_ALMOST_COMBO
+            else:
+                return self.COMBO_TYPE_NONE
+        if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO:
+            return self.COMBO_TYPE_FULL_COMBO
+        if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST:
+            return self.COMBO_TYPE_FULL_COMBO_ALL_JUST
+        raise Exception('Invalid game_combo value {}'.format(game_combo))
+
+    def _add_event_info(self, root: Node) -> None:
+        # Overridden in subclasses
+        pass
+
+    def _add_shop_score(self, root: Node) -> None:
+        shop_score = Node.void('shop_score')
+        root.add_child(shop_score)
+        today = Node.void('today')
+        shop_score.add_child(today)
+        yesterday = Node.void('yesterday')
+        shop_score.add_child(yesterday)
+
+        all_profiles = self.data.local.user.get_all_profiles(self.game, self.version)
+        all_attempts = self.data.local.music.get_all_attempts(self.game, self.version, timelimit=(Time.beginning_of_today() - Time.SECONDS_IN_DAY))
+        machine = self.data.local.machine.get_machine(self.config['machine']['pcbid'])
+        if machine.arcade is not None:
+            lids = [
+                machine.id for machine in self.data.local.machine.get_all_machines(machine.arcade)
+            ]
+        else:
+            lids = [machine.id]
+
+        relevant_profiles = [
+            profile for profile in all_profiles
+            if profile[1].get_int('lid', -1) in lids
+        ]
+
+        for (rootnode, timeoffset) in [
+            (today, 0),
+            (yesterday, Time.SECONDS_IN_DAY),
+        ]:
+            # Grab all attempts made in the relevant day
+            relevant_attempts = [
+                attempt for attempt in all_attempts
+                if (
+                    attempt[1].timestamp >= (Time.beginning_of_today() - timeoffset) and
+                    attempt[1].timestamp <= (Time.end_of_today() - timeoffset)
+                )
+            ]
+
+            # Calculate scores based on attempt
+            scores_by_user: Dict[UserID, Dict[int, Dict[int, Attempt]]] = {}
+            for (userid, attempt) in relevant_attempts:
+                if userid not in scores_by_user:
+                    scores_by_user[userid] = {}
+                if attempt.id not in scores_by_user[userid]:
+                    scores_by_user[userid][attempt.id] = {}
+                if attempt.chart not in scores_by_user[userid][attempt.id]:
+                    # No high score for this yet, just use this attempt
+                    scores_by_user[userid][attempt.id][attempt.chart] = attempt
+                else:
+                    # If this attempt is better than the stored one, replace it
+                    if scores_by_user[userid][attempt.id][attempt.chart].points < attempt.points:
+                        scores_by_user[userid][attempt.id][attempt.chart] = attempt
+
+            # Calculate points earned by user in the day
+            points_by_user: Dict[UserID, int] = {}
+            for userid in scores_by_user:
+                points_by_user[userid] = 0
+                for mid in scores_by_user[userid]:
+                    for chart in scores_by_user[userid][mid]:
+                        points_by_user[userid] = points_by_user[userid] + scores_by_user[userid][mid][chart].points
+
+            # Output that day's earned points
+            for (userid, profile) in relevant_profiles:
+                data = Node.void('data')
+                rootnode.add_child(data)
+                data.add_child(Node.s16('day_id', int((Time.now() - timeoffset) / Time.SECONDS_IN_DAY)))
+                data.add_child(Node.s32('user_id', profile.get_int('extid')))
+                data.add_child(Node.s16('icon_id', profile.get_dict('config').get_int('icon_id')))
+                data.add_child(Node.s16('point', min(points_by_user.get(userid, 0), 32767)))
+                data.add_child(Node.s32('update_time', Time.now()))
+                data.add_child(Node.string('name', profile.get_str('name')))
+
+            rootnode.add_child(Node.s32('time', Time.beginning_of_today() - timeoffset))
+
+    def handle_info_rb5_info_read_request(self, request: Node) -> Node:
+        root = Node.void('info')
+        self._add_event_info(root)
+
+        return root
+
+    def handle_info_rb5_info_read_hit_chart_request(self, request: Node) -> Node:
+        version = request.child_value('ver')
+
+        root = Node.void('info')
+        root.add_child(Node.s32('ver', version))
+        ranking = Node.void('ranking')
+        root.add_child(ranking)
+
+        def add_hitchart(name: str, start: int, end: int, hitchart: List[Tuple[int, int]]) -> None:
+            base = Node.void(name)
+            ranking.add_child(base)
+            base.add_child(Node.s32('bt', start))
+            base.add_child(Node.s32('et', end))
+            new = Node.void('new')
+            base.add_child(new)
+
+            for (mid, plays) in hitchart:
+                d = Node.void('d')
+                new.add_child(d)
+                d.add_child(Node.s16('mid', mid))
+                d.add_child(Node.s32('cnt', plays))
+
+        # Weekly hit chart
+        add_hitchart(
+            'weekly',
+            Time.now() - Time.SECONDS_IN_WEEK,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 7),
+        )
+
+        # Monthly hit chart
+        add_hitchart(
+            'monthly',
+            Time.now() - Time.SECONDS_IN_DAY * 30,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 30),
+        )
+
+        # All time hit chart
+        add_hitchart(
+            'total',
+            Time.now() - Time.SECONDS_IN_DAY * 365,
+            Time.now(),
+            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 365),
+        )
+
+        return root
+
+    def handle_info_rb5_info_read_shop_ranking_request(self, request: Node) -> Node:
+        start_music_id = request.child_value('min')
+        end_music_id = request.child_value('max')
+
+        root = Node.void('info')
+        shop_score = Node.void('shop_score')
+        root.add_child(shop_score)
+        shop_score.add_child(Node.s32('time', Time.now()))
+
+        profiles: Dict[UserID, ValidatedDict] = {}
+        for songid in range(start_music_id, end_music_id + 1):
+            allscores = self.data.local.music.get_all_scores(
+                self.game,
+                self.version,
+                songid=songid,
+            )
+
+            for ng in [
+                self.CHART_TYPE_BASIC,
+                self.CHART_TYPE_MEDIUM,
+                self.CHART_TYPE_HARD,
+                self.CHART_TYPE_SPECIAL,
+            ]:
+                scores = sorted(
+                    [score for score in allscores if score[1].chart == ng],
+                    key=lambda score: score[1].points,
+                    reverse=True,
+                )
+
+                for i in range(len(scores)):
+                    userid, score = scores[i]
+                    if userid not in profiles:
+                        profiles[userid] = self.get_any_profile(userid)
+                    profile = profiles[userid]
+
+                    data = Node.void('data')
+                    shop_score.add_child(data)
+                    data.add_child(Node.s32('rank', i + 1))
+                    data.add_child(Node.s16('music_id', songid))
+                    data.add_child(Node.s8('note_grade', score.chart))
+                    data.add_child(Node.s8('clear_type', self._db_to_game_clear_type(score.data.get_int('clear_type'))))
+                    data.add_child(Node.s32('user_id', profile.get_int('extid')))
+                    data.add_child(Node.s16('icon_id', profile.get_dict('config').get_int('icon_id')))
+                    data.add_child(Node.s32('score', score.points))
+                    data.add_child(Node.s32('time', score.timestamp))
+                    data.add_child(Node.string('name', profile.get_str('name')))
+
+        return root
+
+    def handle_lobby_rb5_lobby_entry_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Create a lobby entry for this user
+        extid = request.child_value('e/uid')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            profile = self.get_profile(userid)
+            info = self.data.local.lobby.get_play_session_info(self.game, self.version, userid)
+            if profile is None or info is None:
+                return root
+
+            self.data.local.lobby.put_lobby(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'mid': request.child_value('e/mid'),
+                    'ng': request.child_value('e/ng'),
+                    'mopt': request.child_value('e/mopt'),
+                    'lid': request.child_value('e/lid'),
+                    'sn': request.child_value('e/sn'),
+                    'pref': request.child_value('e/pref'),
+                    'stg': request.child_value('e/stg'),
+                    'pside': request.child_value('e/pside'),
+                    'eatime': request.child_value('e/eatime'),
+                    'ga': request.child_value('e/ga'),
+                    'gp': request.child_value('e/gp'),
+                    'la': request.child_value('e/la'),
+                    'ver': request.child_value('e/ver'),
+                }
+            )
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            root.add_child(Node.s32('eid', lobby.get_int('id')))
+            e = Node.void('e')
+            root.add_child(e)
+            e.add_child(Node.s32('eid', lobby.get_int('id')))
+            e.add_child(Node.u16('mid', lobby.get_int('mid')))
+            e.add_child(Node.u8('ng', lobby.get_int('ng')))
+            e.add_child(Node.s32('uid', profile.get_int('extid')))
+            e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+            e.add_child(Node.string('pn', profile.get_str('name')))
+            e.add_child(Node.s32('plyid', info.get_int('id')))
+            e.add_child(Node.s16('mg', profile.get_int('mg')))
+            e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+            e.add_child(Node.string('lid', lobby.get_str('lid')))
+            e.add_child(Node.string('sn', lobby.get_str('sn')))
+            e.add_child(Node.u8('pref', lobby.get_int('pref')))
+            e.add_child(Node.s8('stg', lobby.get_int('stg')))
+            e.add_child(Node.s8('pside', lobby.get_int('pside')))
+            e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+            e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+            e.add_child(Node.u16('gp', lobby.get_int('gp')))
+            e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+            e.add_child(Node.u8('ver', lobby.get_int('ver')))
+
+        return root
+
+    def handle_lobby_rb5_lobby_read_request(self, request: Node) -> Node:
+        root = Node.void('lobby')
+        root.add_child(Node.s32('interval', 120))
+        root.add_child(Node.s32('interval_p', 120))
+
+        # Look up all lobbies matching the criteria specified
+        ver = request.child_value('var')
+        mg = request.child_value('m_grade')  # noqa: F841
+        extid = request.child_value('uid')
+        limit = request.child_value('max')
+        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
+        if userid is not None:
+            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
+            for (user, lobby) in lobbies:
+                if limit <= 0:
+                    break
+
+                if user == userid:
+                    # If we have our own lobby, don't return it
+                    continue
+                if ver != lobby.get_int('ver'):
+                    # Don't return lobby data for different versions
+                    continue
+
+                profile = self.get_profile(user)
+                info = self.data.local.lobby.get_play_session_info(self.game, self.version, userid)
+                if profile is None or info is None:
+                    # No profile info, don't return this lobby
+                    return root
+
+                e = Node.void('e')
+                root.add_child(e)
+                e.add_child(Node.s32('eid', lobby.get_int('id')))
+                e.add_child(Node.u16('mid', lobby.get_int('mid')))
+                e.add_child(Node.u8('ng', lobby.get_int('ng')))
+                e.add_child(Node.s32('uid', profile.get_int('extid')))
+                e.add_child(Node.s32('uattr', profile.get_int('uattr')))
+                e.add_child(Node.string('pn', profile.get_str('name')))
+                e.add_child(Node.s32('plyid', info.get_int('id')))
+                e.add_child(Node.s16('mg', profile.get_int('mg')))
+                e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
+                e.add_child(Node.string('lid', lobby.get_str('lid')))
+                e.add_child(Node.string('sn', lobby.get_str('sn')))
+                e.add_child(Node.u8('pref', lobby.get_int('pref')))
+                e.add_child(Node.s8('stg', lobby.get_int('stg')))
+                e.add_child(Node.s8('pside', lobby.get_int('pside')))
+                e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
+                e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
+                e.add_child(Node.u16('gp', lobby.get_int('gp')))
+                e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
+                e.add_child(Node.u8('ver', lobby.get_int('ver')))
+
+                limit = limit - 1
+
+        return root
+
+    def handle_lobby_rb5_lobby_delete_entry_request(self, request: Node) -> Node:
+        eid = request.child_value('eid')
+        self.data.local.lobby.destroy_lobby(eid)
+        return Node.void('lobby')
+
+    def handle_pcb_rb5_pcb_boot_request(self, request: Node) -> Node:
+        shop_id = ID.parse_machine_id(request.child_value('lid'))
+        machine = self.get_machine_by_id(shop_id)
+        if machine is not None:
+            machine_name = machine.name
+            close = machine.data.get_bool('close')
+            hour = machine.data.get_int('hour')
+            minute = machine.data.get_int('minute')
+        else:
+            machine_name = ''
+            close = False
+            hour = 0
+            minute = 0
+
+        root = Node.void('pcb')
+        sinfo = Node.void('sinfo')
+        root.add_child(sinfo)
+        sinfo.add_child(Node.string('nm', machine_name))
+        sinfo.add_child(Node.bool('cl_enbl', close))
+        sinfo.add_child(Node.u8('cl_h', hour))
+        sinfo.add_child(Node.u8('cl_m', minute))
+        sinfo.add_child(Node.bool('shop_flag', True))
+        return root
+
+    def handle_pcb_rb5_pcb_error_request(self, request: Node) -> Node:
+        return Node.void('pcb')
+
+    def handle_pcb_rb5_pcb_update_request(self, request: Node) -> Node:
+        return Node.void('pcb')
+
+    def handle_shop_rb5_shop_write_setting_request(self, request: Node) -> Node:
+        return Node.void('shop')
+
+    def handle_shop_rb5_shop_write_info_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('sinfo/nm'))
+        self.update_machine_data({
+            'close': request.child_value('sinfo/cl_enbl'),
+            'hour': request.child_value('sinfo/cl_h'),
+            'minute': request.child_value('sinfo/cl_m'),
+            'pref': request.child_value('sinfo/prf'),
+        })
+        return Node.void('shop')
+
+    def handle_player_rb5_player_start_request(self, request: Node) -> Node:
+        root = Node.void('player')
+
+        # Create a new play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            self.data.local.lobby.put_play_session_info(
+                self.game,
+                self.version,
+                userid,
+                {
+                    'ga': request.child_value('ga'),
+                    'gp': request.child_value('gp'),
+                    'la': request.child_value('la'),
+                    'pnid': request.child_value('pnid'),
+                },
+            )
+            info = self.data.local.lobby.get_play_session_info(
+                self.game,
+                self.version,
+                userid,
+            )
+            if info is not None:
+                play_id = info.get_int('id')
+            else:
+                play_id = 0
+        else:
+            play_id = 0
+
+        # Session stuff, and resend global defaults
+        root.add_child(Node.s32('plyid', play_id))
+        root.add_child(Node.u64('start_time', Time.now() * 1000))
+        self._add_event_info(root)
+
+        return root
+
+    def handle_player_rb5_player_end_request(self, request: Node) -> Node:
+        # Destroy play session based on info from the request
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            # Kill any lingering lobbies by this user
+            lobby = self.data.local.lobby.get_lobby(
+                self.game,
+                self.version,
+                userid,
+            )
+            if lobby is not None:
+                self.data.local.lobby.destroy_lobby(lobby.get_int('id'))
+            self.data.local.lobby.destroy_play_session_info(self.game, self.version, userid)
+
+        return Node.void('player')
+
+    def handle_player_rb5_player_delete_request(self, request: Node) -> Node:
+        return Node.void('player')
+
+    def handle_player_rb5_player_succeed_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        if userid is not None:
+            previous_version = self.previous_version()
+            profile = previous_version.get_profile(userid)
+        else:
+            profile = None
+
+        root = Node.void('player')
+
+        if profile is None:
+            # Return empty succeed to say this is new
+            root.add_child(Node.string('name', ''))
+            root.add_child(Node.s32('grd', -1))
+            root.add_child(Node.s32('ap', -1))
+            root.add_child(Node.s32('uattr', 0))
+        else:
+            # Return previous profile formatted to say this is data succession
+            root.add_child(Node.string('name', profile.get_str('name')))
+            root.add_child(Node.s32('grd', profile.get_int('mg')))  # This is a guess
+            root.add_child(Node.s32('ap', profile.get_int('ap')))
+            root.add_child(Node.s32('uattr', profile.get_int('uattr')))
+        return root
+
+    def handle_player_rb5_player_read_request(self, request: Node) -> Node:
+        refid = request.child_value('rid')
+        profile = self.get_profile_by_refid(refid)
+        if profile:
+            return profile
+        return Node.void('player')
diff --git a/bemani/backend/sdvx/__init__.py b/bemani/backend/sdvx/__init__.py
new file mode 100644
index 0000000..4d87b35
--- /dev/null
+++ b/bemani/backend/sdvx/__init__.py
@@ -0,0 +1,2 @@
+from bemani.backend.sdvx.factory import SoundVoltexFactory
+from bemani.backend.sdvx.base import SoundVoltexBase
diff --git a/bemani/backend/sdvx/base.py b/bemani/backend/sdvx/base.py
new file mode 100644
index 0000000..c6c99e0
--- /dev/null
+++ b/bemani/backend/sdvx/base.py
@@ -0,0 +1,291 @@
+# vim: set fileencoding=utf-8
+from typing import Dict, Optional
+
+from bemani.backend.base import Base
+from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
+from bemani.common import ValidatedDict, GameConstants, DBConstants, Parallel
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class SoundVoltexBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
+    """
+    Base game class for all Sound Voltex version that we support.
+    """
+
+    game = GameConstants.SDVX
+
+    CLEAR_TYPE_NO_PLAY = DBConstants.SDVX_CLEAR_TYPE_NO_PLAY
+    CLEAR_TYPE_FAILED = DBConstants.SDVX_CLEAR_TYPE_FAILED
+    CLEAR_TYPE_CLEAR = DBConstants.SDVX_CLEAR_TYPE_CLEAR
+    CLEAR_TYPE_HARD_CLEAR = DBConstants.SDVX_CLEAR_TYPE_HARD_CLEAR
+    CLEAR_TYPE_ULTIMATE_CHAIN = DBConstants.SDVX_CLEAR_TYPE_ULTIMATE_CHAIN
+    CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN = DBConstants.SDVX_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN
+
+    GRADE_NO_PLAY = DBConstants.SDVX_GRADE_NO_PLAY
+    GRADE_D = DBConstants.SDVX_GRADE_D
+    GRADE_C = DBConstants.SDVX_GRADE_C
+    GRADE_B = DBConstants.SDVX_GRADE_B
+    GRADE_A = DBConstants.SDVX_GRADE_A
+    GRADE_A_PLUS = DBConstants.SDVX_GRADE_A_PLUS
+    GRADE_AA = DBConstants.SDVX_GRADE_AA
+    GRADE_AA_PLUS = DBConstants.SDVX_GRADE_AA_PLUS
+    GRADE_AAA = DBConstants.SDVX_GRADE_AAA
+    GRADE_AAA_PLUS = DBConstants.SDVX_GRADE_AAA_PLUS
+    GRADE_S = DBConstants.SDVX_GRADE_S
+
+    CHART_TYPE_NOVICE = 0
+    CHART_TYPE_ADVANCED = 1
+    CHART_TYPE_EXHAUST = 2
+    CHART_TYPE_INFINITE = 3
+    CHART_TYPE_MAXIMUM = 4
+
+    def previous_version(self) -> Optional['SoundVoltexBase']:
+        """
+        Returns the previous version of the game, based on this game. Should
+        be overridden.
+        """
+        return None
+
+    def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
+        """
+        Given a RefID, return a formatted profile node. Basically every game
+        needs a profile lookup, even if it handles where that happens in
+        a different request. This is provided for code deduplication.
+        """
+        if refid is None:
+            return None
+
+        # First try to load the actual profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        profile = self.get_profile(userid)
+        if profile is None:
+            return None
+
+        # Now, return it
+        return self.format_profile(userid, profile)
+
+    def new_profile_by_refid(self, refid: Optional[str], name: Optional[str], locid: Optional[int]) -> Node:
+        """
+        Given a RefID and an optional name, create a profile and then return
+        a formatted profile node. Similar rationale to get_profile_by_refid.
+        """
+        if refid is None:
+            return None
+
+        if name is None:
+            name = 'NONAME'
+
+        # First, create and save the default profile
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        defaultprofile = ValidatedDict({
+            'name': name,
+            'loc': locid,
+        })
+        self.put_profile(userid, defaultprofile)
+
+        # Now, reload and format the profile, looking up the has old version flag
+        profile = self.get_profile(userid)
+        return self.format_profile(userid, profile)
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        """
+        Base handler for a profile. Given a userid and a profile dictionary,
+        return a Node representing a profile. Should be overridden.
+        """
+        return Node.void('game')
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        """
+        Base handler for profile parsing. Given a request and an old profile,
+        return a new profile that's been updated with the contents of the request.
+        Should be overridden.
+        """
+        return oldprofile
+
+    def get_clear_rates(self) -> Dict[int, Dict[int, Dict[str, int]]]:
+        """
+        Returns a dictionary similar to the following:
+
+        {
+            musicid: {
+                chart: {
+                    total: total plays,
+                    clears: total clears,
+                    average: average score,
+                },
+            },
+        }
+        """
+        all_attempts, remote_attempts = Parallel.execute([
+            lambda: self.data.local.music.get_all_attempts(
+                game=self.game,
+                version=self.version,
+            ),
+            lambda: self.data.remote.music.get_clear_rates(
+                game=self.game,
+                version=self.version,
+            )
+        ])
+        attempts: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for (_, attempt) in all_attempts:
+            # Terrible temporary structure is terrible.
+            if attempt.id not in attempts:
+                attempts[attempt.id] = {}
+            if attempt.chart not in attempts[attempt.id]:
+                attempts[attempt.id][attempt.chart] = {
+                    'total': 0,
+                    'clears': 0,
+                    'average': 0,
+                }
+
+            # We saw an attempt, keep the total attempts in sync.
+            attempts[attempt.id][attempt.chart]['average'] = int(
+                (
+                    (attempts[attempt.id][attempt.chart]['average'] * attempts[attempt.id][attempt.chart]['total']) +
+                    attempt.points
+                ) / (attempts[attempt.id][attempt.chart]['total'] + 1)
+            )
+            attempts[attempt.id][attempt.chart]['total'] += 1
+
+            if attempt.data.get_int('clear_type', self.CLEAR_TYPE_NO_PLAY) in [self.CLEAR_TYPE_NO_PLAY, self.CLEAR_TYPE_FAILED]:
+                # This attempt was a failure, so don't count it against clears of full combos
+                continue
+
+            # It was at least a clear
+            attempts[attempt.id][attempt.chart]['clears'] += 1
+
+        # Merge in remote attempts
+        for songid in remote_attempts:
+            if songid not in attempts:
+                attempts[songid] = {}
+
+            for songchart in remote_attempts[songid]:
+                if songchart not in attempts[songid]:
+                    attempts[songid][songchart] = {
+                        'total': 0,
+                        'clears': 0,
+                        'average': 0,
+                    }
+
+                attempts[songid][songchart]['total'] += remote_attempts[songid][songchart]['plays']
+                attempts[songid][songchart]['clears'] += remote_attempts[songid][songchart]['clears']
+
+        return attempts
+
+    def update_score(
+        self,
+        userid: Optional[UserID],
+        songid: int,
+        chart: int,
+        points: int,
+        clear_type: int,
+        grade: int,
+        combo: int,
+        stats: Optional[Dict[str, int]]=None,
+    ) -> None:
+        """
+        Given various pieces of a score, update the user's high score and score
+        history in a controlled manner, so all games in SDVX series can expect
+        the same attributes in a score.
+        """
+        # Range check clear type
+        if clear_type not in [
+            self.CLEAR_TYPE_NO_PLAY,
+            self.CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEAR,
+            self.CLEAR_TYPE_HARD_CLEAR,
+            self.CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        ]:
+            raise Exception("Invalid clear type value {}".format(clear_type))
+
+        #  Range check grade
+        if grade not in [
+            self.GRADE_NO_PLAY,
+            self.GRADE_D,
+            self.GRADE_C,
+            self.GRADE_B,
+            self.GRADE_A,
+            self.GRADE_A_PLUS,
+            self.GRADE_AA,
+            self.GRADE_AA_PLUS,
+            self.GRADE_AAA,
+            self.GRADE_AAA_PLUS,
+            self.GRADE_S,
+        ]:
+            raise Exception("Invalid clear type value {}".format(grade))
+
+        if userid is not None:
+            oldscore = self.data.local.music.get_score(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                chart,
+            )
+        else:
+            oldscore = None
+
+        # Score history is verbatum, instead of highest score
+        history = ValidatedDict({})
+        oldpoints = points
+
+        if oldscore is None:
+            # If it is a new score, create a new dictionary to add to
+            scoredata = ValidatedDict({})
+            raised = True
+            highscore = True
+        else:
+            # Set the score to any new record achieved
+            raised = points > oldscore.points
+            highscore = points >= oldscore.points
+            points = max(oldscore.points, points)
+            scoredata = oldscore.data
+
+        # Replace clear type and grade
+        scoredata.replace_int('clear_type', max(scoredata.get_int('clear_type'), clear_type))
+        history.replace_int('clear_type', clear_type)
+        scoredata.replace_int('grade', max(scoredata.get_int('grade'), grade))
+        history.replace_int('grade', grade)
+
+        # If we have a combo, replace it
+        scoredata.replace_int('combo', max(scoredata.get_int('combo'), combo))
+        history.replace_int('combo', combo)
+
+        # If we have play stats, replace it
+        if stats is not None:
+            if raised:
+                # We have stats, and there's a new high score, update the stats
+                scoredata.replace_dict('stats', stats)
+            history.replace_dict('stats', stats)
+
+        # Look up where this score was earned
+        lid = self.get_machine_id()
+
+        if userid is not None:
+            # Write the new score back
+            self.data.local.music.put_score(
+                self.game,
+                self.version,
+                userid,
+                songid,
+                chart,
+                lid,
+                points,
+                scoredata,
+                highscore,
+            )
+
+        # Save the history of this score too
+        self.data.local.music.put_attempt(
+            self.game,
+            self.version,
+            userid,
+            songid,
+            chart,
+            lid,
+            oldpoints,
+            history,
+            raised,
+        )
diff --git a/bemani/backend/sdvx/booth.py b/bemani/backend/sdvx/booth.py
new file mode 100644
index 0000000..57c9cae
--- /dev/null
+++ b/bemani/backend/sdvx/booth.py
@@ -0,0 +1,522 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, Optional, Tuple
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.sdvx.base import SoundVoltexBase
+from bemani.common import ValidatedDict, VersionConstants, ID, intish
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class SoundVoltexBooth(
+    EventLogHandler,
+    SoundVoltexBase,
+):
+
+    name = 'SOUND VOLTEX BOOTH'
+    version = VersionConstants.SDVX_BOOTH
+
+    GAME_LIMITED_LOCKED = 1
+    GAME_LIMITED_UNLOCKED = 2
+
+    GAME_CURRENCY_PACKETS = 0
+    GAME_CURRENCY_BLOCKS = 1
+
+    GAME_CLEAR_TYPE_NO_CLEAR = 1
+    GAME_CLEAR_TYPE_CLEAR = 2
+    GAME_CLEAR_TYPE_ULTIMATE_CHAIN = 3
+    GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN = 4
+
+    GAME_GRADE_NO_PLAY = 0
+    GAME_GRADE_D = 1
+    GAME_GRADE_C = 2
+    GAME_GRADE_B = 3
+    GAME_GRADE_A = 4
+    GAME_GRADE_AA = 5
+    GAME_GRADE_AAA = 6
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Disable Online Matching',
+                    'tip': 'Disable online matching between games.',
+                    'category': 'game_config',
+                    'setting': 'disable_matching',
+                },
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+                {
+                    'name': 'Force Appeal Card Unlock',
+                    'tip': 'Force unlock all appeal cards.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_cards',
+                },
+            ],
+        }
+
+    def previous_version(self) -> Optional[SoundVoltexBase]:
+        return None
+
+    def __game_to_db_clear_type(self, clear_type: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_NO_CLEAR: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEAR: self.CLEAR_TYPE_CLEAR,
+            self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN: self.CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __db_to_game_clear_type(self, clear_type: int) -> int:
+        return {
+            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_CLEAR,
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_NO_CLEAR,
+            self.CLEAR_TYPE_CLEAR: self.GAME_CLEAR_TYPE_CLEAR,
+            self.CLEAR_TYPE_HARD_CLEAR: self.GAME_CLEAR_TYPE_CLEAR,
+            self.CLEAR_TYPE_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __game_to_db_grade(self, grade: int) -> int:
+        return {
+            self.GAME_GRADE_NO_PLAY: self.GRADE_NO_PLAY,
+            self.GAME_GRADE_D: self.GRADE_D,
+            self.GAME_GRADE_C: self.GRADE_C,
+            self.GAME_GRADE_B: self.GRADE_B,
+            self.GAME_GRADE_A: self.GRADE_A,
+            self.GAME_GRADE_AA: self.GRADE_AA,
+            self.GAME_GRADE_AAA: self.GRADE_AAA,
+        }[grade]
+
+    def __db_to_game_grade(self, grade: int) -> int:
+        return {
+            self.GRADE_NO_PLAY: self.GAME_GRADE_NO_PLAY,
+            self.GRADE_D: self.GAME_GRADE_D,
+            self.GRADE_C: self.GAME_GRADE_C,
+            self.GRADE_B: self.GAME_GRADE_B,
+            self.GRADE_A: self.GAME_GRADE_A,
+            self.GRADE_A_PLUS: self.GAME_GRADE_A,
+            self.GRADE_AA: self.GAME_GRADE_AA,
+            self.GRADE_AA_PLUS: self.GAME_GRADE_AA,
+            self.GRADE_AAA: self.GAME_GRADE_AAA,
+            self.GRADE_AAA_PLUS: self.GAME_GRADE_AAA,
+            self.GRADE_S: self.GAME_GRADE_AAA,
+        }[grade]
+
+    def handle_game_exception_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+    def handle_game_entry_s_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        # This should be created on the fly for a lobby that we're in.
+        game.add_child(Node.u32('entry_id', 1))
+        return game
+
+    def handle_game_lounge_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        # Refresh interval in seconds.
+        game.add_child(Node.u32('interval', 10))
+        return game
+
+    def handle_game_entry_e_request(self, request: Node) -> Node:
+        # Lobby destroy method, eid attribute (u32) should be used
+        # to destroy any open lobbies.
+        return Node.void('game')
+
+    def handle_game_frozen_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        game.set_attribute('result', '0')
+        return game
+
+    def handle_game_shop_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('shopname'))
+
+        # Respond with number of milliseconds until next request
+        game = Node.void('game')
+        game.add_child(Node.u32('nxt_time', 1000 * 5 * 60))
+        return game
+
+    def handle_game_common_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        limited = Node.void('limited')
+        game.add_child(limited)
+
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_songs'):
+            ids = set()
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.data.get_int('limited') == self.GAME_LIMITED_LOCKED:
+                    ids.add(song.id)
+
+            for songid in ids:
+                music = Node.void('music')
+                limited.add_child(music)
+                music.set_attribute('id', str(songid))
+                music.set_attribute('flag', str(self.GAME_LIMITED_UNLOCKED))
+
+        event = Node.void('event')
+        game.add_child(event)
+
+        def enable_event(eid: int) -> None:
+            evt = Node.void('info')
+            event.add_child(evt)
+            evt.set_attribute('id', str(eid))
+
+        if not game_config.get_bool('disable_matching'):
+            enable_event(3)  # Matching enabled
+        enable_event(9)  # Rank Soukuu
+        enable_event(13)  # Year-end bonus
+
+        catalog = Node.void('catalog')
+        game.add_child(catalog)
+        songunlocks = self.data.local.game.get_items(self.game, self.version)
+        for unlock in songunlocks:
+            if unlock.type != 'song_unlock':
+                continue
+
+            info = Node.void('info')
+            catalog.add_child(info)
+            info.set_attribute('id', str(unlock.id))
+            info.set_attribute('currency', str(self.GAME_CURRENCY_BLOCKS))
+            info.set_attribute('price', str(unlock.data.get_int('blocks')))
+
+        kacinfo = Node.void('kacinfo')
+        game.add_child(kacinfo)
+        kacinfo.add_child(Node.u32('note00', 0))
+        kacinfo.add_child(Node.u32('note01', 0))
+        kacinfo.add_child(Node.u32('note02', 0))
+        kacinfo.add_child(Node.u32('note10', 0))
+        kacinfo.add_child(Node.u32('note11', 0))
+        kacinfo.add_child(Node.u32('note12', 0))
+        kacinfo.add_child(Node.u32('rabbeat0', 0))
+        kacinfo.add_child(Node.u32('rabbeat1', 0))
+
+        return game
+
+    def handle_game_hiscore_request(self, request: Node) -> Node:
+        game = Node.void('game')
+
+        # Ranking system I think?
+        for i in range(1, 21):
+            ranking = Node.void('ranking')
+            game.add_child(ranking)
+            ranking.set_attribute('id', str(i))
+
+        hiscore = Node.void('hiscore')
+        game.add_child(hiscore)
+        hiscore.set_attribute('type', '1')
+
+        records = self.data.remote.music.get_all_records(self.game, self.version)
+
+        # Organize by song->chart
+        records_by_id: Dict[int, Dict[int, Tuple[UserID, Score]]] = {}
+        missing_users = []
+        for record in records:
+            userid, score = record
+            if score.id not in records_by_id:
+                records_by_id[score.id] = {}
+
+            records_by_id[score.id][score.chart] = record
+            missing_users.append(userid)
+
+        users = {userid: profile for (userid, profile) in self.get_any_profiles(missing_users)}
+
+        # Output records
+        for songid in records_by_id:
+            music = Node.void('music')
+            hiscore.add_child(music)
+            music.set_attribute('id', str(songid))
+
+            for chart in records_by_id[songid]:
+                note = Node.void('note')
+                music.add_child(note)
+                note.set_attribute('type', str(chart))
+
+                userid, score = records_by_id[songid][chart]
+                note.set_attribute('score', str(score.points))
+                note.set_attribute('name', users[userid].get_str('name'))
+
+        return game
+
+    def handle_game_new_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+        name = request.attribute('name')
+        loc = ID.parse_machine_id(request.attribute('locid'))
+        self.new_profile_by_refid(refid, name, loc)
+
+        root = Node.void('game')
+        return root
+
+    def handle_game_load_request(self, request: Node) -> Node:
+        refid = request.attribute('dataid')
+        root = self.get_profile_by_refid(refid)
+        if root is None:
+            root = Node.void('game')
+            root.set_attribute('none', '1')
+        return root
+
+    def handle_game_save_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid)
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+        else:
+            newprofile = None
+
+        if userid is not None and newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+        return Node.void('game')
+
+    def handle_game_load_m_request(self, request: Node) -> Node:
+        refid = request.attribute('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        # Organize by song->chart
+        scores_by_id: Dict[int, Dict[int, Score]] = {}
+        for score in scores:
+            if score.id not in scores_by_id:
+                scores_by_id[score.id] = {}
+
+            scores_by_id[score.id][score.chart] = score
+
+        # Output to the game
+        game = Node.void('game')
+        for songid in scores_by_id:
+            music = Node.void('music')
+            game.add_child(music)
+            music.set_attribute('music_id', str(songid))
+
+            for chart in scores_by_id[songid]:
+                typenode = Node.void('type')
+                music.add_child(typenode)
+                typenode.set_attribute('type_id', str(chart))
+
+                score = scores_by_id[songid][chart]
+                typenode.set_attribute('score', str(score.points))
+                typenode.set_attribute('cnt', str(score.plays))
+                typenode.set_attribute('clear_type', str(self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
+                typenode.set_attribute('score_grade', str(self.__db_to_game_grade(score.data.get_int('grade'))))
+
+        return game
+
+    def handle_game_save_m_request(self, request: Node) -> Node:
+        refid = request.attribute('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is None:
+            return Node.void('game')
+
+        musicid = int(request.attribute('music_id'))
+        chart = int(request.attribute('music_type'))
+        score = int(request.attribute('score'))
+        combo = int(request.attribute('max_chain'))
+        grade = self.__game_to_db_grade(int(request.attribute('score_grade')))
+        clear_type = self.__game_to_db_clear_type(int(request.attribute('clear_type')))
+
+        # Save the score
+        self.update_score(
+            userid,
+            musicid,
+            chart,
+            score,
+            clear_type,
+            grade,
+            combo,
+        )
+
+        # No response necessary
+        return Node.void('game')
+
+    def handle_game_buy_request(self, request: Node) -> Node:
+        refid = request.attribute('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            profile = self.get_profile(userid)
+        else:
+            profile = None
+
+        if userid is not None and profile is not None:
+            # Look up packets and blocks
+            packet = profile.get_int('packet')
+            block = profile.get_int('block')
+
+            # Add on any additional we earned this round
+            packet = packet + (request.child_value('earned_gamecoin_packet') or 0)
+            block = block + (request.child_value('earned_gamecoin_block') or 0)
+
+            # Look up the item to get the actual price and currency used
+            item = self.data.local.game.get_item(self.game, self.version, request.child_value('catalog_id'), 'song_unlock')
+            if item is not None:
+                currency_type = request.child_value('currency_type')
+                if currency_type == self.GAME_CURRENCY_PACKETS:
+                    if 'packets' in item:
+                        # This is a valid purchase
+                        newpacket = packet - item.get_int('packets')
+                        if newpacket < 0:
+                            result = 1
+                        else:
+                            packet = newpacket
+                            result = 0
+                    else:
+                        # Bad transaction
+                        result = 1
+                elif currency_type == self.GAME_CURRENCY_BLOCKS:
+                    if 'blocks' in item:
+                        # This is a valid purchase
+                        newblock = block - item.get_int('blocks')
+                        if newblock < 0:
+                            result = 1
+                        else:
+                            block = newblock
+                            result = 0
+                    else:
+                        # Bad transaction
+                        result = 1
+                else:
+                    # Bad currency type
+                    result = 1
+
+                if result == 0:
+                    # Transaction is valid, update the profile with new packets and blocks
+                    profile.replace_int('packet', packet)
+                    profile.replace_int('block', block)
+                    self.put_profile(userid, profile)
+            else:
+                # Bad catalog ID
+                result = 1
+        else:
+            # Unclear what to do here, return a bad response
+            packet = 0
+            block = 0
+            result = 1
+
+        game = Node.void('game')
+        game.add_child(Node.u32('gamecoin_packet', packet))
+        game.add_child(Node.u32('gamecoin_block', block))
+        game.add_child(Node.s8('result', result))
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.u32('exp_point', profile.get_int('exp')))
+        game.add_child(Node.u32('m_user_cnt', profile.get_int('m_user_cnt')))
+
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_cards'):
+            game.add_child(Node.bool_array('have_item', [True] * 512))
+        else:
+            game.add_child(Node.bool_array('have_item', [x > 0 for x in profile.get_int_array('have_item', 512)]))
+        if game_config.get_bool('force_unlock_songs'):
+            game.add_child(Node.bool_array('have_note', [True] * 512))
+        else:
+            game.add_child(Node.bool_array('have_note', [x > 0 for x in profile.get_int_array('have_note', 512)]))
+
+        # Last played stuff
+        lastdict = profile.get_dict('last')
+        last = Node.void('last')
+        game.add_child(last)
+        last.set_attribute('music_id', str(lastdict.get_int('music_id')))
+        last.set_attribute('music_type', str(lastdict.get_int('music_type')))
+        last.set_attribute('sort_type', str(lastdict.get_int('sort_type')))
+        last.set_attribute('headphone', str(lastdict.get_int('headphone')))
+        last.set_attribute('hispeed', str(lastdict.get_int('hispeed')))
+        last.set_attribute('appeal_id', str(lastdict.get_int('appeal_id')))
+        last.set_attribute('frame0', str(lastdict.get_int('frame0')))
+        last.set_attribute('frame1', str(lastdict.get_int('frame1')))
+        last.set_attribute('frame2', str(lastdict.get_int('frame2')))
+        last.set_attribute('frame3', str(lastdict.get_int('frame3')))
+        last.set_attribute('frame4', str(lastdict.get_int('frame4')))
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update experience and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        gain_exp = request.child_value('gain_exp')
+        if gain_exp is not None:
+            newprofile.replace_int('exp', newprofile.get_int('exp') + gain_exp)
+
+        # Miscelaneous stuff
+        newprofile.replace_int('m_user_cnt', request.child_value('m_user_cnt'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+        if not game_config.get_bool('force_unlock_cards'):
+            have_item = request.child_value('have_item')
+            if have_item is not None:
+                newprofile.replace_int_array('have_item', 512, [1 if x else 0 for x in have_item])
+        if not game_config.get_bool('force_unlock_songs'):
+            have_note = request.child_value('have_note')
+            if have_note is not None:
+                newprofile.replace_int_array('have_note', 512, [1 if x else 0 for x in have_note])
+
+        # Grab last information.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('hispeed', request.child_value('hispeed'))
+        lastdict.replace_int('appeal_id', request.child_value('appeal_id'))
+        lastdict.replace_int('frame0', request.child_value('frame0'))
+        lastdict.replace_int('frame1', request.child_value('frame1'))
+        lastdict.replace_int('frame2', request.child_value('frame2'))
+        lastdict.replace_int('frame3', request.child_value('frame3'))
+        lastdict.replace_int('frame4', request.child_value('frame4'))
+        last = request.child('last')
+        if last is not None:
+            lastdict.replace_int('music_id', intish(last.attribute('music_id')))
+            lastdict.replace_int('music_type', intish(last.attribute('music_type')))
+            lastdict.replace_int('sort_type', intish(last.attribute('sort_type')))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/sdvx/factory.py b/bemani/backend/sdvx/factory.py
new file mode 100644
index 0000000..8da7bdf
--- /dev/null
+++ b/bemani/backend/sdvx/factory.py
@@ -0,0 +1,80 @@
+from typing import Any, Dict, Optional
+
+from bemani.backend.base import Base, Factory
+from bemani.backend.sdvx.booth import SoundVoltexBooth
+from bemani.backend.sdvx.infiniteinfection import SoundVoltexInfiniteInfection
+from bemani.backend.sdvx.gravitywars import SoundVoltexGravityWars
+from bemani.backend.sdvx.gravitywars_s1 import SoundVoltexGravityWarsSeason1
+from bemani.backend.sdvx.gravitywars_s2 import SoundVoltexGravityWarsSeason2
+from bemani.backend.sdvx.heavenlyhaven import SoundVoltexHeavenlyHaven
+from bemani.common import Model, VersionConstants
+from bemani.data import Data
+
+
+class SoundVoltexFactory(Factory):
+
+    MANAGED_CLASSES = [
+        SoundVoltexBooth,
+        SoundVoltexInfiniteInfection,
+        SoundVoltexGravityWars,
+        SoundVoltexHeavenlyHaven,
+    ]
+
+    @classmethod
+    def register_all(cls) -> None:
+        for game in ['KFC']:
+            Base.register(game, SoundVoltexFactory)
+
+    @classmethod
+    def create(cls, data: Data, config: Dict[str, Any], model: Model, parentmodel: Optional[Model]=None) -> Optional[Base]:
+
+        def version_from_date(date: int) -> Optional[int]:
+            if date < 2013060500:
+                return VersionConstants.SDVX_BOOTH
+            elif date >= 2013060500 and date < 2014112000:
+                return VersionConstants.SDVX_INFINITE_INFECTION
+            elif date >= 2014112000 and date < 2016122100:
+                return VersionConstants.SDVX_GRAVITY_WARS
+            elif date >= 2016122100:
+                return VersionConstants.SDVX_HEAVENLY_HAVEN
+            return None
+
+        if model.game == 'KFC':
+            if model.version is None:
+                if parentmodel is None:
+                    return None
+
+                # We have no way to tell apart newer versions. However, we can make
+                # an educated guess if we happen to be summoned for old profile lookup.
+                if parentmodel.game != 'KFC':
+                    return None
+
+                parentversion = version_from_date(parentmodel.version)
+                if parentversion == VersionConstants.SDVX_INFINITE_INFECTION:
+                    return SoundVoltexBooth(data, config, model)
+                if parentversion == VersionConstants.SDVX_GRAVITY_WARS:
+                    return SoundVoltexInfiniteInfection(data, config, model)
+                if parentversion == VersionConstants.SDVX_HEAVENLY_HAVEN:
+                    # We return the generic here because this is usually for profile
+                    # checks, which means we only care about existence.
+                    return SoundVoltexGravityWars(data, config, model)
+
+                # Unknown older version
+                return None
+
+        version = version_from_date(model.version)
+        if version == VersionConstants.SDVX_BOOTH:
+            return SoundVoltexBooth(data, config, model)
+        if version == VersionConstants.SDVX_INFINITE_INFECTION:
+            return SoundVoltexInfiniteInfection(data, config, model)
+        if version == VersionConstants.SDVX_GRAVITY_WARS:
+            # Determine which season
+            if model.version < 2015120400:
+                return SoundVoltexGravityWarsSeason1(data, config, model)
+            else:
+                return SoundVoltexGravityWarsSeason2(data, config, model)
+        if version == VersionConstants.SDVX_HEAVENLY_HAVEN:
+            return SoundVoltexHeavenlyHaven(data, config, model)
+
+        # Unknown game
+        return None
diff --git a/bemani/backend/sdvx/gravitywars.py b/bemani/backend/sdvx/gravitywars.py
new file mode 100644
index 0000000..a86248f
--- /dev/null
+++ b/bemani/backend/sdvx/gravitywars.py
@@ -0,0 +1,516 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, List, Optional
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.sdvx.base import SoundVoltexBase
+from bemani.backend.sdvx.infiniteinfection import SoundVoltexInfiniteInfection
+from bemani.common import ID, VersionConstants
+from bemani.protocol import Node
+
+
+class SoundVoltexGravityWars(
+    EventLogHandler,
+    SoundVoltexBase,
+):
+
+    name = 'SOUND VOLTEX III GRAVITY WARS'
+    version = VersionConstants.SDVX_GRAVITY_WARS
+
+    GAME_LIMITED_LOCKED = 1
+    GAME_LIMITED_UNLOCKABLE = 2
+    GAME_LIMITED_UNLOCKED = 3
+
+    GAME_CURRENCY_PACKETS = 0
+    GAME_CURRENCY_BLOCKS = 1
+
+    GAME_CLEAR_TYPE_NO_CLEAR = 1
+    GAME_CLEAR_TYPE_CLEAR = 2
+    GAME_CLEAR_TYPE_HARD_CLEAR = 3
+    GAME_CLEAR_TYPE_ULTIMATE_CHAIN = 4
+    GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN = 5
+
+    GAME_GRADE_NO_PLAY = 0
+    GAME_GRADE_D = 1
+    GAME_GRADE_C = 2
+    GAME_GRADE_B = 3
+    GAME_GRADE_A = 4
+    GAME_GRADE_AA = 5
+    GAME_GRADE_AAA = 6
+
+    GAME_CATALOG_TYPE_SONG = 0
+    GAME_CATALOG_TYPE_APPEAL_CARD = 1
+    GAME_CATALOG_TYPE_CREW = 4
+
+    GAME_GAUGE_TYPE_SKILL = 1
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Disable Online Matching',
+                    'tip': 'Disable online matching between games.',
+                    'category': 'game_config',
+                    'setting': 'disable_matching',
+                },
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+                {
+                    'name': 'Force Appeal Card Unlock',
+                    'tip': 'Force unlock all appeal cards.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_cards',
+                },
+                {
+                    'name': 'Force Crew Card Unlock',
+                    'tip': 'Force unlock all crew and subcrew cards.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_crew',
+                },
+            ],
+        }
+
+    def previous_version(self) -> Optional[SoundVoltexBase]:
+        return SoundVoltexInfiniteInfection(self.data, self.config, self.model)
+
+    def _get_skill_analyzer_courses(self) -> List[Dict[str, Any]]:
+        # This is overridden in S1/S2 code.
+        return []
+
+    def _get_skill_analyzer_seasons(self) -> Dict[int, str]:
+        # This is overridden in S1/S2 code.
+        return {}
+
+    def _get_extra_events(self) -> List[int]:
+        # This is overridden in S1/S2 code.
+        return []
+
+    def __game_to_db_clear_type(self, clear_type: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_NO_CLEAR: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEAR: self.CLEAR_TYPE_CLEAR,
+            self.GAME_CLEAR_TYPE_HARD_CLEAR: self.CLEAR_TYPE_HARD_CLEAR,
+            self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN: self.CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __db_to_game_clear_type(self, clear_type: int) -> int:
+        return {
+            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_CLEAR,
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_NO_CLEAR,
+            self.CLEAR_TYPE_CLEAR: self.GAME_CLEAR_TYPE_CLEAR,
+            self.CLEAR_TYPE_HARD_CLEAR: self.GAME_CLEAR_TYPE_HARD_CLEAR,
+            self.CLEAR_TYPE_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __game_to_db_grade(self, grade: int) -> int:
+        return {
+            self.GAME_GRADE_NO_PLAY: self.GRADE_NO_PLAY,
+            self.GAME_GRADE_D: self.GRADE_D,
+            self.GAME_GRADE_C: self.GRADE_C,
+            self.GAME_GRADE_B: self.GRADE_B,
+            self.GAME_GRADE_A: self.GRADE_A,
+            self.GAME_GRADE_AA: self.GRADE_AA,
+            self.GAME_GRADE_AAA: self.GRADE_AAA,
+        }[grade]
+
+    def __db_to_game_grade(self, grade: int) -> int:
+        return {
+            self.GRADE_NO_PLAY: self.GAME_GRADE_NO_PLAY,
+            self.GRADE_D: self.GAME_GRADE_D,
+            self.GRADE_C: self.GAME_GRADE_C,
+            self.GRADE_B: self.GAME_GRADE_B,
+            self.GRADE_A: self.GAME_GRADE_A,
+            self.GRADE_A_PLUS: self.GAME_GRADE_A,
+            self.GRADE_AA: self.GAME_GRADE_AA,
+            self.GRADE_AA_PLUS: self.GAME_GRADE_AA,
+            self.GRADE_AAA: self.GAME_GRADE_AAA,
+            self.GRADE_AAA_PLUS: self.GAME_GRADE_AAA,
+            self.GRADE_S: self.GAME_GRADE_AAA,
+        }[grade]
+
+    def __get_skill_analyzer_skill_levels(self) -> Dict[int, str]:
+        return {
+            0: 'Skill LEVEL 01 岳翔',
+            1: 'Skill LEVEL 02 流星',
+            2: 'Skill LEVEL 03 月衝',
+            3: 'Skill LEVEL 04 瞬光',
+            4: 'Skill LEVEL 05 天極',
+            5: 'Skill LEVEL 06 烈風',
+            6: 'Skill LEVEL 07 雷電',
+            7: 'Skill LEVEL 08 麗華',
+            8: 'Skill LEVEL 09 魔騎士',
+            9: 'Skill LEVEL 10 剛力羅',
+            10: 'Skill LEVEL 11 或帝滅斗',
+            11: 'Skill LEVEL ∞(12) 暴龍天',
+        }
+
+    def handle_game_3_common_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        limited = Node.void('music_limited')
+        game.add_child(limited)
+
+        # Song unlock config
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_songs'):
+            ids = set()
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.data.get_int('limited') in (self.GAME_LIMITED_LOCKED, self.GAME_LIMITED_UNLOCKABLE):
+                    ids.add((song.id, song.chart))
+
+            for (songid, chart) in ids:
+                info = Node.void('info')
+                limited.add_child(info)
+                info.add_child(Node.s32('music_id', songid))
+                info.add_child(Node.u8('music_type', chart))
+                info.add_child(Node.u8('limited', self.GAME_LIMITED_UNLOCKED))
+
+        # Event config
+        event = Node.void('event')
+        game.add_child(event)
+
+        def enable_event(eid: int) -> None:
+            evt = Node.void('info')
+            event.add_child(evt)
+            evt.add_child(Node.u32('event_id', eid))
+
+        if not game_config.get_bool('disable_matching'):
+            enable_event(1)  # Matching enabled
+        enable_event(2)  # Floor Infection
+        enable_event(3)  # Policy Break
+        enable_event(60)  # BEMANI Summer Diary
+
+        for eventid in self._get_extra_events():
+            enable_event(eventid)
+
+        # Skill Analyzer config
+        skill_course = Node.void('skill_course')
+        game.add_child(skill_course)
+
+        seasons = self._get_skill_analyzer_seasons()
+        skillnames = self.__get_skill_analyzer_skill_levels()
+        courses = self._get_skill_analyzer_courses()
+        max_level: Dict[int, int] = {}
+        for course in courses:
+            max_level[course['level']] = max(course['season_id'], max_level.get(course['level'], -1))
+        for course in courses:
+            info = Node.void('info')
+            skill_course.add_child(info)
+            info.add_child(Node.s16('course_id', course.get('id', course['level'])))
+            info.add_child(Node.s16('level', course['level']))
+            info.add_child(Node.s32('season_id', course['season_id']))
+            info.add_child(Node.string('season_name', seasons[course['season_id']]))
+            info.add_child(Node.bool('season_new_flg', max_level[course['level']] == course['season_id']))
+            info.add_child(Node.string('course_name', course.get('skill_name', skillnames.get(course['level'], ''))))
+            info.add_child(Node.s16('course_type', 0))
+            info.add_child(Node.s16('skill_name_id', course.get('skill_name_id', course['level'])))
+            info.add_child(Node.bool('matching_assist', course['level'] >= 0 and course['level'] <= 6))
+            info.add_child(Node.s16('gauge_type', self.GAME_GAUGE_TYPE_SKILL))
+            info.add_child(Node.s16('paseli_type', 0))
+
+            for trackno, trackdata in enumerate(course['tracks']):
+                track = Node.void('track')
+                info.add_child(track)
+                track.add_child(Node.s16('track_no', trackno))
+                track.add_child(Node.s32('music_id', trackdata['id']))
+                track.add_child(Node.s8('music_type', trackdata['type']))
+
+        return game
+
+    def handle_game_3_exception_request(self, request: Node) -> Node:
+        return Node.void('game_3')
+
+    def handle_game_3_shop_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('shopname'))
+
+        # Respond with number of milliseconds until next request
+        game = Node.void('game_3')
+        game.add_child(Node.u32('nxt_time', 1000 * 5 * 60))
+        return game
+
+    def handle_game_3_lounge_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        # Refresh interval in seconds.
+        game.add_child(Node.u32('interval', 10))
+        return game
+
+    def handle_game_3_entry_s_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        # This should be created on the fly for a lobby that we're in.
+        game.add_child(Node.u32('entry_id', 1))
+        return game
+
+    def handle_game_3_entry_e_request(self, request: Node) -> Node:
+        # Lobby destroy method, eid node (u32) should be used
+        # to destroy any open lobbies.
+        return Node.void('game_3')
+
+    def handle_game_3_frozen_request(self, request: Node) -> Node:
+        game = Node.void('game_3')
+        game.add_child(Node.u8('result', 0))
+        return game
+
+    def handle_game_3_save_e_request(self, request: Node) -> Node:
+        # This has to do with Policy Break against ReflecBeat and
+        # floor infection, but we don't implement multi-game support so meh.
+        return Node.void('game_3')
+
+    def handle_game_3_play_e_request(self, request: Node) -> Node:
+        return Node.void('game_3')
+
+    def handle_game_3_buy_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            profile = self.get_profile(userid)
+        else:
+            profile = None
+
+        if userid is not None and profile is not None:
+            # Look up packets and blocks
+            packet = profile.get_int('packet')
+            block = profile.get_int('block')
+
+            # Add on any additional we earned this round
+            packet = packet + (request.child_value('earned_gamecoin_packet') or 0)
+            block = block + (request.child_value('earned_gamecoin_block') or 0)
+
+            currency_type = request.child_value('currency_type')
+            price = request.child_value('item/price')
+            if isinstance(price, list):
+                # Sometimes we end up buying more than one item at once
+                price = sum(price)
+
+            if currency_type == self.GAME_CURRENCY_PACKETS:
+                # This is a valid purchase
+                newpacket = packet - price
+                if newpacket < 0:
+                    result = 1
+                else:
+                    packet = newpacket
+                    result = 0
+            elif currency_type == self.GAME_CURRENCY_BLOCKS:
+                # This is a valid purchase
+                newblock = block - price
+                if newblock < 0:
+                    result = 1
+                else:
+                    block = newblock
+                    result = 0
+            else:
+                # Bad currency type
+                result = 1
+
+            if result == 0:
+                # Transaction is valid, update the profile with new packets and blocks
+                profile.replace_int('packet', packet)
+                profile.replace_int('block', block)
+                self.put_profile(userid, profile)
+
+                # If this was a song unlock, we should mark it as unlocked
+                item_type = request.child_value('item/item_type')
+                item_id = request.child_value('item/item_id')
+                param = request.child_value('item/param')
+
+                if not isinstance(item_type, list):
+                    # Sometimes we buy multiple things at once. Make it easier by always assuming this.
+                    item_type = [item_type]
+                    item_id = [item_id]
+                    param = [param]
+
+                for i in range(len(item_type)):
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        item_id[i],
+                        'item_{}'.format(item_type[i]),
+                        {
+                            'param': param[i],
+                        },
+                    )
+
+        else:
+            # Unclear what to do here, return a bad response
+            packet = 0
+            block = 0
+            result = 1
+
+        game = Node.void('game_3')
+        game.add_child(Node.u32('gamecoin_packet', packet))
+        game.add_child(Node.u32('gamecoin_block', block))
+        game.add_child(Node.s8('result', result))
+        return game
+
+    def handle_game_3_new_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        name = request.child_value('name')
+        loc = ID.parse_machine_id(request.child_value('locid'))
+        self.new_profile_by_refid(refid, name, loc)
+
+        root = Node.void('game_3')
+        return root
+
+    def handle_game_3_load_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is not None:
+            return root
+
+        # Figure out if this user has an older profile or not
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            previous_game = self.previous_version()
+        else:
+            previous_game = None
+
+        if previous_game is not None:
+            profile = previous_game.get_profile(userid)
+        else:
+            profile = None
+
+        if profile is not None:
+            root = Node.void('game_3')
+            root.add_child(Node.u8('result', 2))
+            root.add_child(Node.string('name', profile.get_str('name')))
+            return root
+        else:
+            root = Node.void('game_3')
+            root.add_child(Node.u8('result', 1))
+            return root
+
+    def handle_game_3_save_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid)
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+        else:
+            newprofile = None
+
+        if userid is not None and newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+        return Node.void('game_3')
+
+    def handle_game_3_load_m_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        # Output to the game
+        game = Node.void('game_3')
+        new = Node.void('new')
+        game.add_child(new)
+
+        for score in scores:
+            music = Node.void('music')
+            new.add_child(music)
+            music.add_child(Node.u32('music_id', score.id))
+            music.add_child(Node.u32('music_type', score.chart))
+            music.add_child(Node.u32('score', score.points))
+            music.add_child(Node.u32('cnt', score.plays))
+            music.add_child(Node.u32('clear_type', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
+            music.add_child(Node.u32('score_grade', self.__db_to_game_grade(score.data.get_int('grade'))))
+            stats = score.data.get_dict('stats')
+            music.add_child(Node.u32('btn_rate', stats.get_int('btn_rate')))
+            music.add_child(Node.u32('long_rate', stats.get_int('long_rate')))
+            music.add_child(Node.u32('vol_rate', stats.get_int('vol_rate')))
+
+        return game
+
+    def handle_game_3_save_m_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        # Doesn't matter if userid is None here, that's an anonymous score
+        musicid = request.child_value('music_id')
+        chart = request.child_value('music_type')
+        points = request.child_value('score')
+        combo = request.child_value('max_chain')
+        clear_type = self.__game_to_db_clear_type(request.child_value('clear_type'))
+        grade = self.__game_to_db_grade(request.child_value('score_grade'))
+        stats = {
+            'btn_rate': request.child_value('btn_rate'),
+            'long_rate': request.child_value('long_rate'),
+            'vol_rate': request.child_value('vol_rate'),
+            'critical': request.child_value('critical'),
+            'near': request.child_value('near'),
+            'error': request.child_value('error'),
+        }
+
+        # Save the score
+        self.update_score(
+            userid,
+            musicid,
+            chart,
+            points,
+            clear_type,
+            grade,
+            combo,
+            stats,
+        )
+
+        # Return a blank response
+        return Node.void('game_3')
+
+    def handle_game_3_save_c_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            course_id = request.child_value('crsid')
+            clear_type = request.child_value('ct')
+            achievement_rate = request.child_value('ar')
+            season_id = request.child_value('ssnid')
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                (season_id * 100) + course_id,
+                'course',
+                {
+                    'clear_type': clear_type,
+                    'achievement_rate': achievement_rate,
+                },
+            )
+
+        # Return a blank response
+        return Node.void('game_3')
diff --git a/bemani/backend/sdvx/gravitywars_s1.py b/bemani/backend/sdvx/gravitywars_s1.py
new file mode 100644
index 0000000..72a562d
--- /dev/null
+++ b/bemani/backend/sdvx/gravitywars_s1.py
@@ -0,0 +1,3369 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, List
+
+from bemani.backend.sdvx.gravitywars import SoundVoltexGravityWars
+from bemani.common import ID, Time, ValidatedDict
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class SoundVoltexGravityWarsSeason1(
+    SoundVoltexGravityWars,
+):
+
+    def _get_skill_analyzer_seasons(self) -> Dict[int, str]:
+        return {
+            1: 'SKILL ANALYZER 第1回 Aコース',
+            2: 'SKILL ANALYZER 第1回 Bコース',
+            3: 'SKILL ANALYZER 第1回 Cコース',
+            4: 'The 4th KAC コース',
+            5: 'SKILL ANALYZER 第2回 Aコース',
+            6: 'SKILL ANALYZER 第2回 Bコース',
+            7: 'SKILL ANALYZER 第2回 Cコース',
+            8: 'SKILL ANALYZER 第3回 Aコース',
+            9: 'SKILL ANALYZER 第3回 Bコース',
+            10: 'SKILL ANALYZER 第3回 Cコース',
+            11: 'SKILL ANALYZER 第4回',
+            12: 'SKILL ANALYZER 第5回 Aコース',
+            13: 'SKILL ANALYZER 第5回 Bコース',
+            14: 'SKILL ANALYZER 第5回 Cコース',
+            15: 'SKILL ANALYZER 第6回 Aコース',
+            16: 'SKILL ANALYZER 第6回 Bコース',
+        }
+
+    def _get_skill_analyzer_courses(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                'level': 0,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 283,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 279,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 76,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 196,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 8,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 228,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 80,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 201,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 237,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 393,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 352,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 66,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 383,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 511,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 331,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 422,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 445,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 71,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 454,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 158,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 173,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 348,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 73,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 259,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 374,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 84,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 303,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 274,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 56,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 244,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 4,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 414,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 209,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 334,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 403,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 391,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 239,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 426,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 389,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 89,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 419,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 341,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 394,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 466,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 500,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 247,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 229,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 189,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 171,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 182,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 3,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 105,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 14,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 120,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 86,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 390,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 243,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 186,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 423,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 59,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 452,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 262,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 480,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 411,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 70,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 211,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 30,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 72,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 293,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 117,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 269,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 498,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 437,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 0,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースA',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 466,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 273,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースB',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 194,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 501,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースC',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 356,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 472,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースD',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 583,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースA',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 466,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 273,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースB',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 194,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 501,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースC',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 356,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 472,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースD',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 583,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 334,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 10,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 11,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 224,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 132,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 137,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 336,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 380,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 308,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 113,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 101,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 200,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 478,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 487,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 254,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 410,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 196,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 170,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 218,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 489,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 519,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 373,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 456,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 263,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 390,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 19,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 508,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 231,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 185,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 65,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 386,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 92,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 379,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 225,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 427,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 249,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 185,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 413,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 157,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 402,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 412,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 323,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 256,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 400,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 368,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 241,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 453,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 442,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 216,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 370,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 244,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 252,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 359,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 214,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 506,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 446,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 34,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 113,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 309,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 42,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 353,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 130,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 219,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 153,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 418,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 369,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 385,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 226,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 301,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 159,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 311,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 255,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 213,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 357,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 268,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 304,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 295,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 302,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 208,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 376,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 101,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 219,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 159,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 337,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 403,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 30,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 596,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 39,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 430,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 561,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 328,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 444,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 618,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 100,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 447,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 545,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 94,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 291,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 475,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 627,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 624,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 427,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 464,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 591,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 381,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 463,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 507,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 468,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 243,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 388,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 167,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 486,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 75,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 96,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 557,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 55,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 520,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 314,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 507,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 567,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 205,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 86,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 488,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 80,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 184,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 130,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 524,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 521,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 576,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 503,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 473,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 538,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 407,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 472,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 363,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 209,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 24,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 405,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 554,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 77,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 426,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 262,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 194,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 564,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 248,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 471,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 276,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 476,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 120,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 57,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 146,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 622,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 152,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 562,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 531,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 449,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 404,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 607,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 469,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 496,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 289,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Manually specify IDs here since this has more than one level 11.
+            {
+                'id': 0,
+                'level': 0,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 190,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 568,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 191,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': 1,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 278,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 41,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 18,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': 2,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 15,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 483,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 467,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': 3,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 585,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 486,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 48,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': 4,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 103,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 335,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 224,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': 5,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 275,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 438,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 67,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': 6,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 202,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 526,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': 7,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 131,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 394,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 8,
+                'level': 8,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 396,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 346,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 510,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 9,
+                'level': 9,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 326,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 10,
+                'level': 10,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 339,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 418,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 525,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 11,
+                'level': 10,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 73,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'id': 12,
+                'level': 11,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 636,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 507,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 671,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 176,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 27,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 520,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 103,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 478,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 107,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 520,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 163,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 408,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 34,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 678,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 481,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 436,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 104,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 55,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 415,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 512,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 483,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 509,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 557,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 497,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 58,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 166,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 581,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 439,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 443,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 250,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 245,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 186,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 13,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 618,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 31,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 436,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 144,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 79,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 489,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 245,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 222,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 556,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 233,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 565,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 354,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 281,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 14,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 267,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 490,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 467,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 585,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 560,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 599,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 101,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 630,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 408,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 393,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 328,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 266,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 453,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 153,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 458,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 514,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 71,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 392,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 388,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 569,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 508,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 405,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 266,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 50,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 172,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 33,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 210,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 232,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 485,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 457,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 514,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 556,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 534,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 273,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 220,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 420,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 444,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 151,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 117,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 564,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 318,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 93,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 308,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 49,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 317,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 335,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 239,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 439,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 44,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 243,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 158,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 175,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 150,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 162,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 79,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 386,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 99,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 164,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 406,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 344,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 6,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 660,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 378,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 465,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 413,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 221,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 342,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 10,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 11,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 366,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 695,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 692,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 144,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 569,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 515,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 254,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 354,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 441,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 524,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 187,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 117,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 446,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 435,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 180,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 260,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 451,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 58,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 195,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 236,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 440,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 112,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 401,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 325,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 387,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 42,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 676,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 494,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 234,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 623,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 329,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 10,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 450,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 634,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 11,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 693,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 694,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+        ]
+
+    def handle_game_3_hiscore_request(self, request: Node) -> Node:
+        # Grab location for local scores
+        locid = ID.parse_machine_id(request.child_value('locid'))
+
+        # Start the response packet
+        game = Node.void('game_3')
+
+        # First, grab hit chart
+        playcounts = self.data.local.music.get_hit_chart(self.game, self.version, 1024)
+
+        hitchart = Node.void('hitchart')
+        game.add_child(hitchart)
+        for (songid, count) in playcounts:
+            info = Node.void('info')
+            hitchart.add_child(info)
+            info.add_child(Node.u32('id', songid))
+            info.add_child(Node.u32('cnt', count))
+
+        # Now, grab user records
+        records = self.data.remote.music.get_all_records(self.game, self.version)
+        missing_users = [userid for (userid, _) in records]
+        users = {userid: profile for (userid, profile) in self.get_any_profiles(missing_users)}
+
+        hiscore_allover = Node.void('hiscore_allover')
+        game.add_child(hiscore_allover)
+
+        # Output records
+        for (userid, score) in records:
+            info = Node.void('info')
+
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            profile = users[userid]
+
+            info.add_child(Node.u32('id', score.id))
+            info.add_child(Node.u32('type', score.chart))
+            info.add_child(Node.string('name', profile.get_str('name')))
+            info.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+            info.add_child(Node.u32('score', score.points))
+
+            # Add to global scores
+            hiscore_allover.add_child(info)
+
+        # Now, grab local records
+        area_users = [
+            uid for (uid, prof) in self.data.local.user.get_all_profiles(self.game, self.version)
+            if prof.get_int('loc', -1) == locid
+        ]
+        records = self.data.local.music.get_all_records(self.game, self.version, userlist=area_users)
+        missing_users = [userid for (userid, _) in records if userid not in users]
+        for (userid, profile) in self.get_any_profiles(missing_users):
+            users[userid] = profile
+
+        hiscore_location = Node.void('hiscore_location')
+        game.add_child(hiscore_location)
+
+        # Output records
+        for (userid, score) in records:
+            info = Node.void('info')
+
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            profile = users[userid]
+
+            info.add_child(Node.u32('id', score.id))
+            info.add_child(Node.u32('type', score.chart))
+            info.add_child(Node.string('name', profile.get_str('name')))
+            info.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+            info.add_child(Node.u32('score', score.points))
+
+            # Add to global scores
+            hiscore_location.add_child(info)
+
+        # Now, grab clear rates
+        clear_rate = Node.void('clear_rate')
+        game.add_child(clear_rate)
+
+        clears = self.get_clear_rates()
+        for songid in clears:
+            for chart in clears[songid]:
+                if clears[songid][chart]['total'] > 0:
+                    rate = float(clears[songid][chart]['clears']) / float(clears[songid][chart]['total'])
+                    dnode = Node.void('d')
+                    clear_rate.add_child(dnode)
+                    dnode.add_child(Node.u32('id', songid))
+                    dnode.add_child(Node.u32('type', chart))
+                    dnode.add_child(Node.s16('cr', int(rate * 10000)))
+
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game_3')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.s16('skill_name_id', profile.get_int('skill_name_id', -1)))
+        game.add_child(Node.s32_array('hidden_param', profile.get_int_array('hidden_param', 20)))
+        game.add_child(Node.u32('blaster_energy', profile.get_int('blaster_energy')))
+        game.add_child(Node.u32('blaster_count', profile.get_int('blaster_count')))
+
+        # Play statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        game.add_child(Node.u32('play_count', statistics.get_int('total_plays', 0)))
+        game.add_child(Node.u32('daily_count', today_count))
+        game.add_child(Node.u32('play_chain', statistics.get_int('consecutive_days', 0)))
+
+        # Last played stuff
+        if 'last' in profile:
+            lastdict = profile.get_dict('last')
+            last = Node.void('last')
+            game.add_child(last)
+            last.add_child(Node.s32('music_id', lastdict.get_int('music_id', -1)))
+            last.add_child(Node.u8('music_type', lastdict.get_int('music_type')))
+            last.add_child(Node.u8('sort_type', lastdict.get_int('sort_type')))
+            last.add_child(Node.u8('narrow_down', lastdict.get_int('narrow_down')))
+            last.add_child(Node.u8('headphone', lastdict.get_int('headphone')))
+            last.add_child(Node.u16('appeal_id', lastdict.get_int('appeal_id', 1001)))
+            last.add_child(Node.u16('comment_id', lastdict.get_int('comment_id')))
+            last.add_child(Node.u8('gauge_option', lastdict.get_int('gauge_option')))
+
+        # Item unlocks
+        itemnode = Node.void('item')
+        game.add_child(itemnode)
+
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+
+            if game_config.get_bool('force_unlock_songs') and itemtype == self.GAME_CATALOG_TYPE_SONG:
+                # Don't echo unlocked songs, we will add all of them later
+                continue
+            if game_config.get_bool('force_unlock_cards') and itemtype == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                # Don't echo unlocked appeal cards, we will add all of them later
+                continue
+
+            info = Node.void('info')
+            itemnode.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u32('id', item.id))
+            info.add_child(Node.u32('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for itemid in ids:
+                if ids[itemid] == 0:
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('id', itemid))
+                info.add_child(Node.u32('param', ids[itemid]))
+
+        if game_config.get_bool('force_unlock_cards'):
+            catalog = self.data.local.game.get_items(self.game, self.version)
+            for unlock in catalog:
+                if unlock.type != 'appealcard':
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_APPEAL_CARD))
+                info.add_child(Node.u32('id', unlock.id))
+                info.add_child(Node.u32('param', 1))
+
+        # Skill courses
+        skill = Node.void('skill')
+        game.add_child(skill)
+        course_all = Node.void('course_all')
+        skill.add_child(course_all)
+
+        for course in achievements:
+            if course.type != 'course':
+                continue
+
+            course_id = course.id % 100
+            season_id = int(course.id / 100)
+
+            info = Node.void('d')
+            course_all.add_child(info)
+            info.add_child(Node.s16('crsid', course_id))
+            info.add_child(Node.s16('ct', course.data.get_int('clear_type')))
+            info.add_child(Node.s16('ar', course.data.get_int('achievement_rate')))
+            info.add_child(Node.s32('ssnid', season_id))
+
+        # Story mode unlocks
+        storynode = Node.void('story')
+        game.add_child(storynode)
+
+        for story in achievements:
+            if story.type != 'story':
+                continue
+
+            info = Node.void('info')
+            storynode.add_child(info)
+            info.add_child(Node.s32('story_id', story.id))
+            info.add_child(Node.s32('progress_id', story.data.get_int('progress_id')))
+            info.add_child(Node.s32('progress_param', story.data.get_int('progress_param')))
+            info.add_child(Node.s32('clear_cnt', story.data.get_int('clear_cnt')))
+            info.add_child(Node.u32('route_flg', story.data.get_int('route_flg')))
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update blaster energy and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        earned_blaster_energy = request.child_value('earned_blaster_energy')
+        if earned_blaster_energy is not None:
+            newprofile.replace_int('blaster_energy', newprofile.get_int('blaster_energy') + earned_blaster_energy)
+
+        # Miscelaneous stuff
+        newprofile.replace_int('blaster_count', request.child_value('blaster_count'))
+        newprofile.replace_int('skill_name_id', request.child_value('skill_name_id'))
+        newprofile.replace_int_array('hidden_param', 20, request.child_value('hidden_param'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+
+        if request.child('item') is not None:
+            for child in request.child('item').children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+
+                if game_config.get_bool('force_unlock_cards') and item_type == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                    # Don't save back appeal cards because they were force unlocked
+                    continue
+                if game_config.get_bool('force_unlock_songs') and item_type == self.GAME_CATALOG_TYPE_SONG:
+                    # Don't save back songs, because they were force unlocked
+                    continue
+                if game_config.get_bool('force_unlock_crew') and item_type == self.GAME_CATALOG_TYPE_CREW:
+                    # Don't save back crew, because they were force unlocked
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Update story progress
+        if request.child('story') is not None:
+            for child in request.child('story').children:
+                if child.name != 'info':
+                    continue
+
+                story_id = child.child_value('story_id')
+                progress_id = child.child_value('progress_id')
+                progress_param = child.child_value('progress_param')
+                clear_cnt = child.child_value('clear_cnt')
+                route_flg = child.child_value('route_flg')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    story_id,
+                    'story',
+                    {
+                        'progress_id': progress_id,
+                        'progress_param': progress_param,
+                        'clear_cnt': clear_cnt,
+                        'route_flg': route_flg,
+                    },
+                )
+
+        # Grab last information.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('appeal_id', request.child_value('appeal_id'))
+        lastdict.replace_int('comment_id', request.child_value('comment_id'))
+        lastdict.replace_int('music_id', request.child_value('music_id'))
+        lastdict.replace_int('music_type', request.child_value('music_type'))
+        lastdict.replace_int('sort_type', request.child_value('sort_type'))
+        lastdict.replace_int('narrow_down', request.child_value('narrow_down'))
+        lastdict.replace_int('gauge_option', request.child_value('gauge_option'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/sdvx/gravitywars_s2.py b/bemani/backend/sdvx/gravitywars_s2.py
new file mode 100644
index 0000000..4990265
--- /dev/null
+++ b/bemani/backend/sdvx/gravitywars_s2.py
@@ -0,0 +1,4251 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, List, Tuple
+
+from bemani.backend.sdvx.gravitywars import SoundVoltexGravityWars
+from bemani.common import ID, Time, ValidatedDict
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class SoundVoltexGravityWarsSeason2(
+    SoundVoltexGravityWars,
+):
+
+    def _get_skill_analyzer_seasons(self) -> Dict[int, str]:
+        return {
+            1: 'SKILL ANALYZER 第1回 Aコース',
+            2: 'SKILL ANALYZER 第1回 Bコース',
+            3: 'SKILL ANALYZER 第1回 Cコース',
+            4: 'The 4th KAC コース',
+            5: 'SKILL ANALYZER 第2回 Aコース',
+            6: 'SKILL ANALYZER 第2回 Bコース',
+            7: 'SKILL ANALYZER 第2回 Cコース',
+            8: 'SKILL ANALYZER 第3回 Aコース',
+            9: 'SKILL ANALYZER 第3回 Bコース',
+            10: 'SKILL ANALYZER 第3回 Cコース',
+            11: 'SKILL ANALYZER 第4回',
+            12: 'SKILL ANALYZER 第5回 Aコース',
+            13: 'SKILL ANALYZER 第5回 Bコース',
+            14: 'SKILL ANALYZER 第5回 Cコース',
+            15: 'SKILL ANALYZER 第6回 Aコース',
+            16: 'SKILL ANALYZER 第6回 Bコース',
+            17: '天下一コース',
+            18: 'The 5th KAC コース',
+            19: 'VOLTEXES コース',
+            20: 'SKILL ANALYZER 第7回',
+            21: 'SKILL ANALYZER 第8回',
+        }
+
+    def _get_skill_analyzer_courses(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                'level': 0,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 283,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 279,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 76,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 196,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 8,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 228,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 80,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 201,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 237,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 393,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 352,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 66,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 383,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 511,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 331,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 422,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 445,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 71,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 454,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 158,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 173,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 1,
+                'tracks': [
+                    {
+                        'id': 348,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 73,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 259,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 374,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 84,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 303,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 274,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 56,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 244,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 4,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 414,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 209,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 334,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 403,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 391,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 239,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 426,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 389,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 89,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 419,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 341,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 394,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 466,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 2,
+                'tracks': [
+                    {
+                        'id': 500,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 247,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 229,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 189,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 171,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 182,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 3,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 105,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 14,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 120,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 86,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 390,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 243,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 186,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 423,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 59,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 452,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 262,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 480,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 411,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 70,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 211,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 30,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 72,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 293,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 117,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 269,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 3,
+                'tracks': [
+                    {
+                        'id': 498,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 437,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 0,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースA',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 466,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 273,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースB',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 194,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 501,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースC',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 356,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 472,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': -1,
+                'skill_name': 'エンジョイ♪ごりらコースD',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 583,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースA',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 466,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 273,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースB',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 194,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 501,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースC',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 356,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 472,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': -1,
+                'skill_name': 'チャレンジ★ごりらコースD',
+                'skill_name_id': 12,
+                'season_id': 4,
+                'tracks': [
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 583,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 334,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 10,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 11,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 224,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 132,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 137,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 336,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 380,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 308,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 113,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 101,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 200,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 478,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 487,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 254,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 410,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 196,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 170,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 218,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 489,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 519,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 373,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 456,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 263,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 390,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 5,
+                'tracks': [
+                    {
+                        'id': 19,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 508,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 231,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 185,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 65,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 386,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 92,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 379,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 225,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 427,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 249,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 185,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 413,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 157,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 402,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 412,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 323,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 256,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 400,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 368,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 241,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 453,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 442,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 216,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 370,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 244,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 252,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 359,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 214,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 506,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 446,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 34,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 113,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 309,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 42,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 353,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 130,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 219,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 153,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 418,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 369,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 385,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 226,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 301,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 159,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 311,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 255,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 213,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 357,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 268,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 304,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 295,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 302,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 208,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 376,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 101,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 219,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 159,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 337,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 403,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 30,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 596,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 39,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 430,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 561,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 328,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 444,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 618,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 100,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 447,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 545,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 94,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 291,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 475,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 627,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 624,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 427,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 464,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 591,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 381,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 463,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 507,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 468,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 243,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 388,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 167,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 486,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 75,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 96,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 557,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 55,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 520,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 314,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 507,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 567,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 205,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 86,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 488,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 80,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 184,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 130,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 524,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 521,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 576,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 503,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 473,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 538,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 407,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 472,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 363,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 209,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 24,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 405,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 554,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 77,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 426,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 262,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 194,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 564,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 248,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 471,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 276,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 476,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 120,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 57,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 146,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 622,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 152,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 562,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 531,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 449,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 404,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 607,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 469,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 496,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 289,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Manually specify IDs here since this has more than one level 11.
+            {
+                'id': 0,
+                'level': 0,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 190,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 568,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 191,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': 1,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 278,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 41,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 18,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': 2,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 15,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 483,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 467,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': 3,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 585,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 486,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 48,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': 4,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 103,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 335,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 224,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': 5,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 275,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 438,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 67,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': 6,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 202,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 526,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': 7,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 131,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 394,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 8,
+                'level': 8,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 396,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 346,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 510,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 9,
+                'level': 9,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 326,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 10,
+                'level': 10,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 339,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 418,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 525,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 11,
+                'level': 10,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 73,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'id': 12,
+                'level': 11,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 636,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 507,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 671,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 176,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 27,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 520,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 103,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 478,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 107,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 520,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 163,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 408,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 34,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 678,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 481,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 436,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 104,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 55,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 415,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 512,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 483,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 509,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 557,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 497,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 58,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 166,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 581,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 439,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 443,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 250,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 245,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 186,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 13,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 618,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 31,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 436,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 144,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 79,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 489,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 245,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 222,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 556,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 233,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 565,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 354,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 281,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 14,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 267,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 490,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 467,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 585,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 560,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 599,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 101,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 630,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 408,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 393,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 328,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 266,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 453,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 153,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 458,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 514,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 71,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 392,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 388,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 569,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 508,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 405,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 266,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 50,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 172,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 33,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 210,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 232,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 485,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 457,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 514,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 556,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 534,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 273,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 220,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 420,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 444,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 151,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 117,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 564,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 318,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 93,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 308,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 49,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 317,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 335,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 239,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 439,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 44,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 243,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 158,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 175,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 150,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 162,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 79,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 386,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 99,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 164,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 406,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 344,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 6,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 660,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 378,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 465,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 413,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 221,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 342,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 10,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 123,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 11,
+                'season_id': 15,
+                'tracks': [
+                    {
+                        'id': 366,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 695,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 692,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 144,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 569,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 515,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 254,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 354,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 441,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 524,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 187,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 117,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 446,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 435,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 180,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 260,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 451,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # The level 6 course for this version is intentionally missing,
+            # as a song that it included was removed and thus the course was
+            # as well.
+            {
+                'level': 6,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 440,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 112,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 401,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 325,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 387,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 42,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 676,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 494,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 234,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 623,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 329,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 10,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 450,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 634,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 11,
+                'season_id': 16,
+                'tracks': [
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 693,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 694,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'id': 0,
+                'level': -1,
+                'skill_name': '天下一 (梅)コース',
+                'skill_name_id': 13,
+                'season_id': 17,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 708,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': -1,
+                'skill_name': '天下一 (竹)コース',
+                'skill_name_id': 13,
+                'season_id': 17,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 708,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': -1,
+                'skill_name': '天下一 (松)コース',
+                'skill_name_id': 13,
+                'season_id': 17,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 708,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 0,
+                'level': -1,
+                'skill_name': '青龍の戯れ',
+                'skill_name_id': 14,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 439,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 675,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 692,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': -1,
+                'skill_name': '朱雀の戯れ',
+                'skill_name_id': 16,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 587,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 543,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 693,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': -1,
+                'skill_name': '玄武の戯れ',
+                'skill_name_id': 17,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 696,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 695,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': -1,
+                'skill_name': '白虎の戯れ',
+                'skill_name_id': 15,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 606,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 593,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 694,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': -1,
+                'skill_name': '青龍の戯れ',
+                'skill_name_id': 14,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 439,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 675,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 692,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': -1,
+                'skill_name': '朱雀の戯れ',
+                'skill_name_id': 16,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 587,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 543,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 693,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': -1,
+                'skill_name': '玄武の戯れ',
+                'skill_name_id': 17,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 696,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 695,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': -1,
+                'skill_name': '白虎の戯れ',
+                'skill_name_id': 15,
+                'season_id': 18,
+                'tracks': [
+                    {
+                        'id': 606,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 593,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 694,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 0,
+                'level': -1,
+                'skill_name': 'RANK 名も無き草',
+                'skill_name_id': 18,
+                'season_id': 19,
+                'tracks': [
+                    {
+                        'id': 783,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 784,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 785,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': -1,
+                'skill_name': 'RANK 雪月花',
+                'skill_name_id': 18,
+                'season_id': 19,
+                'tracks': [
+                    {
+                        'id': 783,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 784,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 785,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': -1,
+                'skill_name': 'RANK 金剛雲',
+                'skill_name_id': 18,
+                'season_id': 19,
+                'tracks': [
+                    {
+                        'id': 783,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 784,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 785,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Manually specify IDs here since this has more than one level 11.
+            {
+                'id': 0,
+                'level': 0,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 657,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 285,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 491,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': 1,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 446,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 588,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 21,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': 2,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 560,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 602,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 88,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': 3,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 470,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 515,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 65,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': 4,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 499,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 358,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 72,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': 5,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 573,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 559,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 602,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': 6,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 255,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 164,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 783,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': 7,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 425,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 54,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 771,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 8,
+                'level': 8,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 589,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 592,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 776,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 9,
+                'level': 9,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 779,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 611,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 670,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 10,
+                'level': 10,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 522,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 543,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 610,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 11,
+                'level': 10,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 180,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 214,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'id': 12,
+                'level': 11,
+                'season_id': 20,
+                'tracks': [
+                    {
+                        'id': 661,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 791,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            # Manually specify IDs here since this has more than one level 11.
+            {
+                'id': 0,
+                'level': 0,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 314,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 768,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 1,
+                'level': 1,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 16,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 528,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 118,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 2,
+                'level': 2,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 330,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 644,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 74,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'id': 3,
+                'level': 3,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 494,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 294,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 61,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 4,
+                'level': 4,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 498,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 177,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 212,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 5,
+                'level': 5,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 319,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 53,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 603,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 6,
+                'level': 6,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 688,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 261,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 784,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 7,
+                'level': 7,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 777,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 387,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 659,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 8,
+                'level': 8,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 518,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 714,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 681,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 9,
+                'level': 9,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 529,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 682,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 597,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 10,
+                'level': 10,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 600,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 758,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 816,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'id': 11,
+                'level': 10,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 829,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 830,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 831,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'id': 12,
+                'level': 11,
+                'season_id': 21,
+                'tracks': [
+                    {
+                        'id': 914,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 913,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 915,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+        ]
+
+    def _get_extra_events(self) -> List[int]:
+        return [
+            62,  # Navigator select (empty by itself)
+            65,  # Navigator crew recruitments bottom half
+            66,  # Enable Tenkaichi Mode
+            69,  # Season 2 differences
+        ]
+
+    def handle_game_3_hiscore_request(self, request: Node) -> Node:
+        # Grab location for local scores
+        locid = ID.parse_machine_id(request.child_value('locid'))
+
+        # Start the response packet
+        game = Node.void('game_3')
+
+        # First, grab hit chart
+        playcounts = self.data.local.music.get_hit_chart(self.game, self.version, 1024)
+
+        hitchart = Node.void('hit')
+        game.add_child(hitchart)
+        for (songid, count) in playcounts:
+            info = Node.void('d')
+            hitchart.add_child(info)
+            info.add_child(Node.u32('id', songid))
+            info.add_child(Node.u32('cnt', count))
+
+        # Now, grab global and local scores as well as clear rates
+        global_records = self.data.remote.music.get_all_records(self.game, self.version)
+        users = {
+            uid: prof for (uid, prof) in self.data.local.user.get_all_profiles(self.game, self.version)
+        }
+        area_users = [
+            uid for uid in users
+            if users[uid].get_int('loc', -1) == locid
+        ]
+        area_records = self.data.local.music.get_all_records(self.game, self.version, userlist=area_users)
+        clears = self.get_clear_rates()
+        records: Dict[int, Dict[int, Dict[str, Tuple[UserID, Score]]]] = {}
+
+        missing_users = (
+            [userid for (userid, _) in global_records if userid not in users] +
+            [userid for (userid, _) in area_records if userid not in users]
+        )
+        for (userid, profile) in self.get_any_profiles(missing_users):
+            users[userid] = profile
+
+        for (userid, score) in global_records:
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            if score.id not in records:
+                records[score.id] = {}
+            if score.chart not in records[score.id]:
+                records[score.id][score.chart] = {}
+            records[score.id][score.chart]['global'] = (userid, score)
+
+        for (userid, score) in area_records:
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            if score.id not in records:
+                records[score.id] = {}
+            if score.chart not in records[score.id]:
+                records[score.id][score.chart] = {}
+            records[score.id][score.chart]['area'] = (userid, score)
+
+        # Output it to the game
+        highscores = Node.void('sc')
+        game.add_child(highscores)
+        for musicid in records:
+            for chart in records[musicid]:
+                (globaluserid, globalscore) = records[musicid][chart]['global']
+
+                global_profile = users[globaluserid]
+                if clears[musicid][chart]['total'] > 0:
+                    clear_rate = float(clears[musicid][chart]['clears']) / float(clears[musicid][chart]['total'])
+                else:
+                    clear_rate = 0.0
+
+                info = Node.void('d')
+                highscores.add_child(info)
+                info.add_child(Node.u32('id', musicid))
+                info.add_child(Node.u32('ty', chart))
+                info.add_child(Node.string('a_sq', ID.format_extid(global_profile.get_int('extid'))))
+                info.add_child(Node.string('a_nm', global_profile.get_str('name')))
+                info.add_child(Node.u32('a_sc', globalscore.points))
+                info.add_child(Node.s32('cr', int(clear_rate * 10000)))
+
+                if 'area' in records[musicid][chart]:
+                    (localuserid, localscore) = records[musicid][chart]['area']
+                    local_profile = users[localuserid]
+                    info.add_child(Node.string('l_sq', ID.format_extid(local_profile.get_int('extid'))))
+                    info.add_child(Node.string('l_nm', local_profile.get_str('name')))
+                    info.add_child(Node.u32('l_sc', localscore.points))
+
+        return game
+
+    def handle_game_3_load_r_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+        game = Node.void('game_3')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            links = self.data.local.user.get_links(self.game, self.version, userid)
+            for index, link in enumerate(links):
+                if link.type != 'rival':
+                    continue
+                other_profile = self.get_profile(link.other_userid)
+                if other_profile is None:
+                    continue
+
+                # Base information about rival
+                rival = Node.void('rival')
+                game.add_child(rival)
+                rival.add_child(Node.s16('no', index))
+                rival.add_child(Node.string('seq', ID.format_extid(other_profile.get_int('extid'))))
+                rival.add_child(Node.string('name', other_profile.get_str('name')))
+
+                # Return scores for this user on random charts
+                scores = self.data.remote.music.get_scores(self.game, self.version, link.other_userid)
+                for score in scores:
+                    music = Node.void('music')
+                    rival.add_child(music)
+                    music.set_attribute('id', str(score.id))
+                    music.set_attribute('type', str(score.chart))
+                    music.set_attribute('sc', str(score.points))
+
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game_3')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.s16('skill_name_id', profile.get_int('chosen_skill_id', profile.get_int('skill_name_id', -1))))
+        game.add_child(Node.s32_array('hidden_param', profile.get_int_array('hidden_param', 20)))
+        game.add_child(Node.u32('blaster_energy', profile.get_int('blaster_energy')))
+        game.add_child(Node.u32('blaster_count', profile.get_int('blaster_count')))
+
+        # Play statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        game.add_child(Node.u32('play_count', statistics.get_int('total_plays', 0)))
+        game.add_child(Node.u32('daily_count', today_count))
+        game.add_child(Node.u32('play_chain', statistics.get_int('consecutive_days', 0)))
+
+        # Last played stuff
+        if 'last' in profile:
+            lastdict = profile.get_dict('last')
+            last = Node.void('last')
+            game.add_child(last)
+            last.add_child(Node.s32('music_id', lastdict.get_int('music_id', -1)))
+            last.add_child(Node.u8('music_type', lastdict.get_int('music_type')))
+            last.add_child(Node.u8('sort_type', lastdict.get_int('sort_type')))
+            last.add_child(Node.u8('narrow_down', lastdict.get_int('narrow_down')))
+            last.add_child(Node.u8('headphone', lastdict.get_int('headphone')))
+            last.add_child(Node.u16('appeal_id', lastdict.get_int('appeal_id', 1001)))
+            last.add_child(Node.u16('comment_id', lastdict.get_int('comment_id')))
+            last.add_child(Node.u8('gauge_option', lastdict.get_int('gauge_option')))
+
+        # Item unlocks
+        itemnode = Node.void('item')
+        game.add_child(itemnode)
+
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+
+            if game_config.get_bool('force_unlock_songs') and itemtype == self.GAME_CATALOG_TYPE_SONG:
+                # Don't echo unlocked songs, we will add all of them later
+                continue
+            if game_config.get_bool('force_unlock_cards') and itemtype == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                # Don't echo unlocked appeal cards, we will add all of them later
+                continue
+            if game_config.get_bool('force_unlock_crew') and itemtype == self.GAME_CATALOG_TYPE_CREW:
+                # Don't echo unlocked crew, we will add all of them later
+                continue
+
+            info = Node.void('info')
+            itemnode.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u32('id', item.id))
+            info.add_child(Node.u32('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for itemid in ids:
+                if ids[itemid] == 0:
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('id', itemid))
+                info.add_child(Node.u32('param', ids[itemid]))
+
+        if game_config.get_bool('force_unlock_cards'):
+            catalog = self.data.local.game.get_items(self.game, self.version)
+            for unlock in catalog:
+                if unlock.type != 'appealcard':
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_APPEAL_CARD))
+                info.add_child(Node.u32('id', unlock.id))
+                info.add_child(Node.u32('param', 1))
+
+        if game_config.get_bool('force_unlock_crew'):
+            for crewid in range(1, 781):
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_CREW))
+                info.add_child(Node.u32('id', crewid))
+                info.add_child(Node.u32('param', 1))
+
+        # Skill courses
+        skill = Node.void('skill')
+        game.add_child(skill)
+        course_all = Node.void('course_all')
+        skill.add_child(course_all)
+        skill_level = -1
+
+        for course in achievements:
+            if course.type != 'course':
+                continue
+
+            course_id = course.id % 100
+            season_id = int(course.id / 100)
+
+            if course.data.get_int('clear_type') >= 2:
+                # The user cleared this, lets take the highest level clear for this
+                courselist = [
+                    c for c in
+                    self._get_skill_analyzer_courses() if
+                    c.get('id', c['level']) == course_id and
+                    c['season_id'] == season_id
+                ]
+                if len(courselist) > 0:
+                    skill_level = max(skill_level, courselist[0]['level'])
+
+            info = Node.void('d')
+            course_all.add_child(info)
+            info.add_child(Node.s16('crsid', course_id))
+            info.add_child(Node.s16('ct', course.data.get_int('clear_type')))
+            info.add_child(Node.s16('ar', course.data.get_int('achievement_rate')))
+            info.add_child(Node.s32('ssnid', season_id))
+
+        # Calculated skill level
+        game.add_child(Node.s16('skill_level', skill_level))
+
+        # Story mode unlocks
+        storynode = Node.void('story')
+        game.add_child(storynode)
+
+        for story in achievements:
+            if story.type != 'story':
+                continue
+
+            info = Node.void('info')
+            storynode.add_child(info)
+            info.add_child(Node.s32('story_id', story.id))
+            info.add_child(Node.s32('progress_id', story.data.get_int('progress_id')))
+            info.add_child(Node.s32('progress_param', story.data.get_int('progress_param')))
+            info.add_child(Node.s32('clear_cnt', story.data.get_int('clear_cnt')))
+            info.add_child(Node.u32('route_flg', story.data.get_int('route_flg')))
+
+        # Game parameters
+        paramnode = Node.void('param')
+        game.add_child(paramnode)
+
+        for param in achievements:
+            if param.type[:6] != 'param_':
+                continue
+            paramtype = int(param.type[6:])
+
+            info = Node.void('info')
+            paramnode.add_child(info)
+            info.add_child(Node.s32('id', param.id))
+            info.add_child(Node.s32('type', paramtype))
+            info.add_child(Node.s32_array('param', param.data['param']))  # This looks to be variable, so no validation on length
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update blaster energy and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        earned_blaster_energy = request.child_value('earned_blaster_energy')
+        if earned_blaster_energy is not None:
+            newprofile.replace_int('blaster_energy', newprofile.get_int('blaster_energy') + earned_blaster_energy)
+
+        # Miscelaneous stuff
+        newprofile.replace_int('blaster_count', request.child_value('blaster_count'))
+        newprofile.replace_int('chosen_skill_id', request.child_value('skill_name_id'))
+        newprofile.replace_int_array('hidden_param', 20, request.child_value('hidden_param'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+
+        if request.child('item') is not None:
+            for child in request.child('item').children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+
+                if game_config.get_bool('force_unlock_cards') and item_type == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                    # Don't save back appeal cards because they were force unlocked
+                    continue
+                if game_config.get_bool('force_unlock_songs') and item_type == self.GAME_CATALOG_TYPE_SONG:
+                    # Don't save back songs, because they were force unlocked
+                    continue
+                if game_config.get_bool('force_unlock_crew') and item_type == self.GAME_CATALOG_TYPE_CREW:
+                    # Don't save back crew, because they were force unlocked
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Update story progress
+        if request.child('story') is not None:
+            for child in request.child('story').children:
+                if child.name != 'info':
+                    continue
+
+                story_id = child.child_value('story_id')
+                progress_id = child.child_value('progress_id')
+                progress_param = child.child_value('progress_param')
+                clear_cnt = child.child_value('clear_cnt')
+                route_flg = child.child_value('route_flg')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    story_id,
+                    'story',
+                    {
+                        'progress_id': progress_id,
+                        'progress_param': progress_param,
+                        'clear_cnt': clear_cnt,
+                        'route_flg': route_flg,
+                    },
+                )
+
+        # Update params
+        if request.child('param') is not None:
+            for child in request.child('param').children:
+                if child.name != 'info':
+                    continue
+
+                param_id = child.child_value('id')
+                param_type = child.child_value('type')
+                param_param = child.child_value('param')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    param_id,
+                    'param_{}'.format(param_type),
+                    {
+                        'param': param_param,
+                    },
+                )
+
+        # Grab last information.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('appeal_id', request.child_value('appeal_id'))
+        lastdict.replace_int('comment_id', request.child_value('comment_id'))
+        lastdict.replace_int('music_id', request.child_value('music_id'))
+        lastdict.replace_int('music_type', request.child_value('music_type'))
+        lastdict.replace_int('sort_type', request.child_value('sort_type'))
+        lastdict.replace_int('narrow_down', request.child_value('narrow_down'))
+        lastdict.replace_int('gauge_option', request.child_value('gauge_option'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/sdvx/heavenlyhaven.py b/bemani/backend/sdvx/heavenlyhaven.py
new file mode 100644
index 0000000..057f3ba
--- /dev/null
+++ b/bemani/backend/sdvx/heavenlyhaven.py
@@ -0,0 +1,4135 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, List, Optional, Tuple
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.sdvx.base import SoundVoltexBase
+from bemani.backend.sdvx.gravitywars import SoundVoltexGravityWars
+from bemani.common import ID, Time, ValidatedDict, VersionConstants
+from bemani.data import Score, UserID
+from bemani.protocol import Node
+
+
+class SoundVoltexHeavenlyHaven(
+    EventLogHandler,
+    SoundVoltexBase,
+):
+
+    name = 'SOUND VOLTEX IV HEAVENLY HAVEN'
+    version = VersionConstants.SDVX_HEAVENLY_HAVEN
+
+    GAME_LIMITED_LOCKED = 1
+    GAME_LIMITED_UNLOCKABLE = 2
+    GAME_LIMITED_UNLOCKED = 3
+
+    GAME_CURRENCY_PACKETS = 0
+    GAME_CURRENCY_BLOCKS = 1
+
+    GAME_CATALOG_TYPE_SONG = 0
+    GAME_CATALOG_TYPE_APPEAL_CARD = 1
+    GAME_CATALOG_TYPE_CREW = 4
+
+    GAME_CLEAR_TYPE_NO_PLAY = 0
+    GAME_CLEAR_TYPE_FAILED = 1
+    GAME_CLEAR_TYPE_CLEAR = 2
+    GAME_CLEAR_TYPE_HARD_CLEAR = 3
+    GAME_CLEAR_TYPE_ULTIMATE_CHAIN = 4
+    GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN = 5
+
+    GAME_GRADE_NO_PLAY = 0
+    GAME_GRADE_D = 1
+    GAME_GRADE_C = 2
+    GAME_GRADE_B = 3
+    GAME_GRADE_A = 4
+    GAME_GRADE_A_PLUS = 5
+    GAME_GRADE_AA = 6
+    GAME_GRADE_AA_PLUS = 7
+    GAME_GRADE_AAA = 8
+    GAME_GRADE_AAA_PLUS = 9
+    GAME_GRADE_S = 10
+
+    GAME_SKILL_NAME_ID_LV_01 = 1
+    GAME_SKILL_NAME_ID_LV_02 = 2
+    GAME_SKILL_NAME_ID_LV_03 = 3
+    GAME_SKILL_NAME_ID_LV_04 = 4
+    GAME_SKILL_NAME_ID_LV_05 = 5
+    GAME_SKILL_NAME_ID_LV_06 = 6
+    GAME_SKILL_NAME_ID_LV_07 = 7
+    GAME_SKILL_NAME_ID_LV_08 = 8
+    GAME_SKILL_NAME_ID_LV_09 = 9
+    GAME_SKILL_NAME_ID_LV_10 = 10
+    GAME_SKILL_NAME_ID_LV_11 = 11
+    GAME_SKILL_NAME_ID_LV_INF = 12
+    GAME_SKILL_NAME_ID_KAC_6TH_BODY = 13
+    GAME_SKILL_NAME_ID_KAC_6TH_TECHNOLOGY = 14
+    GAME_SKILL_NAME_ID_KAC_6TH_HEART = 15
+    GAME_SKILL_NAME_ID_TENKAICHI = 16
+    GAME_SKILL_NAME_ID_MUSIC_FESTIVAL = 17
+    GAME_SKILL_NAME_ID_YELLOWTAIL = 18  # For the April Fool's day courses.
+    GAME_SKILL_NAME_ID_BMK2017 = 19
+    GAME_SKILL_NAME_ID_KAC_7TH_TIGER = 20
+    GAME_SKILL_NAME_ID_KAC_7TH_WOLF = 21
+    GAME_SKILL_NAME_ID_RIKKA = 22  # For the course that ran from 1/18/2018-2/18/2018
+    GAME_SKILL_NAME_ID_KAC_8TH = 23
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Disable Online Matching',
+                    'tip': 'Disable online matching between games.',
+                    'category': 'game_config',
+                    'setting': 'disable_matching',
+                },
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+                {
+                    'name': 'Force Appeal Card Unlock',
+                    'tip': 'Force unlock all appeal cards.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_cards',
+                },
+                {
+                    'name': 'Force Crew Card Unlock',
+                    'tip': 'Force unlock all crew and subcrew cards.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_crew',
+                },
+            ],
+        }
+
+    def previous_version(self) -> Optional[SoundVoltexBase]:
+        return SoundVoltexGravityWars(self.data, self.config, self.model)
+
+    def extra_services(self) -> List[str]:
+        """
+        Return the local2 service so that SDVX 4 and above will send certain packets.
+        """
+        return [
+            'local2',
+        ]
+
+    def __game_to_db_clear_type(self, clear_type: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_NO_PLAY: self.CLEAR_TYPE_NO_PLAY,
+            self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEAR: self.CLEAR_TYPE_CLEAR,
+            self.GAME_CLEAR_TYPE_HARD_CLEAR: self.CLEAR_TYPE_HARD_CLEAR,
+            self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN: self.CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __db_to_game_clear_type(self, clear_type: int) -> int:
+        return {
+            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_PLAY,
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
+            self.CLEAR_TYPE_CLEAR: self.GAME_CLEAR_TYPE_CLEAR,
+            self.CLEAR_TYPE_HARD_CLEAR: self.GAME_CLEAR_TYPE_HARD_CLEAR,
+            self.CLEAR_TYPE_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __game_to_db_grade(self, grade: int) -> int:
+        return {
+            self.GAME_GRADE_NO_PLAY: self.GRADE_NO_PLAY,
+            self.GAME_GRADE_D: self.GRADE_D,
+            self.GAME_GRADE_C: self.GRADE_C,
+            self.GAME_GRADE_B: self.GRADE_B,
+            self.GAME_GRADE_A: self.GRADE_A,
+            self.GAME_GRADE_A_PLUS: self.GRADE_A_PLUS,
+            self.GAME_GRADE_AA: self.GRADE_AA,
+            self.GAME_GRADE_AA_PLUS: self.GRADE_AA_PLUS,
+            self.GAME_GRADE_AAA: self.GRADE_AAA,
+            self.GAME_GRADE_AAA_PLUS: self.GRADE_AAA_PLUS,
+            self.GAME_GRADE_S: self.GRADE_S,
+        }[grade]
+
+    def __db_to_game_grade(self, grade: int) -> int:
+        return {
+            self.GRADE_NO_PLAY: self.GAME_GRADE_NO_PLAY,
+            self.GRADE_D: self.GAME_GRADE_D,
+            self.GRADE_C: self.GAME_GRADE_C,
+            self.GRADE_B: self.GAME_GRADE_B,
+            self.GRADE_A: self.GAME_GRADE_A,
+            self.GRADE_A_PLUS: self.GAME_GRADE_A_PLUS,
+            self.GRADE_AA: self.GAME_GRADE_AA,
+            self.GRADE_AA_PLUS: self.GAME_GRADE_AA_PLUS,
+            self.GRADE_AAA: self.GAME_GRADE_AAA,
+            self.GRADE_AAA_PLUS: self.GAME_GRADE_AAA_PLUS,
+            self.GRADE_S: self.GAME_GRADE_S,
+        }[grade]
+
+    def handle_game_sv4_exception_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+    def handle_game_sv4_lounge_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        # Refresh interval in seconds.
+        game.add_child(Node.u32('interval', 10))
+        return game
+
+    def handle_game_sv4_entry_s_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        # This should be created on the fly for a lobby that we're in.
+        game.add_child(Node.u32('entry_id', 1))
+        return game
+
+    def handle_game_sv4_entry_e_request(self, request: Node) -> Node:
+        # Lobby destroy method, eid node (u32) should be used
+        # to destroy any open lobbies.
+        return Node.void('game')
+
+    def __get_skill_analyzer_seasons(self) -> Dict[int, str]:
+        return {
+            0: "第1回 Aコース",
+            1: "第1回 Bコース",
+            2: "第1回 Cコース",
+            3: "第2回 Aコース",
+            4: "第2回 Bコース",
+            5: "第3回",
+            6: "第4回 Aコース",
+            7: "第4回 Bコース",
+            8: "第4回 Cコース",
+            9: "第5回",
+            10: "第6回 Aコース",
+            11: "第6回 Bコース",
+            12: "第6回 Cコース",
+            13: "The 6th KAC挑戦コース【体】",
+            14: "The 6th KAC挑戦コース【技】",
+            15: "The 6th KAC挑戦コース【心】",
+            16: "天下一 (梅)",
+            17: "天下一 (竹)",
+            18: "天下一 (松)",
+            19: "BEMANI MASTER KOREA 2017",
+            20: "The 7th KACチャレンジコース【猛虎】",
+            21: "The 7th KACチャレンジコース【餓狼】",
+            22: "The 8th KACチャレンジコース【阿修羅】",
+            23: "The 8th KACエンジョイコース【阿修羅】",
+            24: "第5回 Bコース",
+        }
+
+    def __get_skill_analyzer_skill_levels(self) -> Dict[int, str]:
+        return {
+            1: "SKILL ANALYZER Level.01",
+            2: "SKILL ANALYZER Level.02",
+            3: "SKILL ANALYZER Level.03",
+            4: "SKILL ANALYZER Level.04",
+            5: "SKILL ANALYZER Level.05",
+            6: "SKILL ANALYZER Level.06",
+            7: "SKILL ANALYZER Level.07",
+            8: "SKILL ANALYZER Level.08",
+            9: "SKILL ANALYZER Level.09",
+            10: "SKILL ANALYZER Level.10",
+            11: "SKILL ANALYZER Level.11",
+            12: "SKILL ANALYZER Level.∞",
+        }
+
+    def __get_skill_analyzer_skill_name_ids(self) -> Dict[int, int]:
+        return {
+            1: self.GAME_SKILL_NAME_ID_LV_01,
+            2: self.GAME_SKILL_NAME_ID_LV_02,
+            3: self.GAME_SKILL_NAME_ID_LV_03,
+            4: self.GAME_SKILL_NAME_ID_LV_04,
+            5: self.GAME_SKILL_NAME_ID_LV_05,
+            6: self.GAME_SKILL_NAME_ID_LV_06,
+            7: self.GAME_SKILL_NAME_ID_LV_07,
+            8: self.GAME_SKILL_NAME_ID_LV_08,
+            9: self.GAME_SKILL_NAME_ID_LV_09,
+            10: self.GAME_SKILL_NAME_ID_LV_10,
+            11: self.GAME_SKILL_NAME_ID_LV_11,
+            12: self.GAME_SKILL_NAME_ID_LV_INF,
+        }
+
+    def __get_skill_analyzer_courses(self) -> List[Dict[str, Any]]:
+        return [
+            # Skill LV.01
+            {
+                'season_id': 0,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 653,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 846,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 60,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 770,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 16,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 17,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 922,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 76,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 201,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 182,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 766,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 106,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 568,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 768,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 795,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 110,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 51,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 913,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 189,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 1025,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 914,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 186,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 600,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 915,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 671,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 1035,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 1014,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1033,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 1044,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 1176,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 1083,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 1049,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 1005,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 1,
+                'tracks': [
+                    {
+                        'id': 1190,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 636,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 1054,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # Skill LV.02
+            {
+                'season_id': 0,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 6,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 222,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 48,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 566,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 748,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 19,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 40,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 275,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 171,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 950,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 513,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 185,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 700,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 923,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 219,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 528,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 996,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 486,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 66,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 93,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 664,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 3,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 191,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 771,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 8,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 405,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 451,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 173,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 1074,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1095,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 930,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 1057,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1081,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 868,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 2,
+                'tracks': [
+                    {
+                        'id': 1076,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1002,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 916,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # Skill LV.03
+            {
+                'season_id': 0,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 775,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 684,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 778,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 523,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 921,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 218,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # Skill course for Season ID 2 was removed due to removed songs.
+            {
+                'season_id': 3,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 557,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 843,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 317,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 882,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 531,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 161,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 291,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 970,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 674,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 216,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 434,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 590,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 898,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 152,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 353,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 896,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 39,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 1008,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 608,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 815,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 1086,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1122,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1026,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 1001,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1092,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1113,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 3,
+                'tracks': [
+                    {
+                        'id': 1004,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1111,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1090,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # Skill LV.04
+            {
+                'season_id': 0,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 757,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 480,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 758,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 467,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 456,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 107,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 67,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 544,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 9,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 449,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 506,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 962,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 136,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 534,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 640,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 630,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 647,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 785,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 781,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 623,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 540,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 104,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 521,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 342,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 485,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 359,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 834,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 966,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 983,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 967,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 1070,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1073,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1022,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 1075,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1123,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1029,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 4,
+                'tracks': [
+                    {
+                        'id': 1094,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1128,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1027,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # Skill LV.05
+            {
+                'season_id': 0,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 871,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 327,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 66,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 435,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 750,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 700,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 318,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 157,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 567,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 760,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1020,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 923,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 65,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 966,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 874,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 645,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 335,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 961,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 695,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 276,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 870,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 743,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 958,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 441,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 790,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 277,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 944,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 964,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 58,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1025,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 1040,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1200,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 895,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 1024,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1201,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1124,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 5,
+                'tracks': [
+                    {
+                        'id': 1007,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1220,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1067,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Skill LV.06
+            {
+                'season_id': 0,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 713,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 40,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 33,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 230,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 827,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 146,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 239,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 375,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 94,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 80,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 678,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 928,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 856,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 488,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 968,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 172,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 262,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 781,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 998,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 885,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 400,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 301,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 879,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 62,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 897,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 986,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 898,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 962,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1032,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 1115,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1184,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1230,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 1154,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1114,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 891,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 6,
+                'tracks': [
+                    {
+                        'id': 1139,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 864,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1010,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Skill LV.07
+            {
+                'season_id': 0,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 349,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 896,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 210,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 558,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 368,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 769,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 710,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 609,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 967,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 711,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 594,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 738,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 834,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 762,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 544,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 898,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 211,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 14,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 666,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 54,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 763,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 145,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 99,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 490,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 889,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1042,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 1156,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1138,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1091,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 1012,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1248,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 926,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 7,
+                'tracks': [
+                    {
+                        'id': 1134,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 919,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1250,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Skill LV.08
+            {
+                'season_id': 0,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 690,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 380,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 492,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 603,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 278,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 557,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 357,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 562,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 612,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 26,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 503,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 945,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 639,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 644,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 521,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 572,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 173,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 659,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 749,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 251,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 361,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 744,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 831,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 372,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 747,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 872,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 971,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 752,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1062,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 336,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1199,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1197,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 955,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1037,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 812,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 8,
+                'tracks': [
+                    {
+                        'id': 596,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 902,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 844,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # Skill LV.09
+            # Skill course for Season ID 0 was removed due to removed songs.
+            {
+                'season_id': 1,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 295,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 742,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 302,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 759,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 607,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 599,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 946,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 394,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 228,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 124,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 456,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 852,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 252,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 918,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 47,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 917,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 959,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 912,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 576,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 943,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 359,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 497,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 948,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 954,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 841,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1087,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1112,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 761,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 765,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1006,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 9,
+                'tracks': [
+                    {
+                        'id': 737,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 887,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 933,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            # Skill LV.10
+            {
+                'season_id': 0,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 833,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 858,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 229,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 1,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 871,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 259,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 2,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 779,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 817,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 3,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 961,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 967,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 993,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 214,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 365,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 966,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 876,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 506,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 641,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 463,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 712,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 390,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 655,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 707,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 8,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 922,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 166,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 670,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 1126,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1034,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 834,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 1217,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1041,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1078,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 1237,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1157,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 907,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 12,
+                'skill_level': 10,
+                'tracks': [
+                    {
+                        'id': 1228,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 881,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1135,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            # Skill LV.11
+            {
+                'season_id': 3,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 941,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 718,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 816,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 4,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 30,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 540,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 931,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 818,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 810,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 789,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 634,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 532,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 808,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 965,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 909,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 1013,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1035,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1107,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 173,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 151,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 11,
+                'skill_level': 11,
+                'tracks': [
+                    {
+                        'id': 1060,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1062,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1222,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            # Skill LV.Inf
+            {
+                'season_id': 3,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 654,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 1028,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 5,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 709,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 374,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 1036,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 6,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 551,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1032,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1099,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 7,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 927,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 525,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 1100,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 9,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 1102,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1148,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1185,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 24,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 661,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 791,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 10,
+                'skill_level': 12,
+                'tracks': [
+                    {
+                        'id': 679,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1178,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 1270,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            # 6th KAC
+            {
+                'season_id': 13,
+                'course_id': 1,
+                'course_name': 'The 6th KAC挑戦コース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_6TH_BODY,
+                'course_type': 2,
+                'tracks': [
+                    {
+                        'id': 806,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 971,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 913,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 14,
+                'course_id': 1,
+                'course_name': 'The 6th KAC挑戦コース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_6TH_TECHNOLOGY,
+                'course_type': 2,
+                'tracks': [
+                    {
+                        'id': 758,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 965,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 914,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 15,
+                'course_id': 1,
+                'course_name': 'The 6th KAC挑戦コース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_6TH_HEART,
+                'course_type': 2,
+                'tracks': [
+                    {
+                        'id': 814,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 964,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 915,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'season_id': 13,
+                'course_id': 2,
+                'course_name': 'The 6th KAC挑戦コース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_6TH_BODY,
+                'course_type': 2,
+                'tracks': [
+                    {
+                        'id': 806,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 971,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 913,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 14,
+                'course_id': 2,
+                'course_name': 'The 6th KAC挑戦コース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_6TH_TECHNOLOGY,
+                'course_type': 2,
+                'tracks': [
+                    {
+                        'id': 758,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 965,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 914,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 15,
+                'course_id': 2,
+                'course_name': 'The 6th KAC挑戦コース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_6TH_HEART,
+                'course_type': 2,
+                'tracks': [
+                    {
+                        'id': 814,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 964,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 915,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # Tenkaichi courses.
+            {
+                'season_id': 16,
+                'course_id': 1,
+                'course_name': '天下一',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_TENKAICHI,
+                'course_type': 3,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 708,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'season_id': 17,
+                'course_id': 1,
+                'course_name': '天下一',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_TENKAICHI,
+                'course_type': 3,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 708,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 18,
+                'course_id': 1,
+                'course_name': '天下一',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_TENKAICHI,
+                'course_type': 3,
+                'tracks': [
+                    {
+                        'id': 625,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 697,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 708,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'season_id': 16,
+                'course_id': 2,
+                'course_name': '天下一',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_MUSIC_FESTIVAL,
+                'course_type': 3,
+                'tracks': [
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 927,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'season_id': 17,
+                'course_id': 2,
+                'course_name': '天下一',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_MUSIC_FESTIVAL,
+                'course_type': 3,
+                'tracks': [
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 927,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 18,
+                'course_id': 2,
+                'course_name': '天下一',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_MUSIC_FESTIVAL,
+                'course_type': 3,
+                'tracks': [
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 927,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            # BMK2017 courses
+            {
+                'season_id': 19,
+                'course_id': 1,
+                'course_name': 'BEMANI MASTER KOREA',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_BMK2017,
+                'tracks': [
+                    {
+                        'id': 954,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 960,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 961,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            # 7th KAC
+            {
+                'season_id': 20,
+                'course_id': 1,
+                'course_name': 'The 7th KACチャレンジコース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_7TH_TIGER,
+                'course_type': 4,
+                'tracks': [
+                    {
+                        'id': 1149,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1102,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 21,
+                'course_id': 1,
+                'course_name': 'The 7th KACチャレンジコース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_7TH_WOLF,
+                'course_type': 4,
+                'tracks': [
+                    {
+                        'id': 1042,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 1101,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 20,
+                'course_id': 2,
+                'course_name': 'The 7th KACチャレンジコース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_7TH_TIGER,
+                'course_type': 4,
+                'tracks': [
+                    {
+                        'id': 1149,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1102,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'season_id': 21,
+                'course_id': 2,
+                'course_name': 'The 7th KACチャレンジコース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_7TH_WOLF,
+                'course_type': 4,
+                'tracks': [
+                    {
+                        'id': 1042,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1101,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            # 8th KAC
+            {
+                'season_id': 22,
+                'course_id': 1,
+                'course_name': 'The 8th KACチャレンジコース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_8TH,
+                'course_type': 5,
+                'tracks': [
+                    {
+                        'id': 1334,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                    {
+                        'id': 610,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 1033,
+                        'type': self.CHART_TYPE_MAXIMUM,
+                    },
+                ],
+            },
+            {
+                'season_id': 23,
+                'course_id': 1,
+                'course_name': 'The 8th KACエンジョイコース',
+                'skill_name_id': self.GAME_SKILL_NAME_ID_KAC_8TH,
+                'course_type': 5,
+                'tracks': [
+                    {
+                        'id': 1334,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 610,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 1033,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+        ]
+
+    def handle_game_sv4_common_request(self, request: Node) -> Node:
+        game = Node.void('game')
+
+        limited = Node.void('music_limited')
+        game.add_child(limited)
+
+        # Song unlock config
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_songs'):
+            ids = set()
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.data.get_int('limited') in (self.GAME_LIMITED_LOCKED, self.GAME_LIMITED_UNLOCKABLE):
+                    ids.add((song.id, song.chart))
+
+            for (songid, chart) in ids:
+                info = Node.void('info')
+                limited.add_child(info)
+                info.add_child(Node.s32('music_id', songid))
+                info.add_child(Node.u8('music_type', chart))
+                info.add_child(Node.u8('limited', self.GAME_LIMITED_UNLOCKED))
+
+        # Catalog, maybe this is for the online store?
+        catalog = Node.void('catalog')
+        game.add_child(catalog)
+
+        for item in []:  # type: ignore
+            info = Node.void('info')
+            catalog.add_child(info)
+            info.add_child(Node.u8('catalog_type', 0))
+            info.add_child(Node.u32('catalog_id', 0))
+            info.add_child(Node.u32('discount_rate', 0))
+
+        # Event config
+        event = Node.void('event')
+        game.add_child(event)
+
+        def enable_event(eid: str) -> None:
+            evt = Node.void('info')
+            event.add_child(evt)
+            evt.add_child(Node.string('event_id', eid))
+
+        if not game_config.get_bool('disable_matching'):
+            # Matching enabled events
+            enable_event("MATCHING_MODE")
+            enable_event("MATCHING_MODE_FREE_IP")
+        enable_event("ICON_FLOOR_INFECTION")
+        enable_event("ICON_POLICY_BREAK")
+        enable_event("ACHIEVEMENT_ENABLE")
+        enable_event("VOLFORCE_ENABLE")
+        enable_event("CONTINUATION")
+        enable_event("TENKAICHI_MODE")
+        enable_event("SERIALCODE_JAPAN")
+        enable_event("DEMOGAME_PLAY")
+        enable_event("TOTAL_MEMORIAL_ENABLE")
+        enable_event("EVENT_IDS_SERIALCODE_TOHO_02")
+        enable_event("KONAMI_50TH_LOGO")
+        enable_event("KAC6TH_FINISH")
+        enable_event("KAC7TH_FINISH")
+        enable_event("KAC8TH_FINISH")
+
+        # An old collaboration event we don't support.
+        reitaisai = Node.void('reitaisai2018')
+        game.add_child(reitaisai)
+
+        # Volte factory, an older event we don't support.
+        volte_factory = Node.void('volte_factory')
+        game.add_child(volte_factory)
+        goods = Node.void('goods')
+        volte_factory.add_child(goods)
+        stock = Node.void('stock')
+        volte_factory.add_child(stock)
+
+        # I think this is a list of purchaseable appeal cards.
+        appealcard = Node.void('appealcard')
+        game.add_child(appealcard)
+
+        # Event parameters (we don't support story mode).
+        extend = Node.void('extend')
+        game.add_child(extend)
+
+        # Available skill courses
+        skill_course = Node.void('skill_course')
+        game.add_child(skill_course)
+
+        achievements = self.data.local.user.get_all_achievements(self.game, self.version)
+        courserates: Dict[Tuple[int, int], Dict[str, int]] = {}
+
+        def getrates(season_id: int, course_id: int) -> Dict[str, int]:
+            if (course_id, season_id) in courserates:
+                return courserates[(course_id, season_id)]
+            else:
+                return {
+                    'attempts': 0,
+                    'clears': 0,
+                    'total_score': 0,
+                }
+
+        for _, achievement in achievements:
+            if achievement.type != 'course':
+                continue
+
+            course_id = achievement.id % 100
+            season_id = int(achievement.id / 100)
+            rate = getrates(season_id, course_id)
+
+            rate['attempts'] += 1
+            if achievement.data.get_int('clear_type') >= 2:
+                rate['clears'] += 1
+            rate['total_score'] = achievement.data.get_int('score')
+            courserates[(course_id, season_id)] = rate
+
+        seasons = self.__get_skill_analyzer_seasons()
+        skill_levels = self.__get_skill_analyzer_skill_levels()
+        courses = self.__get_skill_analyzer_courses()
+        skill_name_ids = self.__get_skill_analyzer_skill_name_ids()
+        for course in courses:
+            info = Node.void('info')
+            skill_course.add_child(info)
+
+            info.add_child(Node.s32('season_id', course['season_id']))
+            info.add_child(Node.string('season_name', seasons[course['season_id']]))
+            info.add_child(Node.bool('season_new_flg', course['season_id'] in {10, 11, 12, 22, 23}))
+            info.add_child(Node.s16('course_id', course.get('course_id', course.get('skill_level', -1))))
+            info.add_child(Node.string('course_name', course.get('course_name', skill_levels.get(course.get('skill_level', -1), ''))))
+            # Course type 0 is skill level courses. The course type is the same as the skill level (01-12).
+            # If skill level is specified as '0', then the course type shows up as 'OTHER' instead of Skill Lv.01-12.
+            # Course type 2 = KAC 6th.
+            # Course type 3 = TENKAICHI mode.
+            # Course type 4 = KAC 7th.
+            # Course type 5 = KAC 8th.
+            info.add_child(Node.s16('course_type', course.get('course_type', 0)))
+            info.add_child(Node.s16('skill_level', course.get('skill_level', 0)))
+            info.add_child(Node.s16('skill_name_id', course.get('skill_name_id', skill_name_ids.get(course.get('skill_level', -1), 0))))
+            info.add_child(Node.bool('matching_assist', course.get('skill_level', -1) >= 1 and course.get('skill_level', -1) <= 7))
+
+            # Calculate clear rate and average score
+            rate = getrates(course['season_id'], course.get('course_id', course.get('skill_level', -1)))
+            if rate['attempts'] > 0:
+                info.add_child(Node.s32('clear_rate', int(100.0 * (rate['clears'] / rate['attempts']))))
+                info.add_child(Node.u32('avg_score', rate['total_score'] // rate['attempts']))
+            else:
+                info.add_child(Node.s32('clear_rate', 0))
+                info.add_child(Node.u32('avg_score', 0))
+
+            for trackno, trackdata in enumerate(course['tracks']):
+                track = Node.void('track')
+                info.add_child(track)
+                track.add_child(Node.s16('track_no', trackno))
+                track.add_child(Node.s32('music_id', trackdata['id']))
+                track.add_child(Node.s8('music_type', trackdata['type']))
+
+        # Museca link event that we don't support.
+        museca_link = Node.void('museca_link')
+        game.add_child(museca_link)
+
+        return game
+
+    def handle_game_sv4_shop_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('shopname'))
+
+        # Respond with number of milliseconds until next request
+        game = Node.void('game')
+        game.add_child(Node.u32('nxt_time', 1000 * 5 * 60))
+        return game
+
+    def handle_game_sv4_hiscore_request(self, request: Node) -> Node:
+        # Grab location for local scores
+        locid = ID.parse_machine_id(request.child_value('locid'))
+
+        game = Node.void('game')
+
+        # Now, grab global and local scores as well as clear rates
+        global_records = self.data.remote.music.get_all_records(self.game, self.version)
+        users = {
+            uid: prof for (uid, prof) in self.data.local.user.get_all_profiles(self.game, self.version)
+        }
+        area_users = [
+            uid for uid in users
+            if users[uid].get_int('loc', -1) == locid
+        ]
+        area_records = self.data.local.music.get_all_records(self.game, self.version, userlist=area_users)
+        clears = self.get_clear_rates()
+        records: Dict[int, Dict[int, Dict[str, Tuple[UserID, Score]]]] = {}
+
+        missing_users = (
+            [userid for (userid, _) in global_records if userid not in users] +
+            [userid for (userid, _) in area_records if userid not in users]
+        )
+        for (userid, profile) in self.get_any_profiles(missing_users):
+            users[userid] = profile
+
+        for (userid, score) in global_records:
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            if score.id not in records:
+                records[score.id] = {}
+            if score.chart not in records[score.id]:
+                records[score.id][score.chart] = {}
+            records[score.id][score.chart]['global'] = (userid, score)
+
+        for (userid, score) in area_records:
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            if score.id not in records:
+                records[score.id] = {}
+            if score.chart not in records[score.id]:
+                records[score.id][score.chart] = {}
+            records[score.id][score.chart]['area'] = (userid, score)
+
+        # Output it to the game
+        highscores = Node.void('sc')
+        game.add_child(highscores)
+        for musicid in records:
+            for chart in records[musicid]:
+                (globaluserid, globalscore) = records[musicid][chart]['global']
+
+                global_profile = users[globaluserid]
+                if clears[musicid][chart]['total'] > 0:
+                    clear_rate = float(clears[musicid][chart]['clears']) / float(clears[musicid][chart]['total'])
+                else:
+                    clear_rate = 0.0
+
+                info = Node.void('d')
+                highscores.add_child(info)
+                info.add_child(Node.u32('id', musicid))
+                info.add_child(Node.u32('ty', chart))
+                info.add_child(Node.string('a_sq', ID.format_extid(global_profile.get_int('extid'))))
+                info.add_child(Node.string('a_nm', global_profile.get_str('name')))
+                info.add_child(Node.u32('a_sc', globalscore.points))
+                info.add_child(Node.s32('cr', int(clear_rate * 10000)))
+                info.add_child(Node.s32('avg_sc', clears[musicid][chart]['average']))
+
+                if 'area' in records[musicid][chart]:
+                    (localuserid, localscore) = records[musicid][chart]['area']
+                    local_profile = users[localuserid]
+                    info.add_child(Node.string('l_sq', ID.format_extid(local_profile.get_int('extid'))))
+                    info.add_child(Node.string('l_nm', local_profile.get_str('name')))
+                    info.add_child(Node.u32('l_sc', localscore.points))
+
+        return game
+
+    def handle_game_sv4_load_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is not None:
+            return root
+
+        # Figure out if this user has an older profile or not
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            previous_game = self.previous_version()
+        else:
+            previous_game = None
+
+        if previous_game is not None:
+            profile = previous_game.get_profile(userid)
+        else:
+            profile = None
+
+        if profile is not None:
+            root = Node.void('game')
+            root.add_child(Node.u8('result', 2))
+            root.add_child(Node.string('name', profile.get_str('name')))
+            return root
+        else:
+            root = Node.void('game')
+            root.add_child(Node.u8('result', 1))
+            return root
+
+    def handle_game_sv4_frozen_request(self, request: Node) -> Node:
+        game = Node.void('game')
+        game.add_child(Node.u8('result', 0))
+        return game
+
+    def handle_game_sv4_new_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        name = request.child_value('name')
+        loc = ID.parse_machine_id(request.child_value('locid'))
+        self.new_profile_by_refid(refid, name, loc)
+
+        root = Node.void('game')
+        return root
+
+    def handle_game_sv4_load_m_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        # Output to the game
+        game = Node.void('game')
+        music = Node.void('music')
+        game.add_child(music)
+
+        for score in scores:
+            info = Node.void('info')
+            music.add_child(info)
+
+            stats = score.data.get_dict('stats')
+            info.add_child(
+                Node.u32_array(
+                    'param',
+                    [
+                        score.id,
+                        score.chart,
+                        score.points,
+                        self.__db_to_game_clear_type(score.data.get_int('clear_type')),
+                        self.__db_to_game_grade(score.data.get_int('grade')),
+                        0,  # 5: Any value
+                        0,  # 6: Any value
+                        stats.get_int('btn_rate'),
+                        stats.get_int('long_rate'),
+                        stats.get_int('vol_rate'),
+                        0,  # 10: Any value
+                        0,  # 11: Another medal, perhaps old score medal?
+                        0,  # 12: Another grade, perhaps old score grade?
+                        0,  # 13: Any value
+                        0,  # 14: Any value
+                        0,  # 15: Any value
+                        0,  # 16: Another medal, perhaps old score medal?
+                        0,  # 17: Another grade, perhaps old score grade?
+                        0,  # 18: Any value
+                        0,  # 19: Any value
+                    ],
+                ),
+            )
+
+        return game
+
+    def handle_game_sv4_load_r_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        game = Node.void('game')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            links = self.data.local.user.get_links(self.game, self.version, userid)
+            index = 0
+            for link in links:
+                if link.type != 'rival':
+                    continue
+                other_profile = self.get_profile(link.other_userid)
+                if other_profile is None:
+                    continue
+
+                # Base information about rival
+                rival = Node.void('rival')
+                game.add_child(rival)
+                rival.add_child(Node.s16('no', index))
+                rival.add_child(Node.string('seq', ID.format_extid(other_profile.get_int('extid'))))
+                rival.add_child(Node.string('name', other_profile.get_str('name')))
+
+                # Keep track of index
+                index = index + 1
+
+                # Return scores for this user on random charts
+                scores = self.data.remote.music.get_scores(self.game, self.version, link.other_userid)
+                for score in scores:
+                    music = Node.void('music')
+                    rival.add_child(music)
+                    music.add_child(
+                        Node.u32_array(
+                            'param',
+                            [
+                                score.id,
+                                score.chart,
+                                score.points,
+                                self.__db_to_game_clear_type(score.data.get_int('clear_type')),
+                                self.__db_to_game_grade(score.data.get_int('grade')),
+                            ]
+                        )
+                    )
+
+        return game
+
+    def handle_game_sv4_save_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid)
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+        else:
+            newprofile = None
+
+        if userid is not None and newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+        return Node.void('game')
+
+    def handle_game_sv4_save_m_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        # Doesn't matter if userid is None here, that's an anonymous score
+        musicid = request.child_value('music_id')
+        chart = request.child_value('music_type')
+        points = request.child_value('score')
+        combo = request.child_value('max_chain')
+        clear_type = self.__game_to_db_clear_type(request.child_value('clear_type'))
+        grade = self.__game_to_db_grade(request.child_value('score_grade'))
+        stats = {
+            'btn_rate': request.child_value('btn_rate'),
+            'long_rate': request.child_value('long_rate'),
+            'vol_rate': request.child_value('vol_rate'),
+            'critical': request.child_value('critical'),
+            'near': request.child_value('near'),
+            'error': request.child_value('error'),
+        }
+
+        # Save the score
+        self.update_score(
+            userid,
+            musicid,
+            chart,
+            points,
+            clear_type,
+            grade,
+            combo,
+            stats,
+        )
+
+        # Return a blank response
+        return Node.void('game')
+
+    def handle_game_sv4_play_e_request(self, request: Node) -> Node:
+        return Node.void('game')
+
+    def handle_game_sv4_save_e_request(self, request: Node) -> Node:
+        # This has to do with Policy floor infection, but we don't
+        # implement multi-game support so meh.
+        game = Node.void('game')
+
+        pbc_infection = Node.void('pbc_infection')
+        game.add_child(pbc_infection)
+        for name in ['packet', 'block', 'coloris']:
+            child = Node.void(name)
+            pbc_infection.add_child(child)
+            child.add_child(Node.s32('before', 0))
+            child.add_child(Node.s32('after', 0))
+
+        pb_infection = Node.void('pb_infection')
+        game.add_child(pb_infection)
+        for name in ['packet', 'block']:
+            child = Node.void(name)
+            pb_infection.add_child(child)
+            child.add_child(Node.s32('before', 0))
+            child.add_child(Node.s32('after', 0))
+
+        return game
+
+    def handle_game_sv4_play_s_request(self, request: Node) -> Node:
+        root = Node.void('game')
+        root.add_child(Node.u32('play_id', 1))
+        return root
+
+    def handle_game_sv4_buy_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            profile = self.get_profile(userid)
+        else:
+            profile = None
+
+        if userid is not None and profile is not None:
+            # Look up packets and blocks
+            packet = profile.get_int('packet')
+            block = profile.get_int('block')
+
+            # Add on any additional we earned this round
+            packet = packet + (request.child_value('earned_gamecoin_packet') or 0)
+            block = block + (request.child_value('earned_gamecoin_block') or 0)
+
+            currency_type = request.child_value('currency_type')
+            price = request.child_value('item/price')
+            if isinstance(price, list):
+                # Sometimes we end up buying more than one item at once
+                price = sum(price)
+
+            if currency_type == self.GAME_CURRENCY_PACKETS:
+                # This is a valid purchase
+                newpacket = packet - price
+                if newpacket < 0:
+                    result = 1
+                else:
+                    packet = newpacket
+                    result = 0
+            elif currency_type == self.GAME_CURRENCY_BLOCKS:
+                # This is a valid purchase
+                newblock = block - price
+                if newblock < 0:
+                    result = 1
+                else:
+                    block = newblock
+                    result = 0
+            else:
+                # Bad currency type
+                result = 1
+
+            if result == 0:
+                # Transaction is valid, update the profile with new packets and blocks
+                profile.replace_int('packet', packet)
+                profile.replace_int('block', block)
+                self.put_profile(userid, profile)
+
+                # If this was a song unlock, we should mark it as unlocked
+                item_type = request.child_value('item/item_type')
+                item_id = request.child_value('item/item_id')
+                param = request.child_value('item/param')
+
+                if not isinstance(item_type, list):
+                    # Sometimes we buy multiple things at once. Make it easier by always assuming this.
+                    item_type = [item_type]
+                    item_id = [item_id]
+                    param = [param]
+
+                for i in range(len(item_type)):
+                    self.data.local.user.put_achievement(
+                        self.game,
+                        self.version,
+                        userid,
+                        item_id[i],
+                        f'item_{item_type[i]}',
+                        {
+                            'param': param[i],
+                        },
+                    )
+
+        else:
+            # Unclear what to do here, return a bad response
+            packet = 0
+            block = 0
+            result = 1
+
+        game = Node.void('game')
+        game.add_child(Node.u32('gamecoin_packet', packet))
+        game.add_child(Node.u32('gamecoin_block', block))
+        game.add_child(Node.s8('result', result))
+        return game
+
+    def handle_game_sv4_save_c_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            season_id = request.child_value('ssnid')
+            course_id = request.child_value('crsid')
+            clear_type = request.child_value('ct')
+            achievement_rate = request.child_value('ar')
+            grade = request.child_value('gr')
+            score = request.child_value('sc')
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                (season_id * 100) + course_id,
+                'course',
+                {
+                    'clear_type': clear_type,
+                    'achievement_rate': achievement_rate,
+                    'score': score,
+                    'grade': grade,
+                },
+            )
+
+        # Return a blank response
+        return Node.void('game')
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.string('sdvx_id', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u16('appeal_id', profile.get_int('appealid')))
+        game.add_child(Node.s16('skill_base_id', profile.get_int('skill_base_id')))
+        game.add_child(Node.s16('skill_name_id', profile.get_int('skill_name_id')))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.u32('blaster_energy', profile.get_int('blaster_energy')))
+        game.add_child(Node.u32('blaster_count', profile.get_int('blaster_count')))
+
+        # Play statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        game.add_child(Node.u32('play_count', statistics.get_int('total_plays', 0)))
+        game.add_child(Node.u32('today_count', today_count))
+        game.add_child(Node.u32('play_chain', statistics.get_int('consecutive_days', 0)))
+
+        # Also exists but we don't support:
+        # - day_count: Number of days where this user had at least one play.
+        # - max_play_chain: Max consecutive days in a row where the user had at last one play.
+        # - week_count: Number of weeks here this user had at least one play.
+        # - week_play_count: Number of plays in the last week (I think).
+        # - week_chain: Number of weeks in a row where the user had at least one play in that week.
+        # - max_week_chain: Maximum number of weeks in a row where the user had at least one play in that week.
+
+        # Player options and last touched song.
+        lastdict = profile.get_dict('last')
+        game.add_child(Node.s32('last_music_id', lastdict.get_int('music_id', -1)))
+        game.add_child(Node.u8('last_music_type', lastdict.get_int('music_type')))
+        game.add_child(Node.u8('sort_type', lastdict.get_int('sort_type')))
+        game.add_child(Node.u8('narrow_down', lastdict.get_int('narrow_down')))
+        game.add_child(Node.u8('headphone', lastdict.get_int('headphone')))
+        game.add_child(Node.u8('gauge_option', lastdict.get_int('gauge_option')))
+        game.add_child(Node.u8('ars_option', lastdict.get_int('ars_option')))
+        game.add_child(Node.u8('notes_option', lastdict.get_int('notes_option')))
+        game.add_child(Node.u8('early_late_disp', lastdict.get_int('early_late_disp')))
+        game.add_child(Node.u8('eff_c_left', lastdict.get_int('eff_c_left')))
+        game.add_child(Node.u8('eff_c_right', lastdict.get_int('eff_c_right', 1)))
+        game.add_child(Node.u32('lanespeed', lastdict.get_int('lanespeed')))
+        game.add_child(Node.s32('hispeed', lastdict.get_int('hispeed')))
+        game.add_child(Node.s32('draw_adjust', lastdict.get_int('draw_adjust')))
+
+        # Item unlocks
+        itemnode = Node.void('item')
+        game.add_child(itemnode)
+
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+
+            if game_config.get_bool('force_unlock_songs') and itemtype == self.GAME_CATALOG_TYPE_SONG:
+                # Don't echo unlocked songs, we will add all of them later
+                continue
+            if game_config.get_bool('force_unlock_cards') and itemtype == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                # Don't echo unlocked appeal cards, we will add all of them later
+                continue
+            if game_config.get_bool('force_unlock_crew') and itemtype == self.GAME_CATALOG_TYPE_CREW:
+                # Don't echo unlocked crew, we will add all of them later
+                continue
+
+            info = Node.void('info')
+            itemnode.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u32('id', item.id))
+            info.add_child(Node.u32('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for itemid in ids:
+                if ids[itemid] == 0:
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('id', itemid))
+                info.add_child(Node.u32('param', ids[itemid]))
+
+        if game_config.get_bool('force_unlock_cards'):
+            catalog = self.data.local.game.get_items(self.game, self.version)
+            for unlock in catalog:
+                if unlock.type != 'appealcard':
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_APPEAL_CARD))
+                info.add_child(Node.u32('id', unlock.id))
+                info.add_child(Node.u32('param', 1))
+
+        if game_config.get_bool('force_unlock_crew'):
+            for crewid in range(1, 999):
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_CREW))
+                info.add_child(Node.u32('id', crewid))
+                info.add_child(Node.u32('param', 1))
+
+        # Skill courses
+        skill = Node.void('skill')
+        game.add_child(skill)
+        skill_level = 0
+
+        for course in achievements:
+            if course.type != 'course':
+                continue
+
+            course_id = course.id % 100
+            season_id = int(course.id / 100)
+
+            if course.data.get_int('clear_type') >= 2:
+                # The user cleared this, lets take the highest level clear for this
+                courselist = [
+                    c for c in
+                    self.__get_skill_analyzer_courses() if
+                    c.get('course_id', c.get('skill_level', -1)) == course_id and
+                    c['season_id'] == season_id
+                ]
+                if len(courselist) > 0:
+                    skill_level = max(skill_level, courselist[0]['skill_level'])
+
+            course_node = Node.void('course')
+            skill.add_child(course_node)
+            course_node.add_child(Node.s16('ssnid', season_id))
+            course_node.add_child(Node.s16('crsid', course_id))
+            course_node.add_child(Node.s32('sc', course.data.get_int('score')))
+            course_node.add_child(Node.s16('ct', course.data.get_int('clear_type')))
+            course_node.add_child(Node.s16('gr', course.data.get_int('grade')))
+            course_node.add_child(Node.s16('ar', course.data.get_int('achievement_rate')))
+            course_node.add_child(Node.s16('cnt', 1))
+
+        # Calculated skill level
+        game.add_child(Node.s16('skill_level', skill_level))
+
+        # Game parameters
+        paramnode = Node.void('param')
+        game.add_child(paramnode)
+
+        for param in achievements:
+            if param.type[:6] != 'param_':
+                continue
+            paramtype = int(param.type[6:])
+
+            info = Node.void('info')
+            paramnode.add_child(info)
+            info.add_child(Node.s32('id', param.id))
+            info.add_child(Node.s32('type', paramtype))
+            info.add_child(Node.s32_array('param', param.data['param']))  # This looks to be variable, so no validation on length
+
+        # Infection nodes, we don't support these but it here for posterity.
+        pbc_infection = Node.void('pbc_infection')
+        game.add_child(pbc_infection)
+        for name in ['packet', 'block', 'coloris']:
+            child = Node.void(name)
+            pbc_infection.add_child(child)
+            child.add_child(Node.s32('before', 0))
+            child.add_child(Node.s32('after', 0))
+
+        pb_infection = Node.void('pb_infection')
+        game.add_child(pb_infection)
+        for name in ['packet', 'block']:
+            child = Node.void(name)
+            pb_infection.add_child(child)
+            child.add_child(Node.s32('before', 0))
+            child.add_child(Node.s32('after', 0))
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update blaster energy and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        earned_blaster_energy = request.child_value('earned_blaster_energy')
+        if earned_blaster_energy is not None:
+            newprofile.replace_int('blaster_energy', newprofile.get_int('blaster_energy') + earned_blaster_energy)
+
+        # Miscelaneous profile stuff
+        newprofile.replace_int('blaster_count', request.child_value('blaster_count'))
+        newprofile.replace_int('appealid', request.child_value('appeal_id'))
+        newprofile.replace_int('skill_level', request.child_value('skill_level'))
+        newprofile.replace_int('skill_base_id', request.child_value('skill_base_id'))
+        newprofile.replace_int('skill_name_id', request.child_value('skill_name_id'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+
+        if request.child('item') is not None:
+            for child in request.child('item').children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+
+                if game_config.get_bool('force_unlock_cards') and item_type == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                    # Don't save back appeal cards because they were force unlocked
+                    continue
+                if game_config.get_bool('force_unlock_songs') and item_type == self.GAME_CATALOG_TYPE_SONG:
+                    # Don't save back songs, because they were force unlocked
+                    continue
+                if game_config.get_bool('force_unlock_crew') and item_type == self.GAME_CATALOG_TYPE_CREW:
+                    # Don't save back crew, because they were force unlocked
+                    continue
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    f'item_{item_type}',
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Update params
+        if request.child('param') is not None:
+            for child in request.child('param').children:
+                if child.name != 'info':
+                    continue
+
+                param_id = child.child_value('id')
+                param_type = child.child_value('type')
+                param_param = child.child_value('param')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    param_id,
+                    f'param_{param_type}',
+                    {
+                        'param': param_param,
+                    },
+                )
+
+        # Grab last information and player options.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('music_id', request.child_value('music_id'))
+        lastdict.replace_int('music_type', request.child_value('music_type'))
+        lastdict.replace_int('sort_type', request.child_value('sort_type'))
+        lastdict.replace_int('narrow_down', request.child_value('narrow_down'))
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('gauge_option', request.child_value('gauge_option'))
+        lastdict.replace_int('ars_option', request.child_value('ars_option'))
+        lastdict.replace_int('notes_option', request.child_value('notes_option'))
+        lastdict.replace_int('early_late_disp', request.child_value('early_late_disp'))
+        lastdict.replace_int('eff_c_left', request.child_value('eff_c_left'))
+        lastdict.replace_int('eff_c_right', request.child_value('eff_c_right'))
+        lastdict.replace_int('lanespeed', request.child_value('lanespeed'))
+        lastdict.replace_int('hispeed', request.child_value('hispeed'))
+        lastdict.replace_int('draw_adjust', request.child_value('draw_adjust'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/backend/sdvx/infiniteinfection.py b/bemani/backend/sdvx/infiniteinfection.py
new file mode 100644
index 0000000..19e5db1
--- /dev/null
+++ b/bemani/backend/sdvx/infiniteinfection.py
@@ -0,0 +1,2503 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, List, Optional
+
+from bemani.backend.ess import EventLogHandler
+from bemani.backend.sdvx.base import SoundVoltexBase
+from bemani.backend.sdvx.booth import SoundVoltexBooth
+from bemani.common import Time, ValidatedDict, VersionConstants, ID
+from bemani.data import UserID
+from bemani.protocol import Node
+
+
+class SoundVoltexInfiniteInfection(
+    EventLogHandler,
+    SoundVoltexBase,
+):
+
+    name = 'SOUND VOLTEX II -infinite infection-'
+    version = VersionConstants.SDVX_INFINITE_INFECTION
+
+    GAME_LIMITED_LOCKED = 1
+    GAME_LIMITED_UNLOCKABLE = 2
+    GAME_LIMITED_UNLOCKED = 3
+
+    GAME_CURRENCY_PACKETS = 0
+    GAME_CURRENCY_BLOCKS = 1
+
+    GAME_CLEAR_TYPE_NO_CLEAR = 1
+    GAME_CLEAR_TYPE_CLEAR = 2
+    GAME_CLEAR_TYPE_HARD_CLEAR = 5
+    GAME_CLEAR_TYPE_ULTIMATE_CHAIN = 3
+    GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN = 4
+
+    GAME_GRADE_NO_PLAY = 0
+    GAME_GRADE_D = 1
+    GAME_GRADE_C = 2
+    GAME_GRADE_B = 3
+    GAME_GRADE_A = 4
+    GAME_GRADE_AA = 5
+    GAME_GRADE_AAA = 6
+
+    GAME_CATALOG_TYPE_SONG = 0
+    GAME_CATALOG_TYPE_APPEAL_CARD = 1
+    GAME_CATALOG_TYPE_SPECIAL_SONG = 2
+
+    GAME_GAUGE_TYPE_SKILL = 1
+
+    @classmethod
+    def get_settings(cls) -> Dict[str, Any]:
+        """
+        Return all of our front-end modifiably settings.
+        """
+        return {
+            'bools': [
+                {
+                    'name': 'Disable Online Matching',
+                    'tip': 'Disable online matching between games.',
+                    'category': 'game_config',
+                    'setting': 'disable_matching',
+                },
+                {
+                    'name': 'Force Song Unlock',
+                    'tip': 'Force unlock all songs.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_songs',
+                },
+                {
+                    'name': 'Force Appeal Card Unlock',
+                    'tip': 'Force unlock all appeal cards.',
+                    'category': 'game_config',
+                    'setting': 'force_unlock_cards',
+                },
+            ],
+            'ints': [
+                {
+                    'name': 'BEMANI Stadium Event Phase',
+                    'tip': 'BEMANI Stadium event phase for all players.',
+                    'category': 'game_config',
+                    'setting': 'bemani_stadium',
+                    'values': {
+                        0: 'No Event',
+                        1: 'BEMANI Stadium',
+                        2: 'BEMANI iseki',
+                    }
+                },
+            ],
+        }
+
+    def previous_version(self) -> Optional[SoundVoltexBase]:
+        return SoundVoltexBooth(self.data, self.config, self.model)
+
+    def __game_to_db_clear_type(self, clear_type: int) -> int:
+        return {
+            self.GAME_CLEAR_TYPE_NO_CLEAR: self.CLEAR_TYPE_FAILED,
+            self.GAME_CLEAR_TYPE_CLEAR: self.CLEAR_TYPE_CLEAR,
+            self.GAME_CLEAR_TYPE_HARD_CLEAR: self.CLEAR_TYPE_HARD_CLEAR,
+            self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN: self.CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __db_to_game_clear_type(self, clear_type: int) -> int:
+        return {
+            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_CLEAR,
+            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_NO_CLEAR,
+            self.CLEAR_TYPE_CLEAR: self.GAME_CLEAR_TYPE_CLEAR,
+            self.CLEAR_TYPE_HARD_CLEAR: self.GAME_CLEAR_TYPE_HARD_CLEAR,
+            self.CLEAR_TYPE_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_ULTIMATE_CHAIN,
+            self.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: self.GAME_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }[clear_type]
+
+    def __game_to_db_grade(self, grade: int) -> int:
+        return {
+            self.GAME_GRADE_NO_PLAY: self.GRADE_NO_PLAY,
+            self.GAME_GRADE_D: self.GRADE_D,
+            self.GAME_GRADE_C: self.GRADE_C,
+            self.GAME_GRADE_B: self.GRADE_B,
+            self.GAME_GRADE_A: self.GRADE_A,
+            self.GAME_GRADE_AA: self.GRADE_AA,
+            self.GAME_GRADE_AAA: self.GRADE_AAA,
+        }[grade]
+
+    def __db_to_game_grade(self, grade: int) -> int:
+        return {
+            self.GRADE_NO_PLAY: self.GAME_GRADE_NO_PLAY,
+            self.GRADE_D: self.GAME_GRADE_D,
+            self.GRADE_C: self.GAME_GRADE_C,
+            self.GRADE_B: self.GAME_GRADE_B,
+            self.GRADE_A: self.GAME_GRADE_A,
+            self.GRADE_A_PLUS: self.GAME_GRADE_A,
+            self.GRADE_AA: self.GAME_GRADE_AA,
+            self.GRADE_AA_PLUS: self.GAME_GRADE_AA,
+            self.GRADE_AAA: self.GAME_GRADE_AAA,
+            self.GRADE_AAA_PLUS: self.GAME_GRADE_AAA,
+            self.GRADE_S: self.GAME_GRADE_AAA,
+        }[grade]
+
+    def __get_skill_analyzer_seasons(self) -> Dict[int, str]:
+        return {
+            6: 'SKILL ANALYZER 第6回 (2013/12/06)',
+            7: 'SKILL ANALYZER 第7回 (2014/01/10)',
+            8: 'SKILL ANALYZER 第8回 (2014/02/06)',
+            9: 'SKILL ANALYZER 第9回 (2014/03/06)',
+            10: 'SKILL ANALYZER 第10回 (2014/04/04)',
+            11: 'SKILL ANALYZER 第11回 (2014/05/01)',
+            12: 'SKILL ANALYZER 第12回 (2014/06/05)',
+            13: 'SKILL ANALYZER 第13回 (2014/07/04)',
+            14: 'SKILL ANALYZER 第14回 (2014/08/01)',
+        }
+
+    def __get_skill_analyzer_skill_levels(self) -> Dict[int, str]:
+        return {
+            0: 'Skill LEVEL 01 岳翔',
+            1: 'Skill LEVEL 02 流星',
+            2: 'Skill LEVEL 03 月衝',
+            3: 'Skill LEVEL 04 瞬光',
+            4: 'Skill LEVEL 05 天極',
+            5: 'Skill LEVEL 06 烈風',
+            6: 'Skill LEVEL 07 雷電',
+            7: 'Skill LEVEL 08 麗華',
+            8: 'Skill LEVEL 09 魔騎士',
+            9: 'Skill LEVEL 10 剛力羅',
+            10: 'Skill LEVEL 11 或帝滅斗',
+            11: 'Skill LEVEL ∞(12) 暴龍天',
+        }
+
+    def __get_skill_analyzer_courses(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                'level': 0,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 109,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 24,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 245,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 313,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 4,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 39,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 134,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 314,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 59,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 86,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 128,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 2,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 256,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 255,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 96,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 139,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 216,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 244,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 250,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 180,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 6,
+                'tracks': [
+                    {
+                        'id': 7,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 214,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 54,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 221,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 51,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 6,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 111,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 56,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 10,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 134,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 75,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 369,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 224,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 323,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 128,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 85,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 344,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 241,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 251,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 139,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 341,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 346,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 302,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 7,
+                'tracks': [
+                    {
+                        'id': 19,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 329,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 289,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 54,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 221,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 51,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 6,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 111,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 56,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 333,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 10,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 134,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 75,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 369,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 224,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 323,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 128,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 85,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 344,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 241,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 251,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 139,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 341,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 346,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 302,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 8,
+                'tracks': [
+                    {
+                        'id': 19,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 329,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 289,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 60,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 328,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 278,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 313,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 41,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 80,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 295,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 45,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 44,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 326,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 340,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 115,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 288,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 57,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 267,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 246,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 304,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 373,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 122,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 359,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 247,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 9,
+                'tracks': [
+                    {
+                        'id': 221,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 229,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 363,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 365,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 328,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 51,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 111,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 41,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 15,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 10,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 259,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 23,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 66,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 62,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 85,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 288,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 78,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 311,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 71,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 87,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 341,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 173,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 228,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 166,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 10,
+                'tracks': [
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 229,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 384,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 54,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 365,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 374,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 22,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 56,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 39,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 10,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 369,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 222,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 103,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 158,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 74,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 262,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 128,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 79,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 71,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 192,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 253,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 341,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 58,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 269,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 11,
+                'tracks': [
+                    {
+                        'id': 116,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 289,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 376,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 189,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 245,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 278,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 340,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 183,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 426,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 349,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 342,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 190,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 222,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 158,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 352,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 212,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 275,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 198,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 331,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 184,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 345,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 218,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 268,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 373,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 244,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 414,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 269,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 12,
+                'tracks': [
+                    {
+                        'id': 408,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 376,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 189,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 219,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 278,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 340,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 313,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 90,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 223,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 322,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 299,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 407,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 77,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 36,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 92,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 337,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 8,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 375,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 426,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 401,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 345,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 290,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 432,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 72,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 373,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 125,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 302,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 252,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 13,
+                'tracks': [
+                    {
+                        'id': 247,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 437,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 342,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 0,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 228,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 374,
+                        'type': self.CHART_TYPE_NOVICE,
+                    },
+                    {
+                        'id': 24,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 1,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 76,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 8,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 309,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 2,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 412,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 155,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 99,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                ],
+            },
+            {
+                'level': 3,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 269,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 24,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 171,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 4,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_ADVANCED,
+                    },
+                    {
+                        'id': 92,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 34,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 5,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 42,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 275,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 480,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                ],
+            },
+            {
+                'level': 6,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 170,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 264,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 307,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 7,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 253,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 72,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 430,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 8,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 63,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 343,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 220,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 9,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 413,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 437,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 362,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 10,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 258,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 374,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 360,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+            {
+                'level': 11,
+                'season_id': 14,
+                'tracks': [
+                    {
+                        'id': 366,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                    {
+                        'id': 126,
+                        'type': self.CHART_TYPE_INFINITE,
+                    },
+                    {
+                        'id': 367,
+                        'type': self.CHART_TYPE_EXHAUST,
+                    },
+                ],
+            },
+        ]
+
+    def handle_game_2_exception_request(self, request: Node) -> Node:
+        return Node.void('game_2')
+
+    def handle_game_2_play_e_request(self, request: Node) -> Node:
+        return Node.void('game_2')
+
+    def handle_game_2_save_e_request(self, request: Node) -> Node:
+        # This has to do with Policy Break against ReflecBeat and
+        # floor infection, but we don't implement multi-game support so meh.
+        return Node.void('game_2')
+
+    def handle_game_2_lounge_request(self, request: Node) -> Node:
+        game = Node.void('game_2')
+        # Refresh interval in seconds.
+        game.add_child(Node.u32('interval', 10))
+        return game
+
+    def handle_game_2_entry_s_request(self, request: Node) -> Node:
+        game = Node.void('game_2')
+        # This should be created on the fly for a lobby that we're in.
+        game.add_child(Node.u32('entry_id', 1))
+        return game
+
+    def handle_game_2_entry_e_request(self, request: Node) -> Node:
+        # Lobby destroy method, eid node (u32) should be used
+        # to destroy any open lobbies.
+        return Node.void('game_2')
+
+    def handle_game_2_shop_request(self, request: Node) -> Node:
+        self.update_machine_name(request.child_value('shopname'))
+
+        # Respond with number of milliseconds until next request
+        game = Node.void('game_2')
+        game.add_child(Node.u32('nxt_time', 1000 * 5 * 60))
+        return game
+
+    def handle_game_2_common_request(self, request: Node) -> Node:
+        game = Node.void('game_2')
+        limited = Node.void('music_limited')
+        game.add_child(limited)
+
+        # Song unlock config
+        game_config = self.get_game_config()
+        if game_config.get_bool('force_unlock_songs'):
+            ids = set()
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.data.get_int('limited') in (self.GAME_LIMITED_LOCKED, self.GAME_LIMITED_UNLOCKABLE):
+                    ids.add((song.id, song.chart))
+
+            for (songid, chart) in ids:
+                info = Node.void('info')
+                limited.add_child(info)
+                info.add_child(Node.s32('music_id', songid))
+                info.add_child(Node.u8('music_type', chart))
+                info.add_child(Node.u8('limited', self.GAME_LIMITED_UNLOCKED))
+
+        # Event config
+        event = Node.void('event')
+        game.add_child(event)
+
+        def enable_event(eid: int) -> None:
+            evt = Node.void('info')
+            event.add_child(evt)
+            evt.add_child(Node.u32('event_id', eid))
+
+        if not game_config.get_bool('disable_matching'):
+            enable_event(1)  # Matching enabled
+        enable_event(2)  # BEMANI Academy
+        enable_event(3)  # Floor Infection
+        enable_event(6)  # Skill Analyzer
+        enable_event(9)  # Policy Break
+        enable_event(14)  # Enable pages on Skill Analyzer
+
+        stadium = game_config.get_int('bemani_stadium')
+        if stadium == 1:
+            enable_event(18)  # BEMANI Stadium (mutually exclusive with BEMANI iseki)
+        if stadium == 2:
+            enable_event(51)  # BEMANI iseki (mutually exclusive with BEMANI Stadium)
+
+        # In-game purchases catalog config (this isn't necessary for SDVX 2 to work).
+        catalog = Node.void('catalog')
+        game.add_child(catalog)
+        songunlocks = self.data.local.game.get_items(self.game, self.version)
+        for unlock in songunlocks:
+            if unlock.type == 'song_unlock':
+                info = Node.void('info')
+                catalog.add_child(info)
+                info.add_child(Node.u8('catalog_type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('catalog_id', unlock.id))
+                info.add_child(Node.u32('currency_type', self.GAME_CURRENCY_BLOCKS))
+                info.add_child(Node.u32('price', unlock.data.get_int('blocks')))
+            elif unlock.type == 'special_unlock':
+                info = Node.void('info')
+                catalog.add_child(info)
+                info.add_child(Node.u8('catalog_type', self.GAME_CATALOG_TYPE_SPECIAL_SONG))
+                info.add_child(Node.u32('catalog_id', unlock.id))
+                info.add_child(Node.u32('currency_type', self.GAME_CURRENCY_BLOCKS))
+                info.add_child(Node.u32('price', unlock.data.get_int('blocks')))
+
+        # Skill Analyzer config
+        skill_course = Node.void('skill_course')
+        game.add_child(skill_course)
+
+        seasons = self.__get_skill_analyzer_seasons()
+        skillnames = self.__get_skill_analyzer_skill_levels()
+        last_season = max(seasons.keys())
+        for course in self.__get_skill_analyzer_courses():
+            info = Node.void('info')
+            skill_course.add_child(info)
+            info.add_child(Node.s16('course_id', course['level']))
+            info.add_child(Node.s16('level', course['level']))
+            info.add_child(Node.s32('season_id', course['season_id']))
+            info.add_child(Node.string('season_name', seasons[course['season_id']]))
+            info.add_child(Node.bool('season_new_flg', course['season_id'] == last_season))
+            info.add_child(Node.string('course_name', skillnames[course['level']]))
+            info.add_child(Node.s16('course_type', 0))
+            info.add_child(Node.s16('skill_name_id', course['level']))
+            info.add_child(Node.bool('matching_assist', course['level'] <= 6))
+            info.add_child(Node.s16('gauge_type', self.GAME_GAUGE_TYPE_SKILL))
+            info.add_child(Node.s16('paseli_type', 0))
+
+            trackno = 0
+            for trackdata in course['tracks']:
+                track = Node.void('track')
+                info.add_child(track)
+                track.add_child(Node.s16('track_no', trackno))
+                track.add_child(Node.s32('music_id', trackdata['id']))
+                track.add_child(Node.s8('music_type', trackdata['type']))
+                trackno = trackno + 1
+
+        return game
+
+    def handle_game_2_hiscore_request(self, request: Node) -> Node:
+        # Grab location for local scores
+        locid = ID.parse_machine_id(request.child_value('locid'))
+
+        # Start the response packet
+        game = Node.void('game_2')
+
+        # First, grab hit chart
+        playcounts = self.data.local.music.get_hit_chart(self.game, self.version, 1024)
+
+        hitchart = Node.void('hitchart')
+        game.add_child(hitchart)
+        for (songid, count) in playcounts:
+            info = Node.void('info')
+            hitchart.add_child(info)
+            info.add_child(Node.u32('id', songid))
+            info.add_child(Node.u32('cnt', count))
+
+        # Now, grab user records
+        records = self.data.remote.music.get_all_records(self.game, self.version)
+        missing_users = [userid for (userid, _) in records]
+        users = {userid: profile for (userid, profile) in self.get_any_profiles(missing_users)}
+
+        hiscore_allover = Node.void('hiscore_allover')
+        game.add_child(hiscore_allover)
+
+        # Output records
+        for (userid, score) in records:
+            info = Node.void('info')
+
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            profile = users[userid]
+
+            info.add_child(Node.u32('id', score.id))
+            info.add_child(Node.u32('type', score.chart))
+            info.add_child(Node.string('name', profile.get_str('name')))
+            info.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+            info.add_child(Node.u32('score', score.points))
+
+            # Add to global scores
+            hiscore_allover.add_child(info)
+
+        # Now, grab local records
+        area_users = [
+            uid for (uid, prof) in self.data.local.user.get_all_profiles(self.game, self.version)
+            if prof.get_int('loc', -1) == locid
+        ]
+        records = self.data.local.music.get_all_records(self.game, self.version, userlist=area_users)
+        missing_users = [userid for (userid, _) in records if userid not in users]
+        for (userid, profile) in self.get_any_profiles(missing_users):
+            users[userid] = profile
+
+        hiscore_location = Node.void('hiscore_location')
+        game.add_child(hiscore_location)
+
+        # Output records
+        for (userid, score) in records:
+            info = Node.void('info')
+
+            if userid not in users:
+                raise Exception('Logic error, missing profile for user!')
+            profile = users[userid]
+
+            info.add_child(Node.u32('id', score.id))
+            info.add_child(Node.u32('type', score.chart))
+            info.add_child(Node.string('name', profile.get_str('name')))
+            info.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+            info.add_child(Node.u32('score', score.points))
+
+            # Add to local scores
+            hiscore_location.add_child(info)
+
+        # Now, grab clear rates
+        clear_rate = Node.void('clear_rate')
+        game.add_child(clear_rate)
+
+        clears = self.get_clear_rates()
+        for songid in clears:
+            for chart in clears[songid]:
+                if clears[songid][chart]['total'] > 0:
+                    rate = float(clears[songid][chart]['clears']) / float(clears[songid][chart]['total'])
+                    dnode = Node.void('d')
+                    clear_rate.add_child(dnode)
+                    dnode.add_child(Node.u32('id', songid))
+                    dnode.add_child(Node.u32('type', chart))
+                    dnode.add_child(Node.s16('cr', int(rate * 10000)))
+
+        return game
+
+    def handle_game_2_new_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        name = request.child_value('name')
+        loc = ID.parse_machine_id(request.child_value('locid'))
+        self.new_profile_by_refid(refid, name, loc)
+
+        root = Node.void('game_2')
+        return root
+
+    def handle_game_2_frozen_request(self, request: Node) -> Node:
+        game = Node.void('game_2')
+        game.add_child(Node.u8('result', 0))
+        return game
+
+    def handle_game_2_load_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+        root = self.get_profile_by_refid(refid)
+        if root is not None:
+            return root
+
+        # Figure out if this user has an older profile or not
+        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+
+        if userid is not None:
+            previous_game = self.previous_version()
+        else:
+            previous_game = None
+
+        if previous_game is not None:
+            profile = previous_game.get_profile(userid)
+        else:
+            profile = None
+
+        if profile is not None:
+            root = Node.void('game_2')
+            root.add_child(Node.u8('result', 2))
+            root.add_child(Node.string('name', profile.get_str('name')))
+            return root
+        else:
+            root = Node.void('game_2')
+            root.add_child(Node.u8('result', 1))
+            return root
+
+    def handle_game_2_save_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            oldprofile = self.get_profile(userid)
+            newprofile = self.unformat_profile(userid, request, oldprofile)
+        else:
+            newprofile = None
+
+        if userid is not None and newprofile is not None:
+            self.put_profile(userid, newprofile)
+
+        return Node.void('game_2')
+
+    def handle_game_2_load_m_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            scores = self.data.remote.music.get_scores(self.game, self.version, userid)
+        else:
+            scores = []
+
+        # Output to the game
+        game = Node.void('game_2')
+        new = Node.void('new')
+        game.add_child(new)
+
+        for score in scores:
+            music = Node.void('music')
+            new.add_child(music)
+            music.add_child(Node.u32('music_id', score.id))
+            music.add_child(Node.u32('music_type', score.chart))
+            music.add_child(Node.u32('score', score.points))
+            music.add_child(Node.u32('cnt', score.plays))
+            music.add_child(Node.u32('clear_type', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
+            music.add_child(Node.u32('score_grade', self.__db_to_game_grade(score.data.get_int('grade'))))
+            stats = score.data.get_dict('stats')
+            music.add_child(Node.u32('btn_rate', stats.get_int('btn_rate')))
+            music.add_child(Node.u32('long_rate', stats.get_int('long_rate')))
+            music.add_child(Node.u32('vol_rate', stats.get_int('vol_rate')))
+
+        return game
+
+    def handle_game_2_save_m_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        # Doesn't matter if userid is None here, that's an anonymous score
+        musicid = request.child_value('music_id')
+        chart = request.child_value('music_type')
+        points = request.child_value('score')
+        combo = request.child_value('max_chain')
+        clear_type = self.__game_to_db_clear_type(request.child_value('clear_type'))
+        grade = self.__game_to_db_grade(request.child_value('score_grade'))
+        stats = {
+            'btn_rate': request.child_value('btn_rate'),
+            'long_rate': request.child_value('long_rate'),
+            'vol_rate': request.child_value('vol_rate'),
+            'critical': request.child_value('critical'),
+            'near': request.child_value('near'),
+            'error': request.child_value('error'),
+        }
+
+        # Save the score
+        self.update_score(
+            userid,
+            musicid,
+            chart,
+            points,
+            clear_type,
+            grade,
+            combo,
+            stats,
+        )
+
+        # Return a blank response
+        return Node.void('game_2')
+
+    def handle_game_2_save_c_request(self, request: Node) -> Node:
+        refid = request.child_value('dataid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            course_id = request.child_value('crsid')
+            clear_type = request.child_value('ct')
+            achievement_rate = request.child_value('ar')
+            season_id = request.child_value('ssnid')
+
+            self.data.local.user.put_achievement(
+                self.game,
+                self.version,
+                userid,
+                (season_id * 100) + course_id,
+                'course',
+                {
+                    'clear_type': clear_type,
+                    'achievement_rate': achievement_rate,
+                },
+            )
+
+        # Return a blank response
+        return Node.void('game_2')
+
+    def handle_game_2_buy_request(self, request: Node) -> Node:
+        refid = request.child_value('refid')
+
+        if refid is not None:
+            userid = self.data.remote.user.from_refid(self.game, self.version, refid)
+        else:
+            userid = None
+
+        if userid is not None:
+            profile = self.get_profile(userid)
+        else:
+            profile = None
+
+        if userid is not None and profile is not None:
+            # Look up packets and blocks
+            packet = profile.get_int('packet')
+            block = profile.get_int('block')
+
+            # Add on any additional we earned this round
+            packet = packet + (request.child_value('earned_gamecoin_packet') or 0)
+            block = block + (request.child_value('earned_gamecoin_block') or 0)
+
+            currency_type = request.child_value('currency_type')
+            price = request.child_value('price')
+
+            if currency_type == self.GAME_CURRENCY_PACKETS:
+                # This is a valid purchase
+                newpacket = packet - price
+                if newpacket < 0:
+                    result = 1
+                else:
+                    packet = newpacket
+                    result = 0
+            elif currency_type == self.GAME_CURRENCY_BLOCKS:
+                # This is a valid purchase
+                newblock = block - price
+                if newblock < 0:
+                    result = 1
+                else:
+                    block = newblock
+                    result = 0
+            else:
+                # Bad currency type
+                result = 1
+
+            if result == 0:
+                # Transaction is valid, update the profile with new packets and blocks
+                profile.replace_int('packet', packet)
+                profile.replace_int('block', block)
+                self.put_profile(userid, profile)
+
+                # If this was a song unlock, we should mark it as unlocked
+                item_type = request.child_value('item_type')
+                item_id = request.child_value('item_id')
+                param = request.child_value('param')
+
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        else:
+            # Unclear what to do here, return a bad response
+            packet = 0
+            block = 0
+            result = 1
+
+        game = Node.void('game_2')
+        game.add_child(Node.u32('gamecoin_packet', packet))
+        game.add_child(Node.u32('gamecoin_block', block))
+        game.add_child(Node.s8('result', result))
+        return game
+
+    def format_profile(self, userid: UserID, profile: ValidatedDict) -> Node:
+        game = Node.void('game_2')
+
+        # Generic profile stuff
+        game.add_child(Node.string('name', profile.get_str('name')))
+        game.add_child(Node.string('code', ID.format_extid(profile.get_int('extid'))))
+        game.add_child(Node.u32('gamecoin_packet', profile.get_int('packet')))
+        game.add_child(Node.u32('gamecoin_block', profile.get_int('block')))
+        game.add_child(Node.s16('skill_name_id', profile.get_int('skill_name_id', -1)))
+        game.add_child(Node.s32_array('hidden_param', profile.get_int_array('hidden_param', 20)))
+        game.add_child(Node.u32('blaster_energy', profile.get_int('blaster_energy')))
+        game.add_child(Node.u32('blaster_count', profile.get_int('blaster_count')))
+
+        # Play statistics
+        statistics = self.get_play_statistics(userid)
+        last_play_date = statistics.get_int_array('last_play_date', 3)
+        today_play_date = Time.todays_date()
+        if (
+            last_play_date[0] == today_play_date[0] and
+            last_play_date[1] == today_play_date[1] and
+            last_play_date[2] == today_play_date[2]
+        ):
+            today_count = statistics.get_int('today_plays', 0)
+        else:
+            today_count = 0
+        game.add_child(Node.u32('play_count', statistics.get_int('total_plays', 0)))
+        game.add_child(Node.u32('daily_count', today_count))
+        game.add_child(Node.u32('play_chain', statistics.get_int('consecutive_days', 0)))
+
+        # Last played stuff
+        if 'last' in profile:
+            lastdict = profile.get_dict('last')
+            last = Node.void('last')
+            game.add_child(last)
+            last.add_child(Node.s32('music_id', lastdict.get_int('music_id', -1)))
+            last.add_child(Node.u8('music_type', lastdict.get_int('music_type')))
+            last.add_child(Node.u8('sort_type', lastdict.get_int('sort_type')))
+            last.add_child(Node.u8('narrow_down', lastdict.get_int('narrow_down')))
+            last.add_child(Node.u8('headphone', lastdict.get_int('headphone')))
+            last.add_child(Node.u8('hispeed', lastdict.get_int('hispeed', 8)))
+            last.add_child(Node.u16('appeal_id', lastdict.get_int('appeal_id', 1001)))
+            last.add_child(Node.u16('comment_id', lastdict.get_int('comment_id')))
+            last.add_child(Node.u8('gauge_option', lastdict.get_int('gauge_option')))
+
+        # Item unlocks
+        itemnode = Node.void('item')
+        game.add_child(itemnode)
+
+        game_config = self.get_game_config()
+        achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
+
+        for item in achievements:
+            if item.type[:5] != 'item_':
+                continue
+            itemtype = int(item.type[5:])
+
+            if itemtype == self.GAME_CATALOG_TYPE_APPEAL_CARD:
+                # Type 1 is appeal cards, and the game saves this for non-default cards but
+                # we take care of this below.
+                continue
+            if itemtype == self.GAME_CATALOG_TYPE_SONG and game_config.get_bool('force_unlock_songs'):
+                # We will echo this below in the force unlock song section
+                continue
+
+            info = Node.void('info')
+            itemnode.add_child(info)
+            info.add_child(Node.u8('type', itemtype))
+            info.add_child(Node.u32('id', item.id))
+            info.add_child(Node.u32('param', item.data.get_int('param')))
+
+        if game_config.get_bool('force_unlock_songs'):
+            ids: Dict[int, int] = {}
+            songs = self.data.local.music.get_all_songs(self.game, self.version)
+            for song in songs:
+                if song.id not in ids:
+                    ids[song.id] = 0
+
+                if song.data.get_int('difficulty') > 0:
+                    ids[song.id] = ids[song.id] | (1 << song.chart)
+
+            for itemid in ids:
+                if ids[itemid] == 0:
+                    continue
+
+                info = Node.void('info')
+                itemnode.add_child(info)
+                info.add_child(Node.u8('type', self.GAME_CATALOG_TYPE_SONG))
+                info.add_child(Node.u32('id', itemid))
+                info.add_child(Node.u32('param', ids[itemid]))
+
+        # Appeal card unlocks
+        appealcard = Node.void('appealcard')
+        game.add_child(appealcard)
+
+        if not game_config.get_bool('force_unlock_cards'):
+            for card in achievements:
+                if card.type != 'appealcard':
+                    continue
+
+                info = Node.void('info')
+                appealcard.add_child(info)
+                info.add_child(Node.u32('id', card.id))
+                info.add_child(Node.u32('count', card.data.get_int('count')))
+        else:
+            catalog = self.data.local.game.get_items(self.game, self.version)
+            for unlock in catalog:
+                if unlock.type != 'appealcard':
+                    continue
+                info = Node.void('info')
+                appealcard.add_child(info)
+                info.add_child(Node.u32('id', unlock.id))
+                info.add_child(Node.u32('count', 0))
+
+        # Skill courses
+        skill = Node.void('skill')
+        game.add_child(skill)
+        course_all = Node.void('course_all')
+        skill.add_child(course_all)
+
+        for course in achievements:
+            if course.type != 'course':
+                continue
+
+            course_id = course.id % 100
+            season_id = int(course.id / 100)
+
+            info = Node.void('d')
+            course_all.add_child(info)
+            info.add_child(Node.s16('crsid', course_id))
+            info.add_child(Node.s16('ct', course.data.get_int('clear_type')))
+            info.add_child(Node.s16('ar', course.data.get_int('achievement_rate')))
+            info.add_child(Node.s32('ssnid', season_id))
+
+        return game
+
+    def unformat_profile(self, userid: UserID, request: Node, oldprofile: ValidatedDict) -> ValidatedDict:
+        newprofile = copy.deepcopy(oldprofile)
+
+        # Update blaster energy and in-game currencies
+        earned_gamecoin_packet = request.child_value('earned_gamecoin_packet')
+        if earned_gamecoin_packet is not None:
+            newprofile.replace_int('packet', newprofile.get_int('packet') + earned_gamecoin_packet)
+        earned_gamecoin_block = request.child_value('earned_gamecoin_block')
+        if earned_gamecoin_block is not None:
+            newprofile.replace_int('block', newprofile.get_int('block') + earned_gamecoin_block)
+        earned_blaster_energy = request.child_value('earned_blaster_energy')
+        if earned_blaster_energy is not None:
+            newprofile.replace_int('blaster_energy', newprofile.get_int('blaster_energy') + earned_blaster_energy)
+
+        # Miscelaneous stuff
+        newprofile.replace_int('blaster_count', request.child_value('blaster_count'))
+        newprofile.replace_int('skill_name_id', request.child_value('skill_name_id'))
+        newprofile.replace_int_array('hidden_param', 20, request.child_value('hidden_param'))
+
+        # Update user's unlock status if we aren't force unlocked
+        game_config = self.get_game_config()
+        if not game_config.get_bool('force_unlock_cards'):
+            for child in request.child('appealcard').children:
+                if child.name != 'info':
+                    continue
+
+                appealid = child.child_value('id')
+                count = child.child_value('count')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    appealid,
+                    'appealcard',
+                    {
+                        'count': count,
+                    },
+                )
+
+        if not game_config.get_bool('force_unlock_songs'):
+            for child in request.child('item').children:
+                if child.name != 'info':
+                    continue
+
+                item_id = child.child_value('id')
+                item_type = child.child_value('type')
+                param = child.child_value('param')
+                self.data.local.user.put_achievement(
+                    self.game,
+                    self.version,
+                    userid,
+                    item_id,
+                    'item_{}'.format(item_type),
+                    {
+                        'param': param,
+                    },
+                )
+
+        # Grab last information.
+        lastdict = newprofile.get_dict('last')
+        lastdict.replace_int('headphone', request.child_value('headphone'))
+        lastdict.replace_int('hispeed', request.child_value('hispeed'))
+        lastdict.replace_int('appeal_id', request.child_value('appeal_id'))
+        lastdict.replace_int('comment_id', request.child_value('comment_id'))
+        lastdict.replace_int('music_id', request.child_value('music_id'))
+        lastdict.replace_int('music_type', request.child_value('music_type'))
+        lastdict.replace_int('sort_type', request.child_value('sort_type'))
+        lastdict.replace_int('narrow_down', request.child_value('narrow_down'))
+        lastdict.replace_int('gauge_option', request.child_value('gauge_option'))
+
+        # Save back last information gleaned from results
+        newprofile.replace_dict('last', lastdict)
+
+        # Keep track of play statistics
+        self.update_play_statistics(userid)
+
+        return newprofile
diff --git a/bemani/client/__init__.py b/bemani/client/__init__.py
new file mode 100644
index 0000000..a2fdba9
--- /dev/null
+++ b/bemani/client/__init__.py
@@ -0,0 +1,2 @@
+from bemani.client.base import BaseClient
+from bemani.client.protocol import ClientProtocol
diff --git a/bemani/client/base.py b/bemani/client/base.py
new file mode 100644
index 0000000..0994fc6
--- /dev/null
+++ b/bemani/client/base.py
@@ -0,0 +1,413 @@
+import time
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.client.common import random_hex_string
+from bemani.client.protocol import ClientProtocol
+from bemani.protocol import Node
+
+
+class BaseClient:
+    """
+    The base client that all client emulators subclass from. This includes
+    a lot of functionality to create cards, exchange packets, verify responses
+    and verify some basic packets that are always expected to work.
+    """
+
+    CARD_OK = 0
+    CARD_NEW = 112
+    CARD_BAD_PIN = 116
+    CARD_NOT_ALLOWED = 110
+
+    CORRECT_PASSWORD = '1234'
+    WRONG_PASSWORD = '4321'
+
+    def __init__(self, proto: ClientProtocol, pcbid: str, config: Dict[str, Any]) -> None:
+        self.__proto = proto
+        self.pcbid = pcbid
+        self.config = config
+
+    def random_card(self) -> str:
+        return "E004" + random_hex_string(12, caps=True)
+
+    def call_node(self) -> Node:
+        call = Node.void('call')
+        call.set_attribute('model', self.config['model'])
+        call.set_attribute('srcid', self.pcbid)
+        call.set_attribute('tag', random_hex_string(8))
+        return call
+
+    def exchange(self, path: str, tree: Node) -> Node:
+        module = tree.children[0].name
+        method = tree.children[0].attribute('method')
+
+        return self.__proto.exchange(
+            '{}?model={}&module={}&method={}'.format(
+                path,
+                self.config['model'],
+                module,
+                method,
+            ),
+            tree,
+        )
+
+    def __assert_path(self, root: Node, path: str) -> bool:
+        parts = path.split('/')
+        children = [root]
+        node: Optional[Node] = None
+
+        for part in parts:
+            if part[0] == '@':
+                # Verify attribute, should be last part in chain so
+                # assume its the first node
+                if node is None:
+                    return False
+                if part[1:] not in node.attributes:
+                    return False
+                else:
+                    return True
+            else:
+                # Verify node name, might be last in chain
+                found = False
+                for child in children:
+                    if child.name == part:
+                        # This is a valid node, set to children and keep going
+                        children = child.children
+                        node = child
+                        found = True
+                        break
+
+                if not found:
+                    # Didn't find a noce named this
+                    return False
+
+        # Traversed whole chain
+        return True
+
+    def assert_path(self, root: Node, path: str) -> None:
+        """
+        Given a root node and a path string such as a/b/node or a/b/@attr,
+        validate that the root node has decendents that match the path.
+        As a convenience, you can check an attribute on a node with @attr
+        format, where <attr> is the string name of the attribute.
+        """
+
+        if not self.__assert_path(root, path):
+            raise Exception('Path \'{}\' not found in root node:\n{}'.format(path, root))
+
+    def verify_services_get(self, expected_services: List[str]=[]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        services = Node.void('services')
+        call.add_child(services)
+        services.set_attribute('method', 'get')
+
+        if self.config['avs'] is not None:
+            # Some older games don't include this info
+            info = Node.void('info')
+            services.add_child(info)
+
+            info.add_child(Node.string('AVS2', self.config['avs']))
+
+        # Swap with server
+        resp = self.exchange('core/services', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/services")
+        items = resp.child('services').children
+
+        returned_services = []
+        for item in items:
+            # Make sure it is an item with a url component
+            self.assert_path(item, 'item/@url')
+
+            # Get list of services provided
+            returned_services.append(item.attribute('name'))
+
+        for service in expected_services:
+            if service not in returned_services:
+                raise Exception('Service \'{}\' expected but not returned'.format(service))
+
+    def verify_pcbtracker_alive(self, ecflag: int = 1) -> bool:
+        call = self.call_node()
+
+        # Construct node
+        pcbtracker = Node.void('pcbtracker')
+        call.add_child(pcbtracker)
+        pcbtracker.set_attribute('accountid', self.pcbid)
+        pcbtracker.set_attribute('ecflag', str(ecflag))
+        pcbtracker.set_attribute('hardid', '01000027584F6D3A')
+        pcbtracker.set_attribute('method', 'alive')
+        pcbtracker.set_attribute('softid', '00010203040506070809')
+
+        # Swap with server
+        resp = self.exchange('core/pcbtracker', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcbtracker/@ecenable")
+
+        # Print out setting
+        enable = int(resp.child('pcbtracker').attribute('ecenable'))
+        if enable != 0:
+            return True
+        return False
+
+    def verify_message_get(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        message = Node.void('message')
+        call.add_child(message)
+        message.set_attribute('method', 'get')
+
+        # Swap with server
+        resp = self.exchange('core/message', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/message/@status")
+
+    def verify_dlstatus_progress(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        dlstatus = Node.void('dlstatus')
+        call.add_child(dlstatus)
+        dlstatus.set_attribute('method', 'progress')
+        dlstatus.add_child(Node.s32('progress', 0))
+
+        # Swap with server
+        resp = self.exchange('core/dlstatus', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/dlstatus/@status")
+
+    def verify_package_list(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        package = Node.void('package')
+        call.add_child(package)
+        package.set_attribute('method', 'list')
+        package.set_attribute('pkgtype', 'all')
+
+        # Swap with server
+        resp = self.exchange('core/package', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/package")
+
+    def verify_facility_get(self, encoding: str='SHIFT_JIS') -> str:
+        call = self.call_node()
+
+        # Construct node
+        facility = Node.void('facility')
+        call.add_child(facility)
+        facility.set_attribute('encoding', encoding)
+        facility.set_attribute('method', 'get')
+
+        # Swap with server
+        resp = self.exchange('core/facility', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/facility/location/id")
+        self.assert_path(resp, "response/facility/line")
+        self.assert_path(resp, "response/facility/portfw")
+        self.assert_path(resp, "response/facility/public")
+        self.assert_path(resp, "response/facility/share")
+
+        return resp.child_value('facility/location/id')
+
+    def verify_pcbevent_put(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        pcbevent = Node.void('pcbevent')
+        call.add_child(pcbevent)
+        pcbevent.set_attribute('method', 'put')
+        pcbevent.add_child(Node.time('time', int(time.time())))
+        pcbevent.add_child(Node.u32('seq', 0))
+
+        item = Node.void('item')
+        pcbevent.add_child(item)
+        item.add_child(Node.string('name', 'boot'))
+        item.add_child(Node.s32('value', 1))
+        item.add_child(Node.time('time', int(time.time())))
+
+        # Swap with server
+        resp = self.exchange('core/pcbevent', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcbevent")
+
+    def verify_cardmng_inquire(self, card_id: str, msg_type: str, paseli_enabled: bool) -> Optional[str]:
+        call = self.call_node()
+
+        # Construct node
+        cardmng = Node.void('cardmng')
+        call.add_child(cardmng)
+        cardmng.set_attribute('cardid', card_id)
+        cardmng.set_attribute('cardtype', '1')
+        cardmng.set_attribute('method', 'inquire')
+        cardmng.set_attribute('update', '0')
+        if msg_type == 'new' and 'old_profile_model' in self.config:
+            cardmng.set_attribute('model', self.config['old_profile_model'])
+
+        # Swap with server
+        resp = self.exchange('core/cardmng', call)
+
+        if msg_type == 'unregistered':
+            # Verify that response is correct
+            self.assert_path(resp, "response/cardmng/@status")
+
+            # Verify that we weren't found
+            status = int(resp.child('cardmng').attribute('status'))
+            if status != self.CARD_NEW:
+                raise Exception('Card \'{}\' returned invalid status \'{}\''.format(card_id, status))
+
+            # Nothing to return
+            return None
+        elif msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/cardmng/@refid")
+            self.assert_path(resp, "response/cardmng/@binded")
+            self.assert_path(resp, "response/cardmng/@newflag")
+            self.assert_path(resp, "response/cardmng/@ecflag")
+
+            binded = int(resp.child('cardmng').attribute('binded'))
+            newflag = int(resp.child('cardmng').attribute('newflag'))
+            ecflag = int(resp.child('cardmng').attribute('ecflag'))
+
+            if binded != 0:
+                raise Exception('Card \'{}\' returned invalid binded value \'{}\''.format(card_id, binded))
+            if newflag != 1:
+                raise Exception('Card \'{}\' returned invalid newflag value \'{}\''.format(card_id, newflag))
+            if ecflag != (1 if paseli_enabled else 0):
+                raise Exception('Card \'{}\' returned invalid ecflag value \'{}\''.format(card_id, newflag))
+
+            # Return the refid
+            return resp.child('cardmng').attribute('refid')
+        elif msg_type == 'query':
+            # Verify that response is correct
+            self.assert_path(resp, "response/cardmng/@refid")
+            self.assert_path(resp, "response/cardmng/@binded")
+            self.assert_path(resp, "response/cardmng/@newflag")
+            self.assert_path(resp, "response/cardmng/@ecflag")
+
+            binded = int(resp.child('cardmng').attribute('binded'))
+            newflag = int(resp.child('cardmng').attribute('newflag'))
+            ecflag = int(resp.child('cardmng').attribute('ecflag'))
+
+            if binded != 1:
+                raise Exception('Card \'{}\' returned invalid binded value \'{}\''.format(card_id, binded))
+            if newflag != 1:
+                raise Exception('Card \'{}\' returned invalid newflag value \'{}\''.format(card_id, newflag))
+            if ecflag != (1 if paseli_enabled else 0):
+                raise Exception('Card \'{}\' returned invalid ecflag value \'{}\''.format(card_id, newflag))
+
+            # Return the refid
+            return resp.child('cardmng').attribute('refid')
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_cardmng_getrefid(self, card_id: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        cardmng = Node.void('cardmng')
+        call.add_child(cardmng)
+        cardmng.set_attribute('cardid', card_id)
+        cardmng.set_attribute('cardtype', '1')
+        cardmng.set_attribute('method', 'getrefid')
+        cardmng.set_attribute('newflag', '0')
+        cardmng.set_attribute('passwd', self.CORRECT_PASSWORD)
+
+        # Swap with server
+        resp = self.exchange('core/cardmng', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/cardmng/@refid")
+
+        return resp.child('cardmng').attribute('refid')
+
+    def verify_cardmng_authpass(self, ref_id: str, correct: bool) -> None:
+        call = self.call_node()
+
+        # Construct node
+        cardmng = Node.void('cardmng')
+        call.add_child(cardmng)
+        cardmng.set_attribute('method', 'authpass')
+        cardmng.set_attribute('pass', self.CORRECT_PASSWORD if correct else self.CORRECT_PASSWORD[::-1])
+        cardmng.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('core/cardmng', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/cardmng/@status")
+
+        status = int(resp.child('cardmng').attribute('status'))
+        if status != (self.CARD_OK if correct else self.CARD_BAD_PIN):
+            raise Exception('Ref ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+    def verify_eacoin_checkin(self, card_id: str) -> Tuple[str, int]:
+        call = self.call_node()
+
+        # Construct node
+        eacoin = Node.void('eacoin')
+        call.add_child(eacoin)
+        eacoin.set_attribute('method', 'checkin')
+        eacoin.add_child(Node.string('cardtype', '1'))
+        eacoin.add_child(Node.string('cardid', card_id))
+        eacoin.add_child(Node.string('passwd', self.CORRECT_PASSWORD))
+        eacoin.add_child(Node.string('ectype', '1'))
+
+        # Swap with server
+        resp = self.exchange('core/eacoin', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eacoin/sessid")
+        self.assert_path(resp, "response/eacoin/balance")
+
+        return (resp.child('eacoin').child_value('sessid'), resp.child('eacoin').child_value('balance'))
+
+    def verify_eacoin_consume(self, sessid: str, balance: int, amount: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eacoin = Node.void('eacoin')
+        call.add_child(eacoin)
+        eacoin.set_attribute('method', 'consume')
+        eacoin.add_child(Node.string('sessid', sessid))
+        eacoin.add_child(Node.s16('sequence', 0))
+        eacoin.add_child(Node.s32('payment', amount))
+        eacoin.add_child(Node.s32('service', 0))
+        eacoin.add_child(Node.string('itemtype', '0'))
+        eacoin.add_child(Node.string('detail', '/eacoin/start_pt1'))
+
+        # Swap with server
+        resp = self.exchange('core/eacoin', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eacoin/balance")
+
+        newbalance = resp.child('eacoin').child_value('balance')
+        if balance - amount != newbalance:
+            raise Exception("Expected to get back balance {} but got {}".format(balance - amount, newbalance))
+
+    def verify_eacoin_checkout(self, session: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eacoin = Node.void('eacoin')
+        call.add_child(eacoin)
+        eacoin.set_attribute('method', 'checkout')
+        eacoin.add_child(Node.string('sessid', session))
+
+        # Swap with server
+        resp = self.exchange('core/eacoin', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eacoin/@status")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        raise Exception('Override in subclass!')
diff --git a/bemani/client/bishi/__init__.py b/bemani/client/bishi/__init__.py
new file mode 100644
index 0000000..283303f
--- /dev/null
+++ b/bemani/client/bishi/__init__.py
@@ -0,0 +1 @@
+from bemani.client.bishi.bishi import TheStarBishiBashiClient
diff --git a/bemani/client/bishi/bishi.py b/bemani/client/bishi/bishi.py
new file mode 100644
index 0000000..27f96e4
--- /dev/null
+++ b/bemani/client/bishi/bishi.py
@@ -0,0 +1,222 @@
+import base64
+import time
+from typing import Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class TheStarBishiBashiClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '1.7.6'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_system_getmaster(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        system = Node.void('system')
+        call.add_child(system)
+        system.set_attribute('method', 'getmaster')
+        data = Node.void('data')
+        system.add_child(data)
+        data.add_child(Node.string('gamekind', 'IBB'))
+        data.add_child(Node.string('datatype', 'S_SRVMSG'))
+        data.add_child(Node.string('datakey', 'INFO'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/system/result")
+
+    def verify_usergamedata_send(self, ref_id: str, msg_type: str) -> None:
+        call = self.call_node()
+
+        # Set up profile write
+        profiledata = [
+            b'ffffffff',
+            b'IBBDAT00',
+            b'1',
+            b'0',
+            b'0',
+            b'0',
+            b'0',
+            b'0',
+            b'e474c1b',
+            b'0',
+            b'0',
+            b'ff',
+            b'0',
+            b'0',
+            b'0',
+            b'0',
+            b'0',
+            b'0',
+            b'0',
+            b'0.000000',
+            b'0.000000',
+            b'0.000000',
+            b'0.000000',
+            b'0.000000',
+            b'0.000000',
+            b'0.000000',
+            b'0.000000',
+            b'',
+            b'',
+            b'',
+            b'\x96\xa2\x90\xdd\x92\xe8',
+            b'\x8d\x81\x8d`',
+            b'',
+            b'',
+            b'',
+        ]
+
+        if msg_type == 'new':
+            # New profile gets blank name, because we save over it at the end of the round.
+            profiledata[27] = b''
+        elif msg_type == 'existing':
+            # Exiting profile gets our hardcoded name saved.
+            profiledata[27] = self.NAME.encode('shift-jis')
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_send')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('eaid', ref_id))
+        data.add_child(Node.string('gamekind', 'IBB'))
+        data.add_child(Node.u32('datanum', 1))
+        record = Node.void('record')
+        data.add_child(record)
+        d = Node.string('d', base64.b64encode(b','.join(profiledata)).decode('ascii'))
+        record.add_child(d)
+        d.add_child(Node.string('bin1', ''))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/playerdata/result")
+
+    def verify_usergamedata_recv(self, ref_id: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_recv')
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('eaid', ref_id))
+        data.add_child(Node.string('gamekind', 'IBB'))
+        data.add_child(Node.u32('recv_num', 1))
+        data.add_child(Node.string('recv_csv', 'IBBDAT00,3fffffffff'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/playerdata/result")
+        self.assert_path(resp, "response/playerdata/player/record/d/bin1")
+        self.assert_path(resp, "response/playerdata/player/record_num")
+
+        # Grab binary data, parse out name
+        bindata = resp.child_value('playerdata/player/record/d')
+        profiledata = base64.b64decode(bindata).split(b',')
+
+        # We lob off the first two values in returning profile, so the name is offset by two
+        return profiledata[25].decode('shift-jis')
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_system_getmaster()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Bishi doesn't read a new profile, it just writes out CSV for a blank one
+            self.verify_usergamedata_send(ref_id, msg_type='new')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify profile saving
+            name = self.verify_usergamedata_recv(ref_id)
+            if name != '':
+                raise Exception('New profile has a name associated with it!')
+
+            self.verify_usergamedata_send(ref_id, msg_type='existing')
+            name = self.verify_usergamedata_recv(ref_id)
+            if name != self.NAME:
+                raise Exception('Existing profile has no name associated with it!')
+        else:
+            print("Skipping score checks for existing card")
diff --git a/bemani/client/common.py b/bemani/client/common.py
new file mode 100644
index 0000000..7e24d12
--- /dev/null
+++ b/bemani/client/common.py
@@ -0,0 +1,9 @@
+import random
+
+
+def random_hex_string(length: int, caps: bool=False) -> str:
+    if caps:
+        string = '0123456789ABCDEF'
+    else:
+        string = '0123456789abcdef'
+    return ''.join([random.choice(string) for x in range(length)])
diff --git a/bemani/client/ddr/__init__.py b/bemani/client/ddr/__init__.py
new file mode 100644
index 0000000..cba5c61
--- /dev/null
+++ b/bemani/client/ddr/__init__.py
@@ -0,0 +1,5 @@
+from bemani.client.ddr.ddrx2 import DDRX2Client
+from bemani.client.ddr.ddrx3 import DDRX3Client
+from bemani.client.ddr.ddr2013 import DDR2013Client
+from bemani.client.ddr.ddr2014 import DDR2014Client
+from bemani.client.ddr.ddrace import DDRAceClient
diff --git a/bemani/client/ddr/ddr2013.py b/bemani/client/ddr/ddr2013.py
new file mode 100644
index 0000000..a99adfc
--- /dev/null
+++ b/bemani/client/ddr/ddr2013.py
@@ -0,0 +1,743 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class DDR2013Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_game_shop(self, loc: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('area', '51')
+        game.set_attribute('boot', '34')
+        game.set_attribute('close', '0')
+        game.set_attribute('close_t', '0')
+        game.set_attribute('coin', '02.01.--.--.01.G')
+        game.set_attribute('diff', '3')
+        game.set_attribute('during', '1')
+        game.set_attribute('edit_cnt', '0')
+        game.set_attribute('edit_used', '1')
+        game.set_attribute('first', '1')
+        game.set_attribute('ip', '1.5.7.3')
+        game.set_attribute('is_paseli', '1')
+        game.set_attribute('loc', loc)
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        game.set_attribute('machine', '2')
+        game.set_attribute('name', 'ＴＥＳＴ')
+        game.set_attribute('pay', '0')
+        game.set_attribute('region', '.')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('stage', '1')
+        game.set_attribute('time', '60')
+        game.set_attribute('type', '0')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@stop")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'common')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/flag/@id")
+        self.assert_path(resp, "response/game/flag/@s1")
+        self.assert_path(resp, "response/game/flag/@s2")
+        self.assert_path(resp, "response/game/flag/@t")
+        self.assert_path(resp, "response/game/cnt_music")
+
+    def verify_game_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'hiscore')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+            self.assert_path(child, 'music/type/code')
+
+    def verify_game_area_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'area_hiscore')
+        game.set_attribute('shop_area', '51')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+            self.assert_path(child, 'music/type/code')
+
+    def verify_game_message(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'message')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_ranking(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'ranking')
+        game.set_attribute('max', '10')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_log(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'log')
+        game.set_attribute('type', '0')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('boot', '34')
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        clear = Node.void('clear')
+        game.add_child(clear)
+        clear.set_attribute('book', '0')
+        clear.set_attribute('edit', '0')
+        clear.set_attribute('rank', '0')
+        clear.set_attribute('set', '0')
+        auto = Node.void('auto')
+        game.add_child(auto)
+        auto.set_attribute('book', '1')
+        auto.set_attribute('edit', '1')
+        auto.set_attribute('rank', '1')
+        auto.set_attribute('set', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_tax_info(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'tax_info')
+        game.set_attribute('ver', '2014032400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/tax_info/@tax_phase")
+
+    def verify_game_recorder(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'recorder')
+        game.set_attribute('assert_cnt', '0')
+        game.set_attribute('assert_info', '')
+        game.set_attribute('assert_path', '')
+        game.set_attribute('assert_time', '0')
+        game.set_attribute('boot_time', '1706151228')
+        game.set_attribute('cnt_demo', '1')
+        game.set_attribute('cnt_music', '1')
+        game.set_attribute('cnt_play', '0')
+        game.set_attribute('last_mid', '481')
+        game.set_attribute('last_seq', '36')
+        game.set_attribute('last_step', '0')
+        game.set_attribute('last_time', '1706151235')
+        game.set_attribute('softcode', self.config['model'])
+        game.set_attribute('temp_seq', '15')
+        game.set_attribute('temp_step', '8')
+        game.set_attribute('temp_time', '1706151234')
+        game.set_attribute('wd_restart', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_lock(self, ref_id: str, play: int) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'lock')
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('play', str(play))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@now_login")
+
+    def verify_game_new(self, ref_id: str) -> None:
+        # Pad the name to 8 characters
+        name = self.NAME[:8]
+        while len(name) < 8:
+            name = name + ' '
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('name', name)
+        game.set_attribute('area', '51')
+        game.set_attribute('old', '0')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load_daily(self, ref_id: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load_daily')
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/game/daycount/@playcount")
+        self.assert_path(resp, "response/game/dailycombo/@daily_combo")
+        self.assert_path(resp, "response/game/dailycombo/@daily_combo_lv")
+
+    def verify_game_load(self, ref_id: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/game/@none")
+            return {}
+        if msg_type == 'existing':
+            # Verify existing profile and return info
+            self.assert_path(resp, "response/game/seq")
+            self.assert_path(resp, "response/game/code")
+            self.assert_path(resp, "response/game/name")
+            self.assert_path(resp, "response/game/area")
+            self.assert_path(resp, "response/game/cnt_s")
+            self.assert_path(resp, "response/game/cnt_d")
+            self.assert_path(resp, "response/game/cnt_b")
+            self.assert_path(resp, "response/game/cnt_m0")
+            self.assert_path(resp, "response/game/cnt_m1")
+            self.assert_path(resp, "response/game/cnt_m2")
+            self.assert_path(resp, "response/game/cnt_m3")
+            self.assert_path(resp, "response/game/cnt_m4")
+            self.assert_path(resp, "response/game/cnt_m5")
+            self.assert_path(resp, "response/game/exp")
+            self.assert_path(resp, "response/game/exp_o")
+            self.assert_path(resp, "response/game/star")
+            self.assert_path(resp, "response/game/star_c")
+            self.assert_path(resp, "response/game/combo")
+            self.assert_path(resp, "response/game/timing_diff")
+            self.assert_path(resp, "response/game/chara")
+            self.assert_path(resp, "response/game/chara_opt")
+            self.assert_path(resp, "response/game/daycount/@playcount")
+            self.assert_path(resp, "response/game/dailycombo/@daily_combo")
+            self.assert_path(resp, "response/game/dailycombo/@daily_combo_lv")
+            self.assert_path(resp, "response/game/last/@cate")
+            self.assert_path(resp, "response/game/last/@cid")
+            self.assert_path(resp, "response/game/last/@ctype")
+            self.assert_path(resp, "response/game/last/@fri")
+            self.assert_path(resp, "response/game/last/@mid")
+            self.assert_path(resp, "response/game/last/@mode")
+            self.assert_path(resp, "response/game/last/@mtype")
+            self.assert_path(resp, "response/game/last/@rival1")
+            self.assert_path(resp, "response/game/last/@rival2")
+            self.assert_path(resp, "response/game/last/@rival3")
+            self.assert_path(resp, "response/game/last/@sid")
+            self.assert_path(resp, "response/game/last/@sort")
+            self.assert_path(resp, "response/game/last/@style")
+            self.assert_path(resp, "response/game/result_star/@slot1")
+            self.assert_path(resp, "response/game/result_star/@slot2")
+            self.assert_path(resp, "response/game/result_star/@slot3")
+            self.assert_path(resp, "response/game/result_star/@slot4")
+            self.assert_path(resp, "response/game/result_star/@slot5")
+            self.assert_path(resp, "response/game/result_star/@slot6")
+            self.assert_path(resp, "response/game/result_star/@slot7")
+            self.assert_path(resp, "response/game/result_star/@slot8")
+            self.assert_path(resp, "response/game/result_star/@slot9")
+            self.assert_path(resp, "response/game/target/@flag")
+            self.assert_path(resp, "response/game/target/@setnum")
+            self.assert_path(resp, "response/game/gr_s/@gr1")
+            self.assert_path(resp, "response/game/gr_s/@gr2")
+            self.assert_path(resp, "response/game/gr_s/@gr3")
+            self.assert_path(resp, "response/game/gr_s/@gr4")
+            self.assert_path(resp, "response/game/gr_s/@gr5")
+            self.assert_path(resp, "response/game/gr_d/@gr1")
+            self.assert_path(resp, "response/game/gr_d/@gr2")
+            self.assert_path(resp, "response/game/gr_d/@gr3")
+            self.assert_path(resp, "response/game/gr_d/@gr4")
+            self.assert_path(resp, "response/game/gr_d/@gr5")
+            self.assert_path(resp, "response/game/opt")
+            self.assert_path(resp, "response/game/opt_ex")
+            self.assert_path(resp, "response/game/flag")
+            self.assert_path(resp, "response/game/rank")
+            for i in range(55):
+                self.assert_path(resp, "response/game/play_area/@play_cnt{}".format(i))
+
+            gr_s = resp.child('game/gr_s')
+            gr_d = resp.child('game/gr_d')
+
+            return {
+                'name': resp.child_value('game/name'),
+                'ext_id': resp.child_value('game/code'),
+                'single_plays': resp.child_value('game/cnt_s'),
+                'double_plays': resp.child_value('game/cnt_d'),
+                'groove_single': [
+                    int(gr_s.attribute('gr1')),
+                    int(gr_s.attribute('gr2')),
+                    int(gr_s.attribute('gr3')),
+                    int(gr_s.attribute('gr4')),
+                    int(gr_s.attribute('gr5')),
+                ],
+                'groove_double': [
+                    int(gr_d.attribute('gr1')),
+                    int(gr_d.attribute('gr2')),
+                    int(gr_d.attribute('gr3')),
+                    int(gr_d.attribute('gr4')),
+                    int(gr_d.attribute('gr5')),
+                ],
+            }
+
+        raise Exception('Unknown load type!')
+
+    def verify_game_load_m(self, ref_id: str) -> Dict[int, Dict[int, Dict[str, Any]]]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('all', '1')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'load_m')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        scores: Dict[int, Dict[int, Dict[str, Any]]] = {}
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink')
+            reclink = int(child.attribute('reclink'))
+
+            for typenode in child.children:
+                self.assert_path(typenode, 'type/@diff')
+                self.assert_path(typenode, 'type/score')
+                self.assert_path(typenode, 'type/count')
+                self.assert_path(typenode, 'type/rank')
+                self.assert_path(typenode, 'type/combo_type')
+                chart = int(typenode.attribute('diff'))
+                vals = {
+                    'score': typenode.child_value('score'),
+                    'count': typenode.child_value('count'),
+                    'rank': typenode.child_value('rank'),
+                    'halo': typenode.child_value('combo_type'),
+                }
+                if reclink not in scores:
+                    scores[reclink] = {}
+                scores[reclink][chart] = vals
+        return scores
+
+    def verify_game_save(self, ref_id: str, style: int, gauge: Optional[List[int]]=None) -> None:
+        gauge = gauge or [0, 0, 0, 0, 0]
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('shop_area', '51')
+        last = Node.void('last')
+        game.add_child(last)
+        last.set_attribute('mode', '1')
+        last.set_attribute('style', str(style))
+        gr = Node.void('gr')
+        game.add_child(gr)
+        gr.set_attribute('gr1', str(gauge[0]))
+        gr.set_attribute('gr2', str(gauge[1]))
+        gr.set_attribute('gr3', str(gauge[2]))
+        gr.set_attribute('gr4', str(gauge[3]))
+        gr.set_attribute('gr5', str(gauge[4]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_score(self, ref_id: str, songid: int, chart: int) -> List[int]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'score')
+        game.set_attribute('mid', str(songid))
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2014032400')
+        game.set_attribute('type', str(chart))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@sc1")
+        self.assert_path(resp, "response/game/@sc2")
+        self.assert_path(resp, "response/game/@sc3")
+        self.assert_path(resp, "response/game/@sc4")
+        self.assert_path(resp, "response/game/@sc5")
+        return [
+            int(resp.child('game').attribute('sc1')),
+            int(resp.child('game').attribute('sc2')),
+            int(resp.child('game').attribute('sc3')),
+            int(resp.child('game').attribute('sc4')),
+            int(resp.child('game').attribute('sc5')),
+        ]
+
+    def verify_game_save_m(self, ref_id: str, ext_id: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save_m')
+        game.set_attribute('diff', '12345')
+        game.set_attribute('mtype', str(score['chart']))
+        game.set_attribute('mid', str(score['id']))
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2014032400')
+        data = Node.void('data')
+        game.add_child(data)
+        data.set_attribute('score', str(score['score']))
+        data.set_attribute('rank', str(score['rank']))
+        data.set_attribute('shop_area', '0')
+        data.set_attribute('playmode', '1')
+        data.set_attribute('combo', str(score['combo']))
+        data.set_attribute('phase', '1')
+        data.set_attribute('full', '1' if score['halo'] >= 1 else '0')
+        data.set_attribute('great_fc', '1' if score['halo'] == 1 else '0')
+        data.set_attribute('good_fc', '1' if score['halo'] == 4 else '0')
+        data.set_attribute('perf_fc', '1' if score['halo'] == 2 else '0')
+        player = Node.void('player')
+        game.add_child(player)
+        player.set_attribute('playcnt', '123')
+        player.set_attribute('code', ext_id)
+        option = Node.void('option')
+        game.add_child(option)
+        option.set_attribute('opt0', '6')
+        option.set_attribute('opt6', '1')
+        game.add_child(Node.u8_array('trace', [0] * 512))
+        game.add_child(Node.u32('size', 512))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get('EUC_JP')
+        self.verify_pcbevent_put()
+        self.verify_game_shop(location)
+        self.verify_game_common()
+        self.verify_game_hiscore()
+        self.verify_game_area_hiscore()
+        self.verify_game_message()
+        self.verify_game_ranking()
+        self.verify_game_log()
+        self.verify_game_tax_info()
+        self.verify_game_recorder()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Bishi doesn't read a new profile, it just writes out CSV for a blank one
+            self.verify_game_load(ref_id, msg_type='new')
+            self.verify_game_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify locking and unlocking profile ability
+        self.verify_game_lock(ref_id, 1)
+        self.verify_game_lock(ref_id, 0)
+
+        if cardid is None:
+            # Verify empty profile
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            ext_id = str(profile['ext_id'])
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 0:
+                raise Exception('Profile has plays on single already!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has plays on double already!')
+            if any([g != 0 for g in profile['groove_single']]):
+                raise Exception('Profile has single groove gauge values already!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has double groove gauge values already!')
+
+            # Verify empty scores
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Scores exist on new profile!')
+
+            self.verify_game_load_daily(ref_id)
+
+            # Verify profile saving
+            self.verify_game_save(ref_id, 0, [1, 2, 3, 4, 5])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            self.verify_game_save(ref_id, 1, [5, 4, 3, 2, 1])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 1:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if profile['groove_double'] != [5, 4, 3, 2, 1]:
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            # Now, write some scores and verify saving
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 593,
+                            'chart': 3,
+                            'score': 800000,
+                            'combo': 123,
+                            'rank': 4,
+                            'halo': 1,
+                        },
+                        # A good score on an easier chart same song
+                        {
+                            'id': 593,
+                            'chart': 2,
+                            'score': 990000,
+                            'combo': 321,
+                            'rank': 2,
+                            'halo': 2,
+                        },
+                        # A perfect score
+                        {
+                            'id': 483,
+                            'chart': 3,
+                            'score': 1000000,
+                            'combo': 400,
+                            'rank': 1,
+                            'halo': 3,
+                        },
+                        # A bad score
+                        {
+                            'id': 483,
+                            'chart': 2,
+                            'score': 100000,
+                            'combo': 5,
+                            'rank': 7,
+                            'halo': 0,
+                        },
+                        {
+                            'id': 483,
+                            'chart': 1,
+                            'score': 60000,
+                            'combo': 5,
+                            'rank': 6,
+                            'halo': 4,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on a chart
+                        {
+                            'id': 593,
+                            'chart': 3,
+                            'score': 850000,
+                            'combo': 234,
+                            'rank': 3,
+                            'halo': 2,
+                        },
+                        # A worse score on another chart
+                        {
+                            'id': 593,
+                            'chart': 2,
+                            'score': 980000,
+                            'combo': 300,
+                            'rank': 3,
+                            'halo': 0,
+                            'expected_score': 990000,
+                            'expected_rank': 2,
+                            'expected_halo': 2,
+                        },
+                    ]
+
+                # Verify empty scores for starters
+                if phase == 1:
+                    for score in dummyscores:
+                        last_five = self.verify_game_score(ref_id, score['id'], score['chart'])
+                        if any([s != 0 for s in last_five]):
+                            raise Exception('Score already found on song not played yet!')
+                for score in dummyscores:
+                    self.verify_game_save_m(ref_id, ext_id, score)
+                scores = self.verify_game_load_m(ref_id)
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    # Verify the attributes of the score
+                    expected_score = score.get('expected_score', score['score'])
+                    expected_rank = score.get('expected_rank', score['rank'])
+                    expected_halo = score.get('expected_halo', score['halo'])
+
+                    if data['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['score'],
+                        ))
+                    if data['rank'] != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for song \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, score['id'], score['chart'], data['rank'],
+                        ))
+                    if data['halo'] != expected_halo:
+                        raise Exception('Expected a halo of \'{}\' for song \'{}\' chart \'{}\' but got halo \'{}\''.format(
+                            expected_halo, score['id'], score['chart'], data['halo'],
+                        ))
+
+                    # Verify that the last score is our score
+                    last_five = self.verify_game_score(ref_id, score['id'], score['chart'])
+                    if last_five[0] != score['score']:
+                        raise Exception('Invalid score returned for last five scores on song {} chart {}!'.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/ddr/ddr2014.py b/bemani/client/ddr/ddr2014.py
new file mode 100644
index 0000000..772f65c
--- /dev/null
+++ b/bemani/client/ddr/ddr2014.py
@@ -0,0 +1,735 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class DDR2014Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_game_shop(self, loc: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('area', '51')
+        game.set_attribute('boot', '34')
+        game.set_attribute('close', '0')
+        game.set_attribute('close_t', '0')
+        game.set_attribute('coin', '02.01.--.--.01.G')
+        game.set_attribute('diff', '3')
+        game.set_attribute('during', '1')
+        game.set_attribute('edit_cnt', '0')
+        game.set_attribute('edit_used', '1')
+        game.set_attribute('first', '1')
+        game.set_attribute('ip', '1.5.7.3')
+        game.set_attribute('is_freefirstplay', '1')
+        game.set_attribute('is_paseli', '1')
+        game.set_attribute('loc', loc)
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        game.set_attribute('machine', '2')
+        game.set_attribute('name', 'ＴＥＳＴ')
+        game.set_attribute('pay', '0')
+        game.set_attribute('region', '.')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('stage', '1')
+        game.set_attribute('time', '60')
+        game.set_attribute('type', '0')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@stop")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'common')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/flag/@id")
+        self.assert_path(resp, "response/game/flag/@s1")
+        self.assert_path(resp, "response/game/flag/@s2")
+        self.assert_path(resp, "response/game/flag/@t")
+        self.assert_path(resp, "response/game/cnt_music_monthly")
+        self.assert_path(resp, "response/game/cnt_music_weekly")
+        self.assert_path(resp, "response/game/cnt_music_daily")
+
+    def verify_game_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'hiscore')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+            self.assert_path(child, 'music/type/code')
+
+    def verify_game_area_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'area_hiscore')
+        game.set_attribute('shop_area', '51')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+            self.assert_path(child, 'music/type/code')
+
+    def verify_game_message(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'message')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_ranking(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'ranking')
+        game.set_attribute('max', '10')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_log(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'log')
+        game.set_attribute('type', '0')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('boot', '34')
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        clear = Node.void('clear')
+        game.add_child(clear)
+        clear.set_attribute('book', '0')
+        clear.set_attribute('edit', '0')
+        clear.set_attribute('rank', '0')
+        clear.set_attribute('set', '0')
+        auto = Node.void('auto')
+        game.add_child(auto)
+        auto.set_attribute('book', '1')
+        auto.set_attribute('edit', '1')
+        auto.set_attribute('rank', '1')
+        auto.set_attribute('set', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_tax_info(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'tax_info')
+        game.set_attribute('ver', '2014102700')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/tax_info/@tax_phase")
+
+    def verify_game_recorder(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'recorder')
+        game.set_attribute('assert_cnt', '0')
+        game.set_attribute('assert_info', '')
+        game.set_attribute('assert_path', '')
+        game.set_attribute('assert_time', '0')
+        game.set_attribute('boot_time', '1706151228')
+        game.set_attribute('cnt_demo', '1')
+        game.set_attribute('cnt_music', '1')
+        game.set_attribute('cnt_play', '0')
+        game.set_attribute('last_mid', '481')
+        game.set_attribute('last_seq', '36')
+        game.set_attribute('last_step', '0')
+        game.set_attribute('last_time', '1706151235')
+        game.set_attribute('softcode', self.config['model'])
+        game.set_attribute('temp_seq', '15')
+        game.set_attribute('temp_step', '8')
+        game.set_attribute('temp_time', '1706151234')
+        game.set_attribute('wd_restart', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_lock(self, ref_id: str, play: int) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'lock')
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('play', str(play))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@now_login")
+
+    def verify_game_new(self, ref_id: str) -> None:
+        # Pad the name to 8 characters
+        name = self.NAME[:8]
+        while len(name) < 8:
+            name = name + ' '
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('name', name)
+        game.set_attribute('area', '51')
+        game.set_attribute('old', '0')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load_daily(self, ref_id: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load_daily')
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/game/daycount/@playcount")
+        self.assert_path(resp, "response/game/dailycombo/@daily_combo")
+        self.assert_path(resp, "response/game/dailycombo/@daily_combo_lv")
+
+    def verify_game_load(self, ref_id: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/game/@none")
+            return {}
+        if msg_type == 'existing':
+            # Verify existing profile and return info
+            self.assert_path(resp, "response/game/seq")
+            self.assert_path(resp, "response/game/code")
+            self.assert_path(resp, "response/game/name")
+            self.assert_path(resp, "response/game/area")
+            self.assert_path(resp, "response/game/cnt_s")
+            self.assert_path(resp, "response/game/cnt_d")
+            self.assert_path(resp, "response/game/cnt_b")
+            self.assert_path(resp, "response/game/cnt_m0")
+            self.assert_path(resp, "response/game/cnt_m1")
+            self.assert_path(resp, "response/game/cnt_m2")
+            self.assert_path(resp, "response/game/cnt_m3")
+            self.assert_path(resp, "response/game/cnt_m4")
+            self.assert_path(resp, "response/game/cnt_m5")
+            self.assert_path(resp, "response/game/exp")
+            self.assert_path(resp, "response/game/exp_o")
+            self.assert_path(resp, "response/game/star")
+            self.assert_path(resp, "response/game/star_c")
+            self.assert_path(resp, "response/game/combo")
+            self.assert_path(resp, "response/game/timing_diff")
+            self.assert_path(resp, "response/game/chara")
+            self.assert_path(resp, "response/game/chara_opt")
+            self.assert_path(resp, "response/game/daycount/@playcount")
+            self.assert_path(resp, "response/game/dailycombo/@daily_combo")
+            self.assert_path(resp, "response/game/dailycombo/@daily_combo_lv")
+            self.assert_path(resp, "response/game/last/@cate")
+            self.assert_path(resp, "response/game/last/@cid")
+            self.assert_path(resp, "response/game/last/@ctype")
+            self.assert_path(resp, "response/game/last/@fri")
+            self.assert_path(resp, "response/game/last/@mid")
+            self.assert_path(resp, "response/game/last/@mode")
+            self.assert_path(resp, "response/game/last/@mtype")
+            self.assert_path(resp, "response/game/last/@rival1")
+            self.assert_path(resp, "response/game/last/@rival2")
+            self.assert_path(resp, "response/game/last/@rival3")
+            self.assert_path(resp, "response/game/last/@sid")
+            self.assert_path(resp, "response/game/last/@sort")
+            self.assert_path(resp, "response/game/last/@style")
+            self.assert_path(resp, "response/game/result_star/@slot1")
+            self.assert_path(resp, "response/game/result_star/@slot2")
+            self.assert_path(resp, "response/game/result_star/@slot3")
+            self.assert_path(resp, "response/game/result_star/@slot4")
+            self.assert_path(resp, "response/game/result_star/@slot5")
+            self.assert_path(resp, "response/game/result_star/@slot6")
+            self.assert_path(resp, "response/game/result_star/@slot7")
+            self.assert_path(resp, "response/game/result_star/@slot8")
+            self.assert_path(resp, "response/game/result_star/@slot9")
+            self.assert_path(resp, "response/game/gr_s/@gr1")
+            self.assert_path(resp, "response/game/gr_s/@gr2")
+            self.assert_path(resp, "response/game/gr_s/@gr3")
+            self.assert_path(resp, "response/game/gr_s/@gr4")
+            self.assert_path(resp, "response/game/gr_s/@gr5")
+            self.assert_path(resp, "response/game/gr_d/@gr1")
+            self.assert_path(resp, "response/game/gr_d/@gr2")
+            self.assert_path(resp, "response/game/gr_d/@gr3")
+            self.assert_path(resp, "response/game/gr_d/@gr4")
+            self.assert_path(resp, "response/game/gr_d/@gr5")
+            self.assert_path(resp, "response/game/opt")
+            self.assert_path(resp, "response/game/opt_ex")
+            self.assert_path(resp, "response/game/option_ver/@ver")
+            self.assert_path(resp, "response/game/flag")
+            self.assert_path(resp, "response/game/flag_ex")
+            self.assert_path(resp, "response/game/rank")
+            self.assert_path(resp, "response/game/target/@flag")
+            self.assert_path(resp, "response/game/target/@setnum")
+            for i in range(55):
+                self.assert_path(resp, "response/game/play_area/@play_cnt{}".format(i))
+
+            gr_s = resp.child('game/gr_s')
+            gr_d = resp.child('game/gr_d')
+
+            return {
+                'name': resp.child_value('game/name'),
+                'ext_id': resp.child_value('game/code'),
+                'single_plays': resp.child_value('game/cnt_s'),
+                'double_plays': resp.child_value('game/cnt_d'),
+                'groove_single': [
+                    int(gr_s.attribute('gr1')),
+                    int(gr_s.attribute('gr2')),
+                    int(gr_s.attribute('gr3')),
+                    int(gr_s.attribute('gr4')),
+                    int(gr_s.attribute('gr5')),
+                ],
+                'groove_double': [
+                    int(gr_d.attribute('gr1')),
+                    int(gr_d.attribute('gr2')),
+                    int(gr_d.attribute('gr3')),
+                    int(gr_d.attribute('gr4')),
+                    int(gr_d.attribute('gr5')),
+                ],
+            }
+
+        raise Exception('Unknown load type!')
+
+    def verify_game_load_m(self, ref_id: str) -> Dict[int, Dict[int, Dict[str, Any]]]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('all', '1')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'load_m')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        scores: Dict[int, Dict[int, Dict[str, Any]]] = {}
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink')
+            reclink = int(child.attribute('reclink'))
+
+            for typenode in child.children:
+                self.assert_path(typenode, 'type/@diff')
+                self.assert_path(typenode, 'type/score')
+                self.assert_path(typenode, 'type/count')
+                self.assert_path(typenode, 'type/rank')
+                self.assert_path(typenode, 'type/combo_type')
+                chart = int(typenode.attribute('diff'))
+                vals = {
+                    'score': typenode.child_value('score'),
+                    'count': typenode.child_value('count'),
+                    'rank': typenode.child_value('rank'),
+                    'halo': typenode.child_value('combo_type'),
+                }
+                if reclink not in scores:
+                    scores[reclink] = {}
+                scores[reclink][chart] = vals
+        return scores
+
+    def verify_game_load_edit(self, ref_id: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('pid', '0')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'load_edit')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_save(self, ref_id: str, style: int, gauge: Optional[List[int]]=None) -> None:
+        gauge = gauge or [0, 0, 0, 0, 0]
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2014102700')
+        game.set_attribute('shop_area', '51')
+        last = Node.void('last')
+        game.add_child(last)
+        last.set_attribute('mode', '1')
+        last.set_attribute('style', str(style))
+        gr = Node.void('gr')
+        game.add_child(gr)
+        gr.set_attribute('gr1', str(gauge[0]))
+        gr.set_attribute('gr2', str(gauge[1]))
+        gr.set_attribute('gr3', str(gauge[2]))
+        gr.set_attribute('gr4', str(gauge[3]))
+        gr.set_attribute('gr5', str(gauge[4]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_save_m(self, ref_id: str, ext_id: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save_m')
+        game.set_attribute('diff', '12345')
+        game.set_attribute('mtype', str(score['chart']))
+        game.set_attribute('mid', str(score['id']))
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2014102700')
+        data = Node.void('data')
+        game.add_child(data)
+        data.set_attribute('score', str(score['score']))
+        data.set_attribute('rank', str(score['rank']))
+        data.set_attribute('shop_area', '0')
+        data.set_attribute('playmode', '1')
+        data.set_attribute('combo', str(score['combo']))
+        data.set_attribute('phase', '1')
+        data.set_attribute('style', '0')
+        data.set_attribute('full', '1' if score['halo'] >= 1 else '0')
+        data.set_attribute('great_fc', '1' if score['halo'] == 1 else '0')
+        data.set_attribute('good_fc', '1' if score['halo'] == 4 else '0')
+        data.set_attribute('perf_fc', '1' if score['halo'] == 2 else '0')
+        gauge = Node.void('gauge')
+        game.add_child(gauge)
+        gauge.set_attribute('life8', '0')
+        gauge.set_attribute('assist', '0')
+        gauge.set_attribute('risky', '0')
+        gauge.set_attribute('life4', '0')
+        gauge.set_attribute('hard', '0')
+        player = Node.void('player')
+        game.add_child(player)
+        player.set_attribute('playcnt', '123')
+        player.set_attribute('code', ext_id)
+        option = Node.void('option_02')
+        game.add_child(option)
+        option.set_attribute('opt02_0', '6')
+        option.set_attribute('opt02_6', '1')
+        option.set_attribute('opt02_13', '2')
+        game.add_child(Node.u8_array('trace', [0] * 512))
+        game.add_child(Node.u32('size', 512))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get('EUC_JP')
+        self.verify_pcbevent_put()
+        self.verify_game_recorder()
+        self.verify_game_tax_info()
+        self.verify_game_shop(location)
+        self.verify_game_common()
+        self.verify_game_hiscore()
+        self.verify_game_area_hiscore()
+        self.verify_game_message()
+        self.verify_game_ranking()
+        self.verify_game_log()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Bishi doesn't read a new profile, it just writes out CSV for a blank one
+            self.verify_game_load(ref_id, msg_type='new')
+            self.verify_game_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify locking and unlocking profile ability
+        self.verify_game_lock(ref_id, 1)
+        self.verify_game_lock(ref_id, 0)
+
+        if cardid is None:
+            # Verify empty profile
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            ext_id = str(profile['ext_id'])
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 0:
+                raise Exception('Profile has plays on single already!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has plays on double already!')
+            if any([g != 0 for g in profile['groove_single']]):
+                raise Exception('Profile has single groove gauge values already!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has double groove gauge values already!')
+
+            # Verify empty scores
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Scores exist on new profile!')
+
+            self.verify_game_load_edit(ref_id)
+            self.verify_game_load_daily(ref_id)
+
+            # Verify profile saving
+            self.verify_game_save(ref_id, 0, [1, 2, 3, 4, 5])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            self.verify_game_save(ref_id, 1, [5, 4, 3, 2, 1])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 1:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if profile['groove_double'] != [5, 4, 3, 2, 1]:
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            # Now, write some scores and verify saving
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 593,
+                            'chart': 3,
+                            'score': 800000,
+                            'combo': 123,
+                            'rank': 4,
+                            'halo': 1,
+                        },
+                        # A good score on an easier chart same song
+                        {
+                            'id': 593,
+                            'chart': 2,
+                            'score': 990000,
+                            'combo': 321,
+                            'rank': 2,
+                            'halo': 2,
+                        },
+                        # A perfect score
+                        {
+                            'id': 483,
+                            'chart': 3,
+                            'score': 1000000,
+                            'combo': 400,
+                            'rank': 1,
+                            'halo': 3,
+                        },
+                        # A bad score
+                        {
+                            'id': 483,
+                            'chart': 2,
+                            'score': 100000,
+                            'combo': 5,
+                            'rank': 7,
+                            'halo': 0,
+                        },
+                        {
+                            'id': 483,
+                            'chart': 1,
+                            'score': 60000,
+                            'combo': 5,
+                            'rank': 6,
+                            'halo': 4,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on a chart
+                        {
+                            'id': 593,
+                            'chart': 3,
+                            'score': 850000,
+                            'combo': 234,
+                            'rank': 3,
+                            'halo': 2,
+                        },
+                        # A worse score on another chart
+                        {
+                            'id': 593,
+                            'chart': 2,
+                            'score': 980000,
+                            'combo': 300,
+                            'rank': 3,
+                            'halo': 0,
+                            'expected_score': 990000,
+                            'expected_rank': 2,
+                            'expected_halo': 2,
+                        },
+                    ]
+
+                for score in dummyscores:
+                    self.verify_game_save_m(ref_id, ext_id, score)
+                scores = self.verify_game_load_m(ref_id)
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    # Verify the attributes of the score
+                    expected_score = score.get('expected_score', score['score'])
+                    expected_rank = score.get('expected_rank', score['rank'])
+                    expected_halo = score.get('expected_halo', score['halo'])
+
+                    if data['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['score'],
+                        ))
+                    if data['rank'] != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for song \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, score['id'], score['chart'], data['rank'],
+                        ))
+                    if data['halo'] != expected_halo:
+                        raise Exception('Expected a halo of \'{}\' for song \'{}\' chart \'{}\' but got halo \'{}\''.format(
+                            expected_halo, score['id'], score['chart'], data['halo'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/ddr/ddrace.py b/bemani/client/ddr/ddrace.py
new file mode 100644
index 0000000..df00ad9
--- /dev/null
+++ b/bemani/client/ddr/ddrace.py
@@ -0,0 +1,922 @@
+import base64
+import random
+import time
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.client.base import BaseClient
+from bemani.common import ID, Time
+from bemani.protocol import Node
+
+
+def b64str(string: str) -> str:
+    return base64.b64encode(string.encode()).decode('ascii')
+
+
+class DDRAceClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', b64str('2.4.0')))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_system_convcardnumber(self, cardno: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        system = Node.void('system')
+        call.add_child(system)
+        system.set_attribute('method', 'convcardnumber')
+        info = Node.void('info')
+        system.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        system.add_child(data)
+        data.add_child(Node.string('card_id', cardno))
+        data.add_child(Node.s32('card_type', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/system/data/card_number")
+        self.assert_path(resp, "response/system/result")
+
+    def verify_playerdata_usergamedata_advanced_usernew(self, refid: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_advanced')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('mode', 'usernew'))
+        data.add_child(Node.string('shoparea', '.'))
+        data.add_child(Node.s64('gamesession', 123456))
+        data.add_child(Node.string('refid', refid))
+        data.add_child(Node.string('dataid', refid))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.string('pcbid', self.pcbid))
+        data.add_child(Node.void('record'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/playerdata/seq")
+        self.assert_path(resp, "response/playerdata/code")
+        self.assert_path(resp, "response/playerdata/shoparea")
+        self.assert_path(resp, "response/playerdata/result")
+
+        return resp.child_value('playerdata/code')
+
+    def verify_playerdata_usergamedata_advanced_ghostload(self, refid: str, ghostid: int) -> Dict[str, Any]:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_advanced')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('mode', 'ghostload'))
+        data.add_child(Node.s32('ghostid', ghostid))
+        data.add_child(Node.s64('gamesession', 123456))
+        data.add_child(Node.string('refid', refid))
+        data.add_child(Node.string('dataid', refid))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.string('pcbid', self.pcbid))
+        data.add_child(Node.void('record'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/playerdata/ghostdata/code")
+        self.assert_path(resp, "response/playerdata/ghostdata/mcode")
+        self.assert_path(resp, "response/playerdata/ghostdata/notetype")
+        self.assert_path(resp, "response/playerdata/ghostdata/ghostsize")
+        self.assert_path(resp, "response/playerdata/ghostdata/ghost")
+
+        return {
+            'extid': resp.child_value('playerdata/ghostdata/code'),
+            'id': resp.child_value('playerdata/ghostdata/mcode'),
+            'chart': resp.child_value('playerdata/ghostdata/notetype'),
+            'ghost': resp.child_value('playerdata/ghostdata/ghost'),
+        }
+
+    def verify_playerdata_usergamedata_advanced_rivalload(self, refid: str, loadflag: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_advanced')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('mode', 'rivalload'))
+        data.add_child(Node.u64('targettime', Time.now() * 1000))
+        data.add_child(Node.string('shoparea', '.'))
+        data.add_child(Node.bool('isdouble', False))
+        data.add_child(Node.s32('loadflag', loadflag))
+        data.add_child(Node.s32('ddrcode', 0))
+        data.add_child(Node.s64('gamesession', 123456))
+        data.add_child(Node.string('refid', refid))
+        data.add_child(Node.string('dataid', refid))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.string('pcbid', self.pcbid))
+        data.add_child(Node.void('record'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/playerdata/data/recordtype")
+        if loadflag != 2:
+            # As implemented, its possible for a machine not in an arcade to have scores.
+            # So, if the test PCBID we're using isn't in an arcade, we won't fetch scores
+            # for area records (flag 2), so don't check for these in that case.
+            self.assert_path(resp, "response/playerdata/data/record/mcode")
+            self.assert_path(resp, "response/playerdata/data/record/notetype")
+            self.assert_path(resp, "response/playerdata/data/record/rank")
+            self.assert_path(resp, "response/playerdata/data/record/clearkind")
+            self.assert_path(resp, "response/playerdata/data/record/flagdata")
+            self.assert_path(resp, "response/playerdata/data/record/name")
+            self.assert_path(resp, "response/playerdata/data/record/area")
+            self.assert_path(resp, "response/playerdata/data/record/code")
+            self.assert_path(resp, "response/playerdata/data/record/score")
+            self.assert_path(resp, "response/playerdata/data/record/ghostid")
+
+        if resp.child_value('playerdata/data/recordtype') != loadflag:
+            raise Exception('Invalid record type returned!')
+
+    def verify_playerdata_usergamedata_advanced_userload(self, refid: str) -> Tuple[bool, List[Dict[str, Any]]]:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_advanced')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('mode', 'userload'))
+        data.add_child(Node.s64('gamesession', 123456))
+        data.add_child(Node.string('refid', refid))
+        data.add_child(Node.string('dataid', refid))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.string('pcbid', self.pcbid))
+        data.add_child(Node.void('record'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/playerdata/result")
+        self.assert_path(resp, "response/playerdata/is_new")
+
+        music = []
+        for child in resp.child('playerdata').children:
+            if child.name != 'music':
+                continue
+
+            songid = child.child_value('mcode')
+            chart = 0
+            for note in child.children:
+                if note.name != 'note':
+                    continue
+
+                if note.child_value('count') != 0:
+                    # Actual song
+                    music.append({
+                        'id': songid,
+                        'chart': chart,
+                        'rank': note.child_value('rank'),
+                        'halo': note.child_value('clearkind'),
+                        'score': note.child_value('score'),
+                        'ghostid': note.child_value('ghostid'),
+                    })
+
+                chart = chart + 1
+
+        return (
+            resp.child_value('playerdata/is_new'),
+            music,
+        )
+
+    def verify_playerdata_usergamedata_advanced_inheritance(self, refid: str, locid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_advanced')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('mode', 'inheritance'))
+        data.add_child(Node.string('locid', locid))
+        data.add_child(Node.s64('gamesession', 123456))
+        data.add_child(Node.string('refid', refid))
+        data.add_child(Node.string('dataid', refid))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.string('pcbid', self.pcbid))
+        data.add_child(Node.void('record'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/playerdata/InheritanceStatus")
+        self.assert_path(resp, "response/playerdata/result")
+
+    def verify_playerdata_usergamedata_advanced_usersave(self, refid: str, extid: int, locid: str, score: Dict[str, Any], scorepos: int=0) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_advanced')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('mode', 'usersave'))
+        data.add_child(Node.string('name', self.NAME))
+        data.add_child(Node.s32('ddrcode', extid))
+        data.add_child(Node.s32('playside', 1))
+        data.add_child(Node.s32('playstyle', 0))
+        data.add_child(Node.s32('area', 58))
+        data.add_child(Node.s32('weight100', 0))
+        data.add_child(Node.string('shopname', 'gmw='))
+        data.add_child(Node.bool('ispremium', False))
+        data.add_child(Node.bool('iseapass', True))
+        data.add_child(Node.bool('istakeover', False))
+        data.add_child(Node.bool('isrepeater', False))
+        data.add_child(Node.bool('isgameover', scorepos < 0))
+        data.add_child(Node.string('locid', locid))
+        data.add_child(Node.string('shoparea', '.'))
+        data.add_child(Node.s64('gamesession', 123456))
+        data.add_child(Node.string('refid', refid))
+        data.add_child(Node.string('dataid', refid))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.string('pcbid', self.pcbid))
+        data.add_child(Node.void('record'))
+
+        for i in range(5):
+            if i == scorepos:
+                # Fill in score here
+                note = Node.void('note')
+                data.add_child(note)
+                note.add_child(Node.u8('stagenum', i + 1))
+                note.add_child(Node.u32('mcode', score['id']))
+                note.add_child(Node.u8('notetype', score['chart']))
+                note.add_child(Node.u8('rank', score['rank']))
+                note.add_child(Node.u8('clearkind', score['halo']))
+                note.add_child(Node.s32('score', score['score']))
+                note.add_child(Node.s32('exscore', 0))
+                note.add_child(Node.s32('maxcombo', 0))
+                note.add_child(Node.s32('life', 0))
+                note.add_child(Node.s32('fastcount', 0))
+                note.add_child(Node.s32('slowcount', 0))
+                note.add_child(Node.s32('judge_marvelous', 0))
+                note.add_child(Node.s32('judge_perfect', 0))
+                note.add_child(Node.s32('judge_great', 0))
+                note.add_child(Node.s32('judge_good', 0))
+                note.add_child(Node.s32('judge_boo', 0))
+                note.add_child(Node.s32('judge_miss', 0))
+                note.add_child(Node.s32('judge_ok', 0))
+                note.add_child(Node.s32('judge_ng', 0))
+                note.add_child(Node.s32('calorie', 0))
+                note.add_child(Node.s32('ghostsize', len(score['ghost'])))
+                note.add_child(Node.string('ghost', score['ghost']))
+                note.add_child(Node.u8('opt_speed', 0))
+                note.add_child(Node.u8('opt_boost', 0))
+                note.add_child(Node.u8('opt_appearance', 0))
+                note.add_child(Node.u8('opt_turn', 0))
+                note.add_child(Node.u8('opt_dark', 0))
+                note.add_child(Node.u8('opt_scroll', 0))
+                note.add_child(Node.u8('opt_arrowcolor', 0))
+                note.add_child(Node.u8('opt_cut', 0))
+                note.add_child(Node.u8('opt_freeze', 0))
+                note.add_child(Node.u8('opt_jump', 0))
+                note.add_child(Node.u8('opt_arrowshape', 0))
+                note.add_child(Node.u8('opt_filter', 0))
+                note.add_child(Node.u8('opt_guideline', 0))
+                note.add_child(Node.u8('opt_gauge', 0))
+                note.add_child(Node.u8('opt_judgepriority', 0))
+                note.add_child(Node.u8('opt_timing', 0))
+                note.add_child(Node.string('basename', ''))
+                note.add_child(Node.string('title_b64', ''))
+                note.add_child(Node.string('artist_b64', ''))
+                note.add_child(Node.u16('bpmMax', 0))
+                note.add_child(Node.u16('bpmMin', 0))
+                note.add_child(Node.u8('level', 0))
+                note.add_child(Node.u8('series', 0))
+                note.add_child(Node.u32('bemaniFlag', 0))
+                note.add_child(Node.u32('genreFlag', 0))
+                note.add_child(Node.u8('limited', 0))
+                note.add_child(Node.u8('region', 0))
+                note.add_child(Node.s32('gr_voltage', 0))
+                note.add_child(Node.s32('gr_stream', 0))
+                note.add_child(Node.s32('gr_chaos', 0))
+                note.add_child(Node.s32('gr_freeze', 0))
+                note.add_child(Node.s32('gr_air', 0))
+                note.add_child(Node.bool('share', False))
+                note.add_child(Node.u64('endtime', 0))
+                note.add_child(Node.s32('folder', 0))
+            else:
+                note = Node.void('note')
+                data.add_child(note)
+                note.add_child(Node.u8('stagenum', 0))
+                note.add_child(Node.u32('mcode', 0))
+                note.add_child(Node.u8('notetype', 0))
+                note.add_child(Node.u8('rank', 0))
+                note.add_child(Node.u8('clearkind', 0))
+                note.add_child(Node.s32('score', 0))
+                note.add_child(Node.s32('exscore', 0))
+                note.add_child(Node.s32('maxcombo', 0))
+                note.add_child(Node.s32('life', 0))
+                note.add_child(Node.s32('fastcount', 0))
+                note.add_child(Node.s32('slowcount', 0))
+                note.add_child(Node.s32('judge_marvelous', 0))
+                note.add_child(Node.s32('judge_perfect', 0))
+                note.add_child(Node.s32('judge_great', 0))
+                note.add_child(Node.s32('judge_good', 0))
+                note.add_child(Node.s32('judge_boo', 0))
+                note.add_child(Node.s32('judge_miss', 0))
+                note.add_child(Node.s32('judge_ok', 0))
+                note.add_child(Node.s32('judge_ng', 0))
+                note.add_child(Node.s32('calorie', 0))
+                note.add_child(Node.s32('ghostsize', 0))
+                note.add_child(Node.string('ghost', ''))
+                note.add_child(Node.u8('opt_speed', 0))
+                note.add_child(Node.u8('opt_boost', 0))
+                note.add_child(Node.u8('opt_appearance', 0))
+                note.add_child(Node.u8('opt_turn', 0))
+                note.add_child(Node.u8('opt_dark', 0))
+                note.add_child(Node.u8('opt_scroll', 0))
+                note.add_child(Node.u8('opt_arrowcolor', 0))
+                note.add_child(Node.u8('opt_cut', 0))
+                note.add_child(Node.u8('opt_freeze', 0))
+                note.add_child(Node.u8('opt_jump', 0))
+                note.add_child(Node.u8('opt_arrowshape', 0))
+                note.add_child(Node.u8('opt_filter', 0))
+                note.add_child(Node.u8('opt_guideline', 0))
+                note.add_child(Node.u8('opt_gauge', 0))
+                note.add_child(Node.u8('opt_judgepriority', 0))
+                note.add_child(Node.u8('opt_timing', 0))
+                note.add_child(Node.string('basename', ''))
+                note.add_child(Node.string('title_b64', ''))
+                note.add_child(Node.string('artist_b64', ''))
+                note.add_child(Node.u16('bpmMax', 0))
+                note.add_child(Node.u16('bpmMin', 0))
+                note.add_child(Node.u8('level', 0))
+                note.add_child(Node.u8('series', 0))
+                note.add_child(Node.u32('bemaniFlag', 0))
+                note.add_child(Node.u32('genreFlag', 0))
+                note.add_child(Node.u8('limited', 0))
+                note.add_child(Node.u8('region', 0))
+                note.add_child(Node.s32('gr_voltage', 0))
+                note.add_child(Node.s32('gr_stream', 0))
+                note.add_child(Node.s32('gr_chaos', 0))
+                note.add_child(Node.s32('gr_freeze', 0))
+                note.add_child(Node.s32('gr_air', 0))
+                note.add_child(Node.bool('share', False))
+                note.add_child(Node.u64('endtime', 0))
+                note.add_child(Node.s32('folder', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/playerdata/result")
+
+    def verify_usergamedata_send(self, ref_id: str, ext_id: int, msg_type: str, send_only_common: bool=False) -> None:
+        call = self.call_node()
+
+        # Set up profile write
+        profiledata = {
+            'COMMON': [
+                b'1',
+                b'0',  # shoparea spot, filled in below
+                b'3c880f8',
+                b'1',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'ffffffffffffffff',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'',  # Name spot, filled in below
+                ID.format_extid(ext_id).encode('ascii'),
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+            ],
+            'OPTION': [
+                b'0',
+                b'3',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'3',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'1',
+                b'2',
+                b'0',
+                b'0',
+                b'0',
+                b'10.000000',
+                b'10.000000',
+                b'10.000000',
+                b'10.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+            ],
+            'LAST': [
+                b'1',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+            ],
+            'RIVAL': [
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'0.000000',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+                b'',
+            ]
+        }
+
+        if msg_type == 'new':
+            # New profile gets blank name, because we save over it at the end of the round.
+            profiledata['COMMON'][1] = b'0'
+            profiledata['COMMON'][25] = b''
+
+        elif msg_type == 'existing':
+            # Exiting profile gets our hardcoded name saved.
+            profiledata['COMMON'][1] = b'3a'
+            profiledata['COMMON'][25] = self.NAME.encode('shift-jis')
+
+        else:
+            raise Exception('Unknown message type {}!'.format(msg_type))
+
+        if send_only_common:
+            profiledata = {'COMMON': profiledata['COMMON']}
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_send')
+        playerdata.add_child(Node.u32('retrycnt', 0))
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('refid', ref_id))
+        data.add_child(Node.string('dataid', ref_id))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.u32('datanum', len(profiledata.keys())))
+        record = Node.void('record')
+        data.add_child(record)
+        for ptype in profiledata:
+            profile = [b'ffffffff', ptype.encode('ascii')] + profiledata[ptype]
+            d = Node.string('d', base64.b64encode(b','.join(profile)).decode('ascii'))
+            record.add_child(d)
+            d.add_child(Node.string('bin1', ''))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/playerdata/result")
+
+    def verify_usergamedata_recv(self, ref_id: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'usergamedata_recv')
+        info = Node.void('info')
+        playerdata.add_child(info)
+        info.add_child(Node.s32('version', 1))
+        data = Node.void('data')
+        playerdata.add_child(data)
+        data.add_child(Node.string('refid', ref_id))
+        data.add_child(Node.string('dataid', ref_id))
+        data.add_child(Node.string('gamekind', 'MDX'))
+        data.add_child(Node.u32('recv_num', 4))
+        data.add_child(Node.string('recv_csv', 'COMMON,3fffffffff,OPTION,3fffffffff,LAST,3fffffffff,RIVAL,3fffffffff'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/playerdata/result")
+        self.assert_path(resp, "response/playerdata/player/record/d/bin1")
+        self.assert_path(resp, "response/playerdata/player/record_num")
+
+        profiles = 0
+        name = ''
+        for child in resp.child('playerdata/player/record').children:
+            if child.name != 'd':
+                continue
+
+            if profiles == 0:
+                bindata = child.value
+                profiledata = base64.b64decode(bindata).split(b',')
+                name = profiledata[25].decode('ascii')
+
+            profiles = profiles + 1
+
+        if profiles != 4:
+            raise Exception('Didn\'t receive all four profiles in the right order!')
+
+        return name
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+
+        # Verify the game-wide packets Ace insists on sending before profile load
+        is_new, music = self.verify_playerdata_usergamedata_advanced_userload('X0000000000000000000000000123456')
+        if not is_new:
+            raise Exception('Fake profiles should be new!')
+        if len(music) > 0:
+            raise Exception('Fake profiles should have no scores associated!')
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            self.verify_system_convcardnumber(card)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            extid = self.verify_playerdata_usergamedata_advanced_usernew(ref_id)
+            self.verify_usergamedata_send(ref_id, extid, 'new')
+            self.verify_playerdata_usergamedata_advanced_inheritance(ref_id, location)
+            name = self.verify_usergamedata_recv(ref_id)
+            if name != '':
+                raise Exception('Name stored on profile we just created!')
+            self.verify_usergamedata_send(ref_id, extid, 'existing', send_only_common=True)
+            name = self.verify_usergamedata_recv(ref_id)
+            if name != self.NAME:
+                raise Exception('Name stored on profile is incorrect!')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            is_new, music = self.verify_playerdata_usergamedata_advanced_userload(ref_id)
+            if is_new:
+                raise Exception('Profile should not be new!')
+            if len(music) > 0:
+                raise Exception('Created profile should have no scores associated!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 10,
+                            'chart': 3,
+                            'rank': 5,
+                            'halo': 6,
+                            'score': 765432,
+                            'ghost': '765432',
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 10,
+                            'chart': 2,
+                            'rank': 2,
+                            'halo': 8,
+                            'score': 876543,
+                            'ghost': '876543',
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 479,
+                            'chart': 2,
+                            'rank': 11,
+                            'halo': 6,
+                            'score': 654321,
+                            'ghost': '654321',
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 479,
+                            'chart': 1,
+                            'rank': 15,
+                            'halo': 6,
+                            'score': 123456,
+                            'ghost': '123456',
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 10,
+                            'chart': 3,
+                            'rank': 4,
+                            'halo': 7,
+                            'score': 888888,
+                            'ghost': '888888',
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 10,
+                            'chart': 2,
+                            'rank': 3,
+                            'halo': 7,
+                            'score': 654321,
+                            'ghost': '654321',
+                            'expected_score': 876543,
+                            'expected_halo': 8,
+                            'expected_rank': 2,
+                            'expected_ghost': '876543',
+                        },
+                    ]
+
+                pos = 0
+                for dummyscore in dummyscores:
+                    self.verify_playerdata_usergamedata_advanced_usersave(
+                        ref_id,
+                        extid,
+                        location,
+                        dummyscore,
+                        pos,
+                    )
+                    pos = pos + 1
+
+                is_new, scores = self.verify_playerdata_usergamedata_advanced_userload(ref_id)
+                if is_new:
+                    raise Exception('Profile should not be new!')
+                if len(scores) == 0:
+                    raise Exception('Expected some scores after saving!')
+
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_rank' in expected:
+                        expected_rank = expected['expected_rank']
+                    else:
+                        expected_rank = expected['rank']
+                    if 'expected_halo' in expected:
+                        expected_halo = expected['expected_halo']
+                    else:
+                        expected_halo = expected['halo']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['rank'] != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for song \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, expected['id'], expected['chart'], actual['rank'],
+                        ))
+                    if actual['halo'] != expected_halo:
+                        raise Exception('Expected a halo of \'{}\' for song \'{}\' chart \'{}\' but got halo \'{}\''.format(
+                            expected_halo, expected['id'], expected['chart'], actual['halo'],
+                        ))
+
+                    # Now verify that the ghost for this score is what we saved
+                    ghost = self.verify_playerdata_usergamedata_advanced_ghostload(ref_id, received['ghostid'])
+                    if 'expected_ghost' in expected:
+                        expected_ghost = expected['expected_ghost']
+                    else:
+                        expected_ghost = expected['ghost']
+
+                    if ghost['id'] != received['id']:
+                        raise Exception('Wrong song ID \'{}\' returned for ghost, expected ID \'{}\''.format(
+                            ghost['id'], received['id'],
+                        ))
+                    if ghost['chart'] != received['chart']:
+                        raise Exception('Wrong song chart \'{}\' returned for ghost, expected chart \'{}\''.format(
+                            ghost['chart'], received['chart'],
+                        ))
+                    if ghost['ghost'] != expected_ghost:
+                        raise Exception('Wrong ghost data \'{}\' returned for ghost, expected \'{}\''.format(
+                            ghost['ghost'], expected_ghost,
+                        ))
+                    if ghost['extid'] != extid:
+                        raise Exception('Wrong extid \'{}\' returned for ghost, expected \'{}\''.format(
+                            ghost['extid'], extid,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Simulate game over conditions
+            self.verify_playerdata_usergamedata_advanced_usersave(
+                ref_id,
+                extid,
+                location,
+                {},
+                -1,
+            )
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify global scores now that we've inserted some
+        self.verify_playerdata_usergamedata_advanced_rivalload('X0000000000000000000000000123456', 1)
+        self.verify_playerdata_usergamedata_advanced_rivalload('X0000000000000000000000000123456', 2)
+        self.verify_playerdata_usergamedata_advanced_rivalload('X0000000000000000000000000123456', 4)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/ddr/ddrx2.py b/bemani/client/ddr/ddrx2.py
new file mode 100644
index 0000000..d4c388e
--- /dev/null
+++ b/bemani/client/ddr/ddrx2.py
@@ -0,0 +1,788 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class DDRX2Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_cardmng_getkeepspan(self) -> None:
+        call = self.call_node()
+
+        # Calculate model node
+        model = ':'.join(self.config['model'].split(':')[:4])
+
+        # Construct node
+        cardmng = Node.void('cardmng')
+        cardmng.set_attribute('method', 'getkeepspan')
+        cardmng.set_attribute('model', model)
+        call.add_child(cardmng)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/cardmng/@keepspan")
+
+    def verify_game_shop(self, loc: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('diff', '3')
+        game.set_attribute('time', '60')
+        game.set_attribute('close', '0')
+        game.set_attribute('during', '1')
+        game.set_attribute('stage', '1')
+        game.set_attribute('ver', '1')
+        game.set_attribute('machine', '2')
+        game.set_attribute('area', '0')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('close_t', '0')
+        game.set_attribute('region', '.')
+        game.set_attribute('is_paseli', '1')
+        game.set_attribute('ip', '1.5.7.3')
+        game.set_attribute('pay', '0')
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('first', '1')
+        game.set_attribute('boot', '34')
+        game.set_attribute('type', '0')
+        game.set_attribute('coin', '02.01.--.--.01.G')
+        game.set_attribute('name', 'ＴＥＳＴ')
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        game.set_attribute('loc', loc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@stop")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'common')
+        game.set_attribute('ver', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/flag/@id")
+        self.assert_path(resp, "response/game/flag/@s1")
+        self.assert_path(resp, "response/game/flag/@s2")
+        self.assert_path(resp, "response/game/flag/@t")
+        self.assert_path(resp, "response/game/cnt_music")
+
+    def verify_game_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'hiscore')
+        game.set_attribute('ver', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+
+    def verify_game_message(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'message')
+        game.set_attribute('ver', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_ranking(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'ranking')
+        game.set_attribute('ver', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_log(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'log')
+        game.set_attribute('type', '0')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('ver', '1')
+        game.set_attribute('boot', '34')
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        clear = Node.void('clear')
+        game.add_child(clear)
+        clear.set_attribute('book', '0')
+        clear.set_attribute('edit', '0')
+        clear.set_attribute('rank', '0')
+        clear.set_attribute('set', '0')
+        auto = Node.void('auto')
+        game.add_child(auto)
+        auto.set_attribute('book', '1')
+        auto.set_attribute('edit', '1')
+        auto.set_attribute('rank', '1')
+        auto.set_attribute('set', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_lock(self, ref_id: str, play: int) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'lock')
+        game.set_attribute('ver', '1')
+        game.set_attribute('play', str(play))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@now_login")
+
+    def verify_game_new(self, ref_id: str) -> None:
+        # Pad the name to 8 characters
+        name = self.NAME[:8]
+        while len(name) < 8:
+            name = name + ' '
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '1')
+        game.set_attribute('name', name)
+        game.set_attribute('area', '51')
+        game.set_attribute('old', '0')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load(self, ref_id: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '1')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/game/@none")
+            return {}
+        if msg_type == 'existing':
+            # Verify existing profile and return info
+            self.assert_path(resp, "response/game/seq")
+            self.assert_path(resp, "response/game/code")
+            self.assert_path(resp, "response/game/name")
+            self.assert_path(resp, "response/game/area")
+            self.assert_path(resp, "response/game/cnt_s")
+            self.assert_path(resp, "response/game/cnt_d")
+            self.assert_path(resp, "response/game/cnt_b")
+            self.assert_path(resp, "response/game/cnt_m0")
+            self.assert_path(resp, "response/game/cnt_m1")
+            self.assert_path(resp, "response/game/cnt_m2")
+            self.assert_path(resp, "response/game/cnt_m3")
+            self.assert_path(resp, "response/game/exp")
+            self.assert_path(resp, "response/game/exp_o")
+            self.assert_path(resp, "response/game/star")
+            self.assert_path(resp, "response/game/star_c")
+            self.assert_path(resp, "response/game/combo")
+            self.assert_path(resp, "response/game/timing_diff")
+            self.assert_path(resp, "response/game/chara")
+            self.assert_path(resp, "response/game/chara_opt")
+            self.assert_path(resp, "response/game/last/@cate")
+            self.assert_path(resp, "response/game/last/@cid")
+            self.assert_path(resp, "response/game/last/@ctype")
+            self.assert_path(resp, "response/game/last/@fri")
+            self.assert_path(resp, "response/game/last/@mid")
+            self.assert_path(resp, "response/game/last/@mode")
+            self.assert_path(resp, "response/game/last/@mtype")
+            self.assert_path(resp, "response/game/last/@sid")
+            self.assert_path(resp, "response/game/last/@sort")
+            self.assert_path(resp, "response/game/last/@style")
+            self.assert_path(resp, "response/game/gr_s/@gr1")
+            self.assert_path(resp, "response/game/gr_s/@gr2")
+            self.assert_path(resp, "response/game/gr_s/@gr3")
+            self.assert_path(resp, "response/game/gr_s/@gr4")
+            self.assert_path(resp, "response/game/gr_s/@gr5")
+            self.assert_path(resp, "response/game/gr_d/@gr1")
+            self.assert_path(resp, "response/game/gr_d/@gr2")
+            self.assert_path(resp, "response/game/gr_d/@gr3")
+            self.assert_path(resp, "response/game/gr_d/@gr4")
+            self.assert_path(resp, "response/game/gr_d/@gr5")
+            self.assert_path(resp, "response/game/opt")
+            self.assert_path(resp, "response/game/opt_ex")
+            self.assert_path(resp, "response/game/flag")
+            self.assert_path(resp, "response/game/rank")
+
+            gr_s = resp.child('game/gr_s')
+            gr_d = resp.child('game/gr_d')
+
+            return {
+                'name': resp.child_value('game/name'),
+                'single_plays': resp.child_value('game/cnt_s'),
+                'double_plays': resp.child_value('game/cnt_d'),
+                'groove_single': [
+                    int(gr_s.attribute('gr1')),
+                    int(gr_s.attribute('gr2')),
+                    int(gr_s.attribute('gr3')),
+                    int(gr_s.attribute('gr4')),
+                    int(gr_s.attribute('gr5')),
+                ],
+                'groove_double': [
+                    int(gr_d.attribute('gr1')),
+                    int(gr_d.attribute('gr2')),
+                    int(gr_d.attribute('gr3')),
+                    int(gr_d.attribute('gr4')),
+                    int(gr_d.attribute('gr5')),
+                ],
+            }
+
+        raise Exception('Unknown load type!')
+
+    def verify_game_load_m(self, ref_id: str) -> Dict[int, Dict[int, Dict[str, Any]]]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '1')
+        game.set_attribute('all', '1')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'load_m')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        scores: Dict[int, Dict[int, Dict[str, Any]]] = {}
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink')
+            reclink = int(child.attribute('reclink'))
+
+            for typenode in child.children:
+                self.assert_path(typenode, 'type/@diff')
+                self.assert_path(typenode, 'type/score')
+                self.assert_path(typenode, 'type/count')
+                self.assert_path(typenode, 'type/rank')
+                self.assert_path(typenode, 'type/combo_type')
+                chart = int(typenode.attribute('diff'))
+                vals = {
+                    'score': typenode.child_value('score'),
+                    'count': typenode.child_value('count'),
+                    'rank': typenode.child_value('rank'),
+                    'halo': typenode.child_value('combo_type'),
+                }
+                if reclink not in scores:
+                    scores[reclink] = {}
+                scores[reclink][chart] = vals
+        return scores
+
+    def verify_game_load_c(self, ref_id: str) -> Dict[int, Dict[int, Dict[str, Any]]]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load_c')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+        courses: Dict[int, Dict[int, Dict[str, Any]]] = {}
+        self.assert_path(resp, "response/game/course")
+        courseblob = resp.child_value('game/course')
+        index = 0
+        for chunk in [courseblob[i:(i + 8)] for i in range(0, len(courseblob), 8)]:
+            if any([v != 0 for v in chunk]):
+                course = int(index / 4)
+                chart = index % 4
+                vals = {
+                    'score': chunk[0] * 10000 + chunk[1],
+                    'combo': chunk[2],
+                    'rank': chunk[3],
+                    'stage': chunk[5],
+                    'combo_type': chunk[6],
+                }
+                if course not in courses:
+                    courses[course] = {}
+                courses[course][chart] = vals
+
+            index = index + 1
+        return courses
+
+    def verify_game_save(self, ref_id: str, style: int, gauge: Optional[List[int]]=None) -> None:
+        gauge = gauge or [0, 0, 0, 0, 0]
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '1')
+        last = Node.void('last')
+        game.add_child(last)
+        last.set_attribute('mode', '1')
+        last.set_attribute('style', str(style))
+        gr = Node.void('gr')
+        game.add_child(gr)
+        gr.set_attribute('gr1', str(gauge[0]))
+        gr.set_attribute('gr2', str(gauge[1]))
+        gr.set_attribute('gr3', str(gauge[2]))
+        gr.set_attribute('gr4', str(gauge[3]))
+        gr.set_attribute('gr5', str(gauge[4]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_score(self, ref_id: str, songid: int, chart: int) -> List[int]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'score')
+        game.set_attribute('mid', str(songid))
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '1')
+        game.set_attribute('type', str(chart))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@sc1")
+        self.assert_path(resp, "response/game/@sc2")
+        self.assert_path(resp, "response/game/@sc3")
+        self.assert_path(resp, "response/game/@sc4")
+        self.assert_path(resp, "response/game/@sc5")
+        return [
+            int(resp.child('game').attribute('sc1')),
+            int(resp.child('game').attribute('sc2')),
+            int(resp.child('game').attribute('sc3')),
+            int(resp.child('game').attribute('sc4')),
+            int(resp.child('game').attribute('sc5')),
+        ]
+
+    def verify_game_save_m(self, ref_id: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '1')
+        game.set_attribute('mtype', str(score['chart']))
+        game.set_attribute('mid', str(score['id']))
+        game.set_attribute('method', 'save_m')
+        data = Node.void('data')
+        game.add_child(data)
+        data.set_attribute('perf', '1' if score['halo'] >= 2 else '0')
+        data.set_attribute('score', str(score['score']))
+        data.set_attribute('rank', str(score['rank']))
+        data.set_attribute('phase', '1')
+        data.set_attribute('full', '1' if score['halo'] >= 1 else '0')
+        data.set_attribute('combo', str(score['combo']))
+        option = Node.void('option')
+        game.add_child(option)
+        option.set_attribute('opt0', '6')
+        option.set_attribute('opt6', '1')
+        game.add_child(Node.u8_array('trace', [0] * 512))
+        game.add_child(Node.u32('size', 512))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_save_c(self, ref_id: str, course: Dict[str, Any]) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ctype', str(course['chart']))
+        game.set_attribute('cid', str(course['id']))
+        game.set_attribute('method', 'save_c')
+        game.set_attribute('ver', '1')
+        game.set_attribute('refid', ref_id)
+        data = Node.void('data')
+        game.add_child(data)
+        data.set_attribute('combo_type', str(course['combo_type']))
+        data.set_attribute('clear', '1')
+        data.set_attribute('combo', str(course['combo']))
+        data.set_attribute('opt', '32774')
+        data.set_attribute('per', '995')
+        data.set_attribute('score', str(course['score']))
+        data.set_attribute('stage', str(course['stage']))
+        data.set_attribute('rank', str(course['rank']))
+        game.add_child(Node.u8_array('trace', [0] * 4096))
+        game.add_child(Node.u32('size', 4096))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_cardmng_getkeepspan()
+        self.verify_game_shop(location)
+        self.verify_game_common()
+        self.verify_game_hiscore()
+        self.verify_game_message()
+        self.verify_game_ranking()
+        self.verify_game_log()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Bishi doesn't read a new profile, it just writes out CSV for a blank one
+            self.verify_game_load(ref_id, msg_type='new')
+            self.verify_game_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify locking and unlocking profile ability
+        self.verify_game_lock(ref_id, 1)
+        self.verify_game_lock(ref_id, 0)
+
+        if cardid is None:
+            # Verify empty profile
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 0:
+                raise Exception('Profile has plays on single already!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has plays on double already!')
+            if any([g != 0 for g in profile['groove_single']]):
+                raise Exception('Profile has single groove gauge values already!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has double groove gauge values already!')
+
+            # Verify empty scores
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Scores exist on new profile!')
+
+            # Verify empty courses
+            courses = self.verify_game_load_c(ref_id)
+            if len(courses) > 0:
+                raise Exception('Courses exist on new profile!')
+
+            # Verify profile saving
+            self.verify_game_save(ref_id, 0, [1, 2, 3, 4, 5])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            self.verify_game_save(ref_id, 1, [5, 4, 3, 2, 1])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 1:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if profile['groove_double'] != [5, 4, 3, 2, 1]:
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            # Now, write some scores and verify saving
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 524,
+                            'chart': 3,
+                            'score': 800000,
+                            'combo': 123,
+                            'rank': 4,
+                            'halo': 1,
+                        },
+                        # A good score on an easier chart same song
+                        {
+                            'id': 524,
+                            'chart': 2,
+                            'score': 990000,
+                            'combo': 321,
+                            'rank': 2,
+                            'halo': 2,
+                        },
+                        # A perfect score
+                        {
+                            'id': 483,
+                            'chart': 3,
+                            'score': 1000000,
+                            'combo': 400,
+                            'rank': 1,
+                            'halo': 3,
+                        },
+                        # A bad score
+                        {
+                            'id': 483,
+                            'chart': 2,
+                            'score': 100000,
+                            'combo': 5,
+                            'rank': 7,
+                            'halo': 0,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on a chart
+                        {
+                            'id': 524,
+                            'chart': 3,
+                            'score': 850000,
+                            'combo': 234,
+                            'rank': 3,
+                            'halo': 2,
+                        },
+                        # A worse score on another chart
+                        {
+                            'id': 524,
+                            'chart': 2,
+                            'score': 980000,
+                            'combo': 300,
+                            'rank': 3,
+                            'halo': 0,
+                            'expected_score': 990000,
+                            'expected_rank': 2,
+                            'expected_halo': 2,
+                        },
+                    ]
+
+                # Verify empty scores for starters
+                if phase == 1:
+                    for score in dummyscores:
+                        last_five = self.verify_game_score(ref_id, score['id'], score['chart'])
+                        if any([s != 0 for s in last_five]):
+                            raise Exception('Score already found on song not played yet!')
+                for score in dummyscores:
+                    self.verify_game_save_m(ref_id, score)
+                scores = self.verify_game_load_m(ref_id)
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    # Verify the attributes of the score
+                    expected_score = score.get('expected_score', score['score'])
+                    expected_rank = score.get('expected_rank', score['rank'])
+                    expected_halo = score.get('expected_halo', score['halo'])
+
+                    if data['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['score'],
+                        ))
+                    if data['rank'] != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for song \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, score['id'], score['chart'], data['rank'],
+                        ))
+                    if data['halo'] != expected_halo:
+                        raise Exception('Expected a halo of \'{}\' for song \'{}\' chart \'{}\' but got halo \'{}\''.format(
+                            expected_halo, score['id'], score['chart'], data['halo'],
+                        ))
+
+                    # Verify that the last score is our score
+                    last_five = self.verify_game_score(ref_id, score['id'], score['chart'])
+                    if last_five[0] != score['score']:
+                        raise Exception('Invalid score returned for last five scores on song {} chart {}!'.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Now, write some courses and verify saving
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummycourses = [
+                        # An okay score on a course
+                        {
+                            'id': 5,
+                            'chart': 3,
+                            'score': 800000,
+                            'combo': 123,
+                            'rank': 4,
+                            'stage': 5,
+                            'combo_type': 1,
+                        },
+                        # A good score on a different coruse
+                        {
+                            'id': 7,
+                            'chart': 2,
+                            'score': 600000,
+                            'combo': 23,
+                            'rank': 5,
+                            'stage': 5,
+                            'combo_type': 0,
+                        },
+                    ]
+                if phase == 2:
+                    dummycourses = [
+                        # A better score on the same course
+                        {
+                            'id': 5,
+                            'chart': 3,
+                            'score': 900000,
+                            'combo': 234,
+                            'rank': 3,
+                            'stage': 5,
+                            'combo_type': 1,
+                        },
+                        # A worse score on a different same course
+                        {
+                            'id': 7,
+                            'chart': 2,
+                            'score': 500000,
+                            'combo': 12,
+                            'rank': 7,
+                            'stage': 4,
+                            'combo_type': 0,
+                            'expected_score': 600000,
+                            'expected_combo': 23,
+                            'expected_rank': 5,
+                            'expected_stage': 5,
+                        },
+                    ]
+
+                for course in dummycourses:
+                    self.verify_game_save_c(ref_id, course)
+                courses = self.verify_game_load_c(ref_id)
+                for course in dummycourses:
+                    data = courses.get(course['id'], {}).get(course['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get course back for course {} chart {}!'.format(course['id'], course['chart']))
+
+                    expected_score = course.get('expected_score', course['score'])
+                    expected_combo = course.get('expected_combo', course['combo'])
+                    expected_rank = course.get('expected_rank', course['rank'])
+                    expected_stage = course.get('expected_stage', course['stage'])
+                    expected_combo_type = course.get('expected_combo_type', course['combo_type'])
+
+                    if data['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for course \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, course['id'], course['chart'], data['score'],
+                        ))
+                    if data['combo'] != expected_combo:
+                        raise Exception('Expected a combo of \'{}\' for course \'{}\' chart \'{}\' but got combo \'{}\''.format(
+                            expected_combo, course['id'], course['chart'], data['combo'],
+                        ))
+                    if data['rank'] != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for course \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, course['id'], course['chart'], data['rank'],
+                        ))
+                    if data['stage'] != expected_stage:
+                        raise Exception('Expected a stage of \'{}\' for course \'{}\' chart \'{}\' but got stage \'{}\''.format(
+                            expected_stage, course['id'], course['chart'], data['stage'],
+                        ))
+                    if data['combo_type'] != expected_combo_type:
+                        raise Exception('Expected a combo_type of \'{}\' for course \'{}\' chart \'{}\' but got combo_type \'{}\''.format(
+                            expected_combo_type, course['id'], course['chart'], data['combo_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/ddr/ddrx3.py b/bemani/client/ddr/ddrx3.py
new file mode 100644
index 0000000..d41b9d3
--- /dev/null
+++ b/bemani/client/ddr/ddrx3.py
@@ -0,0 +1,923 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class DDRX3Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_cardmng_getkeepspan(self) -> None:
+        call = self.call_node()
+
+        # Calculate model node
+        model = ':'.join(self.config['model'].split(':')[:4])
+
+        # Construct node
+        cardmng = Node.void('cardmng')
+        cardmng.set_attribute('method', 'getkeepspan')
+        cardmng.set_attribute('model', model)
+        call.add_child(cardmng)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/cardmng/@keepspan")
+
+    def verify_game_shop(self, loc: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('area', '51')
+        game.set_attribute('boot', '34')
+        game.set_attribute('close', '0')
+        game.set_attribute('close_t', '0')
+        game.set_attribute('coin', '02.01.--.--.01.G')
+        game.set_attribute('diff', '3')
+        game.set_attribute('during', '1')
+        game.set_attribute('first', '1')
+        game.set_attribute('ip', '1.5.7.3')
+        game.set_attribute('is_paseli', '1')
+        game.set_attribute('loc', loc)
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        game.set_attribute('machine', '2')
+        game.set_attribute('name', 'ＴＥＳＴ')
+        game.set_attribute('pay', '0')
+        game.set_attribute('region', '.')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('stage', '1')
+        game.set_attribute('time', '60')
+        game.set_attribute('type', '0')
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@stop")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'common')
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/flag/@id")
+        self.assert_path(resp, "response/game/flag/@s1")
+        self.assert_path(resp, "response/game/flag/@s2")
+        self.assert_path(resp, "response/game/flag/@t")
+        self.assert_path(resp, "response/game/cnt_music")
+
+    def verify_game_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'hiscore')
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+            self.assert_path(child, 'music/type/code')
+
+    def verify_game_area_hiscore(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'area_hiscore')
+        game.set_attribute('shop_area', '51')
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink_num')
+            self.assert_path(child, 'music/type/@diff')
+            self.assert_path(child, 'music/type/name')
+            self.assert_path(child, 'music/type/score')
+            self.assert_path(child, 'music/type/area')
+            self.assert_path(child, 'music/type/rank')
+            self.assert_path(child, 'music/type/combo_type')
+            self.assert_path(child, 'music/type/code')
+
+    def verify_game_message(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'message')
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_ranking(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'ranking')
+        game.set_attribute('max', '10')
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_log(self) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'log')
+        game.set_attribute('type', '0')
+        game.set_attribute('soft', self.config['model'])
+        game.set_attribute('softid', self.pcbid)
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('boot', '34')
+        game.set_attribute('mac', '00:11:22:33:44:55')
+        clear = Node.void('clear')
+        game.add_child(clear)
+        clear.set_attribute('book', '0')
+        clear.set_attribute('edit', '0')
+        clear.set_attribute('rank', '0')
+        clear.set_attribute('set', '0')
+        auto = Node.void('auto')
+        game.add_child(auto)
+        auto.set_attribute('book', '1')
+        auto.set_attribute('edit', '1')
+        auto.set_attribute('rank', '1')
+        auto.set_attribute('set', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_lock(self, ref_id: str, play: int) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'lock')
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('play', str(play))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@now_login")
+
+    def verify_game_new(self, ref_id: str) -> None:
+        # Pad the name to 8 characters
+        name = self.NAME[:8]
+        while len(name) < 8:
+            name = name + ' '
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('name', name)
+        game.set_attribute('area', '51')
+        game.set_attribute('old', '0')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load_daily(self, ref_id: str) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load_daily')
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/game/daycount/@playcount")
+        self.assert_path(resp, "response/game/dailycombo/@daily_combo")
+        self.assert_path(resp, "response/game/dailycombo/@daily_combo_lv")
+
+    def verify_game_load(self, ref_id: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('refid', ref_id)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/game/@none")
+            return {}
+        if msg_type == 'existing':
+            # Verify existing profile and return info
+            self.assert_path(resp, "response/game/seq")
+            self.assert_path(resp, "response/game/code")
+            self.assert_path(resp, "response/game/name")
+            self.assert_path(resp, "response/game/area")
+            self.assert_path(resp, "response/game/cnt_s")
+            self.assert_path(resp, "response/game/cnt_d")
+            self.assert_path(resp, "response/game/cnt_b")
+            self.assert_path(resp, "response/game/cnt_m0")
+            self.assert_path(resp, "response/game/cnt_m1")
+            self.assert_path(resp, "response/game/cnt_m2")
+            self.assert_path(resp, "response/game/cnt_m3")
+            self.assert_path(resp, "response/game/cnt_m4")
+            self.assert_path(resp, "response/game/cnt_m5")
+            self.assert_path(resp, "response/game/exp")
+            self.assert_path(resp, "response/game/exp_o")
+            self.assert_path(resp, "response/game/star")
+            self.assert_path(resp, "response/game/star_c")
+            self.assert_path(resp, "response/game/combo")
+            self.assert_path(resp, "response/game/timing_diff")
+            self.assert_path(resp, "response/game/chara")
+            self.assert_path(resp, "response/game/chara_opt")
+            self.assert_path(resp, "response/game/daycount/@playcount")
+            self.assert_path(resp, "response/game/dailycombo/@daily_combo")
+            self.assert_path(resp, "response/game/dailycombo/@daily_combo_lv")
+            self.assert_path(resp, "response/game/last/@cate")
+            self.assert_path(resp, "response/game/last/@cid")
+            self.assert_path(resp, "response/game/last/@ctype")
+            self.assert_path(resp, "response/game/last/@fri")
+            self.assert_path(resp, "response/game/last/@mid")
+            self.assert_path(resp, "response/game/last/@mode")
+            self.assert_path(resp, "response/game/last/@mtype")
+            self.assert_path(resp, "response/game/last/@rival1")
+            self.assert_path(resp, "response/game/last/@rival2")
+            self.assert_path(resp, "response/game/last/@rival3")
+            self.assert_path(resp, "response/game/last/@sid")
+            self.assert_path(resp, "response/game/last/@sort")
+            self.assert_path(resp, "response/game/last/@style")
+            self.assert_path(resp, "response/game/result_star/@slot1")
+            self.assert_path(resp, "response/game/result_star/@slot2")
+            self.assert_path(resp, "response/game/result_star/@slot3")
+            self.assert_path(resp, "response/game/result_star/@slot4")
+            self.assert_path(resp, "response/game/result_star/@slot5")
+            self.assert_path(resp, "response/game/result_star/@slot6")
+            self.assert_path(resp, "response/game/result_star/@slot7")
+            self.assert_path(resp, "response/game/result_star/@slot8")
+            self.assert_path(resp, "response/game/result_star/@slot9")
+            self.assert_path(resp, "response/game/target/@flag")
+            self.assert_path(resp, "response/game/target/@setnum")
+            self.assert_path(resp, "response/game/gr_s/@gr1")
+            self.assert_path(resp, "response/game/gr_s/@gr2")
+            self.assert_path(resp, "response/game/gr_s/@gr3")
+            self.assert_path(resp, "response/game/gr_s/@gr4")
+            self.assert_path(resp, "response/game/gr_s/@gr5")
+            self.assert_path(resp, "response/game/gr_d/@gr1")
+            self.assert_path(resp, "response/game/gr_d/@gr2")
+            self.assert_path(resp, "response/game/gr_d/@gr3")
+            self.assert_path(resp, "response/game/gr_d/@gr4")
+            self.assert_path(resp, "response/game/gr_d/@gr5")
+            self.assert_path(resp, "response/game/opt")
+            self.assert_path(resp, "response/game/opt_ex")
+            self.assert_path(resp, "response/game/flag")
+            self.assert_path(resp, "response/game/rank")
+            for i in range(55):
+                self.assert_path(resp, "response/game/play_area/@play_cnt{}".format(i))
+
+            gr_s = resp.child('game/gr_s')
+            gr_d = resp.child('game/gr_d')
+
+            return {
+                'name': resp.child_value('game/name'),
+                'single_plays': resp.child_value('game/cnt_s'),
+                'double_plays': resp.child_value('game/cnt_d'),
+                'groove_single': [
+                    int(gr_s.attribute('gr1')),
+                    int(gr_s.attribute('gr2')),
+                    int(gr_s.attribute('gr3')),
+                    int(gr_s.attribute('gr4')),
+                    int(gr_s.attribute('gr5')),
+                ],
+                'groove_double': [
+                    int(gr_d.attribute('gr1')),
+                    int(gr_d.attribute('gr2')),
+                    int(gr_d.attribute('gr3')),
+                    int(gr_d.attribute('gr4')),
+                    int(gr_d.attribute('gr5')),
+                ],
+            }
+
+        raise Exception('Unknown load type!')
+
+    def verify_game_load_m(self, ref_id: str) -> Dict[int, Dict[int, Dict[str, Any]]]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('all', '1')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('method', 'load_m')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        scores: Dict[int, Dict[int, Dict[str, Any]]] = {}
+        self.assert_path(resp, "response/game")
+        for child in resp.child('game').children:
+            self.assert_path(child, 'music/@reclink')
+            reclink = int(child.attribute('reclink'))
+
+            for typenode in child.children:
+                self.assert_path(typenode, 'type/@diff')
+                self.assert_path(typenode, 'type/score')
+                self.assert_path(typenode, 'type/count')
+                self.assert_path(typenode, 'type/rank')
+                self.assert_path(typenode, 'type/combo_type')
+                self.assert_path(typenode, 'type/score_2nd')
+                self.assert_path(typenode, 'type/rank_2nd')
+                self.assert_path(typenode, 'type/cnt_2nd')
+                chart = int(typenode.attribute('diff'))
+                vals = {
+                    'score': typenode.child_value('score'),
+                    'count': typenode.child_value('count'),
+                    'rank': typenode.child_value('rank'),
+                    'halo': typenode.child_value('combo_type'),
+                    'score_2nd': typenode.child_value('score_2nd'),
+                    'rank_2nd': typenode.child_value('rank_2nd'),
+                    'cnt_2nd': typenode.child_value('cnt_2nd'),
+                }
+                if reclink not in scores:
+                    scores[reclink] = {}
+                scores[reclink][chart] = vals
+        return scores
+
+    def verify_game_load_c(self, ref_id: str) -> Dict[int, Dict[int, Dict[str, Any]]]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load_c')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2012092400')
+
+        # Swap with server
+        resp = self.exchange('', call)
+        courses: Dict[int, Dict[int, Dict[str, Any]]] = {}
+        self.assert_path(resp, "response/game/course")
+        courseblob = resp.child_value('game/course')
+        index = 0
+        for chunk in [courseblob[i:(i + 8)] for i in range(0, len(courseblob), 8)]:
+            if any([v != 0 for v in chunk]):
+                course = int(index / 4)
+                chart = index % 4
+                vals = {
+                    'score': chunk[0] * 10000 + chunk[1],
+                    'combo': chunk[2],
+                    'rank': chunk[3],
+                    'stage': chunk[5],
+                    'combo_type': chunk[6],
+                }
+                if course not in courses:
+                    courses[course] = {}
+                courses[course][chart] = vals
+
+            index = index + 1
+        return courses
+
+    def verify_game_save(self, ref_id: str, style: int, gauge: Optional[List[int]]=None) -> None:
+        gauge = gauge or [0, 0, 0, 0, 0]
+
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('shop_area', '51')
+        last = Node.void('last')
+        game.add_child(last)
+        last.set_attribute('mode', '1')
+        last.set_attribute('style', str(style))
+        gr = Node.void('gr')
+        game.add_child(gr)
+        gr.set_attribute('gr1', str(gauge[0]))
+        gr.set_attribute('gr2', str(gauge[1]))
+        gr.set_attribute('gr3', str(gauge[2]))
+        gr.set_attribute('gr4', str(gauge[3]))
+        gr.set_attribute('gr5', str(gauge[4]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_score(self, ref_id: str, songid: int, chart: int) -> List[int]:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'score')
+        game.set_attribute('mid', str(songid))
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('type', str(chart))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@sc1")
+        self.assert_path(resp, "response/game/@sc2")
+        self.assert_path(resp, "response/game/@sc3")
+        self.assert_path(resp, "response/game/@sc4")
+        self.assert_path(resp, "response/game/@sc5")
+        return [
+            int(resp.child('game').attribute('sc1')),
+            int(resp.child('game').attribute('sc2')),
+            int(resp.child('game').attribute('sc3')),
+            int(resp.child('game').attribute('sc4')),
+            int(resp.child('game').attribute('sc5')),
+        ]
+
+    def verify_game_save_m(self, ref_id: str, score: Dict[str, Any]) -> None:
+        if score['score'] == 0 and score['score_2nd'] == 0:
+            raise Exception('Must store either 2ndMIX or regular score!')
+        if score['score'] != 0 and score['score_2nd'] != 0:
+            raise Exception('Must store either 2ndMIX or regular score!')
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', ref_id)
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('mtype', str(score['chart']))
+        game.set_attribute('mid', str(score['id']))
+        game.set_attribute('method', 'save_m')
+        data = Node.void('data')
+        game.add_child(data)
+        data.set_attribute('perf', '1' if score['halo'] >= 2 else '0')
+        data.set_attribute('score', str(score['score']))
+        data.set_attribute('rank', str(score['rank']))
+        data.set_attribute('phase', '1')
+        data.set_attribute('full', '1' if score['halo'] >= 1 else '0')
+        data.set_attribute('combo', str(score['combo']))
+        data.set_attribute('playmode', str(1 if score['score'] > 0 else 5))
+        data.set_attribute('rank_2nd', str(score['rank_2nd']))
+        data.set_attribute('score_2nd', str(score['score_2nd']))
+        data.set_attribute('combo_2nd', str(score['combo_2nd']))
+        option = Node.void('option')
+        game.add_child(option)
+        option.set_attribute('opt0', '6')
+        option.set_attribute('opt6', '1')
+        game.add_child(Node.u8_array('trace', [0] * 512))
+        game.add_child(Node.u32('size', 512))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_save_c(self, ref_id: str, course: Dict[str, Any]) -> None:
+        call = self.call_node()
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ctype', str(course['chart']))
+        game.set_attribute('cid', str(course['id']))
+        game.set_attribute('method', 'save_c')
+        game.set_attribute('ver', '2012092400')
+        game.set_attribute('refid', ref_id)
+        data = Node.void('data')
+        game.add_child(data)
+        data.set_attribute('combo_type', str(course['combo_type']))
+        data.set_attribute('clear', '1')
+        data.set_attribute('combo', str(course['combo']))
+        data.set_attribute('opt', '32774')
+        data.set_attribute('per', '995')
+        data.set_attribute('score', str(course['score']))
+        data.set_attribute('stage', str(course['stage']))
+        data.set_attribute('rank', str(course['rank']))
+        game.add_child(Node.u8_array('trace', [0] * 4096))
+        game.add_child(Node.u32('size', 4096))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get('EUC_JP')
+        self.verify_pcbevent_put()
+        self.verify_cardmng_getkeepspan()
+        self.verify_game_shop(location)
+        self.verify_game_common()
+        self.verify_game_hiscore()
+        self.verify_game_area_hiscore()
+        self.verify_game_message()
+        self.verify_game_ranking()
+        self.verify_game_log()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Bishi doesn't read a new profile, it just writes out CSV for a blank one
+            self.verify_game_load(ref_id, msg_type='new')
+            self.verify_game_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify locking and unlocking profile ability
+        self.verify_game_lock(ref_id, 1)
+        self.verify_game_lock(ref_id, 0)
+
+        if cardid is None:
+            # Verify empty profile
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 0:
+                raise Exception('Profile has plays on single already!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has plays on double already!')
+            if any([g != 0 for g in profile['groove_single']]):
+                raise Exception('Profile has single groove gauge values already!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has double groove gauge values already!')
+
+            # Verify empty scores
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Scores exist on new profile!')
+
+            # Verify empty courses
+            courses = self.verify_game_load_c(ref_id)
+            if len(courses) > 0:
+                raise Exception('Courses exist on new profile!')
+
+            self.verify_game_load_daily(ref_id)
+
+            # Verify profile saving
+            self.verify_game_save(ref_id, 0, [1, 2, 3, 4, 5])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 0:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if any([g != 0 for g in profile['groove_double']]):
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            self.verify_game_save(ref_id, 1, [5, 4, 3, 2, 1])
+            profile = self.verify_game_load(ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has invalid name associated with it!')
+            if profile['single_plays'] != 1:
+                raise Exception('Profile has invalid plays on single!')
+            if profile['double_plays'] != 1:
+                raise Exception('Profile has invalid plays on double!')
+            if profile['groove_single'] != [1, 2, 3, 4, 5]:
+                raise Exception('Profile has invalid single groove gauge values!')
+            if profile['groove_double'] != [5, 4, 3, 2, 1]:
+                raise Exception('Profile has invalid double groove gauge values!')
+
+            # Now, write some scores and verify saving
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 524,
+                            'chart': 3,
+                            'score': 800000,
+                            'combo': 123,
+                            'rank': 4,
+                            'halo': 1,
+                            'score_2nd': 0,
+                            'combo_2nd': 0,
+                            'rank_2nd': 0,
+                        },
+                        # A good score on an easier chart same song
+                        {
+                            'id': 524,
+                            'chart': 2,
+                            'score': 990000,
+                            'combo': 321,
+                            'rank': 2,
+                            'halo': 2,
+                            'score_2nd': 0,
+                            'combo_2nd': 0,
+                            'rank_2nd': 0,
+                        },
+                        # A perfect score
+                        {
+                            'id': 483,
+                            'chart': 3,
+                            'score': 1000000,
+                            'combo': 400,
+                            'rank': 1,
+                            'halo': 3,
+                            'score_2nd': 0,
+                            'combo_2nd': 0,
+                            'rank_2nd': 0,
+                        },
+                        # A bad score
+                        {
+                            'id': 483,
+                            'chart': 2,
+                            'score': 100000,
+                            'combo': 5,
+                            'rank': 7,
+                            'halo': 0,
+                            'score_2nd': 0,
+                            'combo_2nd': 0,
+                            'rank_2nd': 0,
+                        },
+                        # A score on 2ndMIX
+                        {
+                            'id': 483,
+                            'chart': 3,
+                            'score': 0,
+                            'combo': 0,
+                            'rank': 0,
+                            'halo': 0,
+                            'score_2nd': 21608500,
+                            'combo_2nd': 158,
+                            'rank_2nd': 0,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on a chart
+                        {
+                            'id': 524,
+                            'chart': 3,
+                            'score': 850000,
+                            'combo': 234,
+                            'rank': 3,
+                            'halo': 2,
+                            'score_2nd': 0,
+                            'combo_2nd': 0,
+                            'rank_2nd': 0,
+                        },
+                        # A worse score on another chart
+                        {
+                            'id': 524,
+                            'chart': 2,
+                            'score': 980000,
+                            'combo': 300,
+                            'rank': 3,
+                            'halo': 0,
+                            'expected_score': 990000,
+                            'expected_rank': 2,
+                            'expected_halo': 2,
+                            'score_2nd': 0,
+                            'combo_2nd': 0,
+                            'rank_2nd': 0,
+                        },
+                        # A worse score on 2ndMIX
+                        {
+                            'id': 483,
+                            'chart': 3,
+                            'score': 0,
+                            'combo': 0,
+                            'rank': 0,
+                            'halo': 0,
+                            'score_2nd': 11608500,
+                            'combo_2nd': 125,
+                            'rank_2nd': 1,
+                            'expected_score_2nd': 21608500,
+                            'expected_rank_2nd': 0,
+                        },
+                    ]
+
+                # Verify empty scores for starters
+                if phase == 1:
+                    for score in dummyscores:
+                        last_five = self.verify_game_score(ref_id, score['id'], score['chart'])
+                        if any([s != 0 for s in last_five]):
+                            raise Exception('Score already found on song not played yet!')
+                for score in dummyscores:
+                    self.verify_game_save_m(ref_id, score)
+                scores = self.verify_game_load_m(ref_id)
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    # Verify the attributes of the score
+                    expected_score = score.get('expected_score', score['score'])
+                    expected_rank = score.get('expected_rank', score['rank'])
+                    expected_halo = score.get('expected_halo', score['halo'])
+                    expected_score_2nd = score.get('expected_score_2nd', score['score_2nd'])
+                    expected_rank_2nd = score.get('expected_rank_2nd', score['rank_2nd'])
+
+                    if score['score'] != 0:
+                        if data['score'] != expected_score:
+                            raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                                expected_score, score['id'], score['chart'], data['score'],
+                            ))
+                        if data['rank'] != expected_rank:
+                            raise Exception('Expected a rank of \'{}\' for song \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                                expected_rank, score['id'], score['chart'], data['rank'],
+                            ))
+                        if data['halo'] != expected_halo:
+                            raise Exception('Expected a halo of \'{}\' for song \'{}\' chart \'{}\' but got halo \'{}\''.format(
+                                expected_halo, score['id'], score['chart'], data['halo'],
+                            ))
+
+                        # Verify that the last score is our score
+                        last_five = self.verify_game_score(ref_id, score['id'], score['chart'])
+                        if last_five[0] != score['score']:
+                            raise Exception('Invalid score returned for last five scores on song {} chart {}!'.format(score['id'], score['chart']))
+                    if score['score_2nd'] != 0:
+                        if data['score_2nd'] != expected_score_2nd:
+                            raise Exception('Expected a score_2nd of \'{}\' for song \'{}\' chart \'{}\' but got score_2nd \'{}\''.format(
+                                expected_score_2nd, score['id'], score['chart'], data['score_2nd'],
+                            ))
+                        if data['rank_2nd'] != expected_rank_2nd:
+                            raise Exception('Expected a rank_2nd of \'{}\' for song \'{}\' chart \'{}\' but got rank_2nd \'{}\''.format(
+                                expected_rank_2nd, score['id'], score['chart'], data['rank_2nd'],
+                            ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Now, write some courses and verify saving
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummycourses = [
+                        # An okay score on a course
+                        {
+                            'id': 5,
+                            'chart': 3,
+                            'score': 800000,
+                            'combo': 123,
+                            'rank': 4,
+                            'stage': 5,
+                            'combo_type': 1,
+                        },
+                        # A good score on a different coruse
+                        {
+                            'id': 7,
+                            'chart': 2,
+                            'score': 600000,
+                            'combo': 23,
+                            'rank': 5,
+                            'stage': 5,
+                            'combo_type': 0,
+                        },
+                    ]
+                if phase == 2:
+                    dummycourses = [
+                        # A better score on the same course
+                        {
+                            'id': 5,
+                            'chart': 3,
+                            'score': 900000,
+                            'combo': 234,
+                            'rank': 3,
+                            'stage': 5,
+                            'combo_type': 1,
+                        },
+                        # A worse score on a different same course
+                        {
+                            'id': 7,
+                            'chart': 2,
+                            'score': 500000,
+                            'combo': 12,
+                            'rank': 7,
+                            'stage': 4,
+                            'combo_type': 0,
+                            'expected_score': 600000,
+                            'expected_combo': 23,
+                            'expected_rank': 5,
+                            'expected_stage': 5,
+                        },
+                    ]
+
+                for course in dummycourses:
+                    self.verify_game_save_c(ref_id, course)
+                courses = self.verify_game_load_c(ref_id)
+                for course in dummycourses:
+                    data = courses.get(course['id'], {}).get(course['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get course back for course {} chart {}!'.format(course['id'], course['chart']))
+
+                    expected_score = course.get('expected_score', course['score'])
+                    expected_combo = course.get('expected_combo', course['combo'])
+                    expected_rank = course.get('expected_rank', course['rank'])
+                    expected_stage = course.get('expected_stage', course['stage'])
+                    expected_combo_type = course.get('expected_combo_type', course['combo_type'])
+
+                    if data['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for course \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, course['id'], course['chart'], data['score'],
+                        ))
+                    if data['combo'] != expected_combo:
+                        raise Exception('Expected a combo of \'{}\' for course \'{}\' chart \'{}\' but got combo \'{}\''.format(
+                            expected_combo, course['id'], course['chart'], data['combo'],
+                        ))
+                    if data['rank'] != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for course \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, course['id'], course['chart'], data['rank'],
+                        ))
+                    if data['stage'] != expected_stage:
+                        raise Exception('Expected a stage of \'{}\' for course \'{}\' chart \'{}\' but got stage \'{}\''.format(
+                            expected_stage, course['id'], course['chart'], data['stage'],
+                        ))
+                    if data['combo_type'] != expected_combo_type:
+                        raise Exception('Expected a combo_type of \'{}\' for course \'{}\' chart \'{}\' but got combo_type \'{}\''.format(
+                            expected_combo_type, course['id'], course['chart'], data['combo_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/iidx/__init__.py b/bemani/client/iidx/__init__.py
new file mode 100644
index 0000000..d54bb6a
--- /dev/null
+++ b/bemani/client/iidx/__init__.py
@@ -0,0 +1,5 @@
+from bemani.client.iidx.tricoro import IIDXTricoroClient
+from bemani.client.iidx.spada import IIDXSpadaClient
+from bemani.client.iidx.pendual import IIDXPendualClient
+from bemani.client.iidx.copula import IIDXCopulaClient
+from bemani.client.iidx.sinobuz import IIDXSinobuzClient
diff --git a/bemani/client/iidx/copula.py b/bemani/client/iidx/copula.py
new file mode 100644
index 0000000..59019f0
--- /dev/null
+++ b/bemani/client/iidx/copula.py
@@ -0,0 +1,906 @@
+import random
+import time
+from typing import Any, Dict, Optional, Tuple
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class IIDXCopulaClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_iidx23shop_getname(self, lid: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23shop = Node.void('IIDX23shop')
+        call.add_child(IIDX23shop)
+        IIDX23shop.set_attribute('method', 'getname')
+        IIDX23shop.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX23shop/@opname")
+        self.assert_path(resp, "response/IIDX23shop/@pid")
+        self.assert_path(resp, "response/IIDX23shop/@cls_opt")
+
+        return resp.child('IIDX23shop').attribute('opname')
+
+    def verify_iidx23shop_savename(self, lid: str, name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23shop = Node.void('IIDX23shop')
+        IIDX23shop.set_attribute('lid', lid)
+        IIDX23shop.set_attribute('pid', '51')
+        IIDX23shop.set_attribute('method', 'savename')
+        IIDX23shop.set_attribute('cls_opt', '0')
+        IIDX23shop.set_attribute('ccode', 'US')
+        IIDX23shop.set_attribute('opname', name)
+        IIDX23shop.set_attribute('rcode', '.')
+
+        call.add_child(IIDX23shop)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX23shop")
+
+    def verify_iidx23pc_common(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX23pc/ir/@beat")
+        self.assert_path(resp, "response/IIDX23pc/newsong_another/@open")
+        self.assert_path(resp, "response/IIDX23pc/boss/@phase")
+        self.assert_path(resp, "response/IIDX23pc/event1_phase/@phase")
+        self.assert_path(resp, "response/IIDX23pc/event2_phase/@phase")
+        self.assert_path(resp, "response/IIDX23pc/extra_boss_event/@phase")
+        self.assert_path(resp, "response/IIDX23pc/bemani_summer2016/@phase")
+        self.assert_path(resp, "response/IIDX23pc/expert/@phase")
+        self.assert_path(resp, "response/IIDX23pc/expert_random_select/@phase")
+
+    def verify_iidx23music_crate(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23music')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('method', 'crate')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/IIDX23music")
+        for child in resp.child("IIDX23music").children:
+            if child.name != 'c':
+                raise Exception('Invalid node {} in clear rate response!'.format(child))
+            if len(child.value) != 12:
+                raise Exception('Invalid node data {} in clear rate response!'.format(child))
+            for v in child.value:
+                if v < 0 or v > 101:
+                    raise Exception('Invalid clear percent {} in clear rate response!'.format(child))
+
+    def verify_iidx23shop_getconvention(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23shop')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('method', 'getconvention')
+        IIDX23pc.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX23shop/valid")
+        self.assert_path(resp, "response/IIDX23shop/@music_0")
+        self.assert_path(resp, "response/IIDX23shop/@music_1")
+        self.assert_path(resp, "response/IIDX23shop/@music_2")
+        self.assert_path(resp, "response/IIDX23shop/@music_3")
+
+    def verify_iidx23pc_visit(self, extid: int, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('iidxid', str(extid))
+        IIDX23pc.set_attribute('lid', lid)
+        IIDX23pc.set_attribute('method', 'visit')
+        IIDX23pc.set_attribute('pid', '51')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX23pc/@aflg")
+        self.assert_path(resp, "response/IIDX23pc/@anum")
+        self.assert_path(resp, "response/IIDX23pc/@pflg")
+        self.assert_path(resp, "response/IIDX23pc/@pnum")
+        self.assert_path(resp, "response/IIDX23pc/@sflg")
+        self.assert_path(resp, "response/IIDX23pc/@snum")
+
+    def verify_iidx23ranking_getranker(self, lid: str) -> None:
+        for clid in [0, 1, 2, 3, 4, 5, 6]:
+            call = self.call_node()
+
+            # Construct node
+            IIDX23pc = Node.void('IIDX23ranking')
+            call.add_child(IIDX23pc)
+            IIDX23pc.set_attribute('method', 'getranker')
+            IIDX23pc.set_attribute('lid', lid)
+            IIDX23pc.set_attribute('clid', str(clid))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            # Verify that response is correct
+            self.assert_path(resp, "response/IIDX23ranking")
+
+    def verify_iidx23shop_sentinfo(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23shop')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('method', 'sentinfo')
+        IIDX23pc.set_attribute('lid', lid)
+        IIDX23pc.set_attribute('bflg', '1')
+        IIDX23pc.set_attribute('bnum', '2')
+        IIDX23pc.set_attribute('ioid', '0')
+        IIDX23pc.set_attribute('tax_phase', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX23shop")
+
+    def verify_iidx23pc_get(self, ref_id: str, card_id: str, lid: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('rid', ref_id)
+        IIDX23pc.set_attribute('did', ref_id)
+        IIDX23pc.set_attribute('pid', '51')
+        IIDX23pc.set_attribute('lid', lid)
+        IIDX23pc.set_attribute('cid', card_id)
+        IIDX23pc.set_attribute('method', 'get')
+        IIDX23pc.set_attribute('ctype', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that the response is correct
+        self.assert_path(resp, "response/IIDX23pc/pcdata/@name")
+        self.assert_path(resp, "response/IIDX23pc/pcdata/@pid")
+        self.assert_path(resp, "response/IIDX23pc/pcdata/@id")
+        self.assert_path(resp, "response/IIDX23pc/pcdata/@idstr")
+        self.assert_path(resp, "response/IIDX23pc/deller")
+        self.assert_path(resp, "response/IIDX23pc/secret/flg1")
+        self.assert_path(resp, "response/IIDX23pc/secret/flg2")
+        self.assert_path(resp, "response/IIDX23pc/secret/flg3")
+        self.assert_path(resp, "response/IIDX23pc/achievements/trophy")
+        self.assert_path(resp, "response/IIDX23pc/skin")
+        self.assert_path(resp, "response/IIDX23pc/grade")
+        self.assert_path(resp, "response/IIDX23pc/ir_data")
+        self.assert_path(resp, "response/IIDX23pc/secret_course_data")
+        self.assert_path(resp, "response/IIDX23pc/rlist")
+        self.assert_path(resp, "response/IIDX23pc/step")
+        self.assert_path(resp, "response/IIDX23pc/favorite/sp_mlist")
+        self.assert_path(resp, "response/IIDX23pc/favorite/sp_clist")
+        self.assert_path(resp, "response/IIDX23pc/favorite/dp_mlist")
+        self.assert_path(resp, "response/IIDX23pc/favorite/dp_clist")
+
+        name = resp.child('IIDX23pc/pcdata').attribute('name')
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+        # Extract and return account data
+        ir_data: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for child in resp.child('IIDX23pc/ir_data').children:
+            if child.name == 'e':
+                course_id = child.value[0]
+                course_chart = child.value[1]
+                clear_status = child.value[2]
+                pgnum = child.value[3]
+                gnum = child.value[4]
+
+                if course_id not in ir_data:
+                    ir_data[course_id] = {}
+                ir_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        secret_course_data: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for child in resp.child('IIDX23pc/secret_course_data').children:
+            if child.name == 'e':
+                course_id = child.value[0]
+                course_chart = child.value[1]
+                clear_status = child.value[2]
+                pgnum = child.value[3]
+                gnum = child.value[4]
+
+                if course_id not in secret_course_data:
+                    secret_course_data[course_id] = {}
+                secret_course_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        expert_point: Dict[int, Dict[str, int]] = {}
+        for child in resp.child('IIDX23pc/expert_point').children:
+            if child.name == 'detail':
+                expert_point[int(child.attribute('course_id'))] = {
+                    'n_point': int(child.attribute('n_point')),
+                    'h_point': int(child.attribute('h_point')),
+                    'a_point': int(child.attribute('a_point')),
+                }
+
+        return {
+            'extid': int(resp.child('IIDX23pc/pcdata').attribute('id')),
+            'sp_dan': int(resp.child('IIDX23pc/grade').attribute('sgid')),
+            'dp_dan': int(resp.child('IIDX23pc/grade').attribute('dgid')),
+            'deller': int(resp.child('IIDX23pc/deller').attribute('deller')),
+            'ir_data': ir_data,
+            'secret_course_data': secret_course_data,
+            'expert_point': expert_point,
+        }
+
+    def verify_iidx23music_getrank(self, extid: int) -> Dict[int, Dict[int, Dict[str, int]]]:
+        scores: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for cltype in [0, 1]:  # singles, doubles
+            call = self.call_node()
+
+            # Construct node
+            IIDX23music = Node.void('IIDX23music')
+            call.add_child(IIDX23music)
+            IIDX23music.set_attribute('method', 'getrank')
+            IIDX23music.set_attribute('iidxid', str(extid))
+            IIDX23music.set_attribute('cltype', str(cltype))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            self.assert_path(resp, "response/IIDX23music/style")
+            if int(resp.child('IIDX23music/style').attribute('type')) != cltype:
+                raise Exception('Returned wrong clear type for IIDX23music.getrank!')
+
+            for child in resp.child('IIDX23music').children:
+                if child.name == 'm':
+                    if child.value[0] != -1:
+                        raise Exception('Got non-self score back when requesting only our scores!')
+
+                    music_id = child.value[1]
+                    normal_clear_status = child.value[2]
+                    hyper_clear_status = child.value[3]
+                    another_clear_status = child.value[4]
+                    normal_ex_score = child.value[5]
+                    hyper_ex_score = child.value[6]
+                    another_ex_score = child.value[7]
+                    normal_miss_count = child.value[8]
+                    hyper_miss_count = child.value[9]
+                    another_miss_count = child.value[10]
+
+                    if cltype == 0:
+                        normal = 0
+                        hyper = 1
+                        another = 2
+                    else:
+                        normal = 3
+                        hyper = 4
+                        another = 5
+
+                    if music_id not in scores:
+                        scores[music_id] = {}
+
+                    scores[music_id][normal] = {
+                        'clear_status': normal_clear_status,
+                        'ex_score': normal_ex_score,
+                        'miss_count': normal_miss_count,
+                    }
+                    scores[music_id][hyper] = {
+                        'clear_status': hyper_clear_status,
+                        'ex_score': hyper_ex_score,
+                        'miss_count': hyper_miss_count,
+                    }
+                    scores[music_id][another] = {
+                        'clear_status': another_clear_status,
+                        'ex_score': another_ex_score,
+                        'miss_count': another_miss_count,
+                    }
+                elif child.name == 'b':
+                    music_id = child.value[0]
+                    clear_status = child.value[1]
+
+                    scores[music_id][6] = {
+                        'clear_status': clear_status,
+                        'ex_score': -1,
+                        'miss_count': -1,
+                    }
+
+        return scores
+
+    def verify_iidx23pc_save(self, extid: int, card: str, lid: str, expert_point: Optional[Dict[str, int]]=None) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('s_disp_judge', '1')
+        IIDX23pc.set_attribute('mode', '6')
+        IIDX23pc.set_attribute('pmode', '0')
+        IIDX23pc.set_attribute('method', 'save')
+        IIDX23pc.set_attribute('s_sorttype', '0')
+        IIDX23pc.set_attribute('s_exscore', '0')
+        IIDX23pc.set_attribute('d_notes', '0.000000')
+        IIDX23pc.set_attribute('gpos', '0')
+        IIDX23pc.set_attribute('s_gno', '8')
+        IIDX23pc.set_attribute('s_hispeed', '5.771802')
+        IIDX23pc.set_attribute('s_judge', '0')
+        IIDX23pc.set_attribute('d_timing', '0')
+        IIDX23pc.set_attribute('rtype', '0')
+        IIDX23pc.set_attribute('d_largejudge', '0')
+        IIDX23pc.set_attribute('d_lift', '60')
+        IIDX23pc.set_attribute('s_pace', '0')
+        IIDX23pc.set_attribute('d_exscore', '0')
+        IIDX23pc.set_attribute('d_sdtype', '0')
+        IIDX23pc.set_attribute('s_opstyle', '1')
+        IIDX23pc.set_attribute('s_achi', '449')
+        IIDX23pc.set_attribute('s_largejudge', '0')
+        IIDX23pc.set_attribute('d_gno', '0')
+        IIDX23pc.set_attribute('s_lift', '60')
+        IIDX23pc.set_attribute('s_notes', '31.484070')
+        IIDX23pc.set_attribute('d_tune', '0')
+        IIDX23pc.set_attribute('d_sdlen', '0')
+        IIDX23pc.set_attribute('d_achi', '4')
+        IIDX23pc.set_attribute('d_opstyle', '0')
+        IIDX23pc.set_attribute('sp_opt', '8208')
+        IIDX23pc.set_attribute('iidxid', str(extid))
+        IIDX23pc.set_attribute('lid', lid)
+        IIDX23pc.set_attribute('s_judgeAdj', '0')
+        IIDX23pc.set_attribute('s_tune', '3')
+        IIDX23pc.set_attribute('s_sdtype', '1')
+        IIDX23pc.set_attribute('s_gtype', '2')
+        IIDX23pc.set_attribute('d_judge', '0')
+        IIDX23pc.set_attribute('cid', card)
+        IIDX23pc.set_attribute('cltype', '0')
+        IIDX23pc.set_attribute('ctype', '1')
+        IIDX23pc.set_attribute('bookkeep', '0')
+        IIDX23pc.set_attribute('d_hispeed', '0.000000')
+        IIDX23pc.set_attribute('d_pace', '0')
+        IIDX23pc.set_attribute('d_judgeAdj', '0')
+        IIDX23pc.set_attribute('s_timing', '1')
+        IIDX23pc.set_attribute('d_disp_judge', '0')
+        IIDX23pc.set_attribute('s_sdlen', '121')
+        IIDX23pc.set_attribute('dp_opt2', '0')
+        IIDX23pc.set_attribute('d_gtype', '0')
+        IIDX23pc.set_attribute('d_sorttype', '0')
+        IIDX23pc.set_attribute('dp_opt', '0')
+        pyramid = Node.void('pyramid')
+        IIDX23pc.add_child(pyramid)
+        pyramid.set_attribute('point', '290')
+        destiny_catharsis = Node.void('destiny_catharsis')
+        IIDX23pc.add_child(destiny_catharsis)
+        destiny_catharsis.set_attribute('point', '290')
+        bemani_summer_collabo = Node.void('bemani_summer_collabo')
+        IIDX23pc.add_child(bemani_summer_collabo)
+        bemani_summer_collabo.set_attribute('point', '290')
+        deller = Node.void('deller')
+        IIDX23pc.add_child(deller)
+        deller.set_attribute('deller', '150')
+
+        if expert_point is not None:
+            epnode = Node.void('expert_point')
+            epnode.set_attribute('h_point', str(expert_point['h_point']))
+            epnode.set_attribute('course_id', str(expert_point['course_id']))
+            epnode.set_attribute('n_point', str(expert_point['n_point']))
+            epnode.set_attribute('a_point', str(expert_point['a_point']))
+            IIDX23pc.add_child(epnode)
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX23pc")
+
+    def verify_iidx23music_reg(self, extid: int, lid: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23music = Node.void('IIDX23music')
+        call.add_child(IIDX23music)
+        IIDX23music.set_attribute('convid', '-1')
+        IIDX23music.set_attribute('iidxid', str(extid))
+        IIDX23music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX23music.set_attribute('pid', '51')
+        IIDX23music.set_attribute('rankside', '1')
+        IIDX23music.set_attribute('cflg', str(score['clear_status']))
+        IIDX23music.set_attribute('method', 'reg')
+        IIDX23music.set_attribute('gnum', str(score['gnum']))
+        IIDX23music.set_attribute('clid', str(score['chart']))
+        IIDX23music.set_attribute('mnum', str(score['mnum']))
+        IIDX23music.set_attribute('is_death', '0')
+        IIDX23music.set_attribute('theory', '0')
+        IIDX23music.set_attribute('shopconvid', lid)
+        IIDX23music.set_attribute('mid', str(score['id']))
+        IIDX23music.set_attribute('shopflg', '1')
+        IIDX23music.add_child(Node.binary('ghost', bytes([1] * 64)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX23music/shopdata/@rank")
+        self.assert_path(resp, "response/IIDX23music/ranklist/data")
+
+    def verify_iidx23music_appoint(self, extid: int, musicid: int, chart: int) -> Tuple[int, bytes]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23music = Node.void('IIDX23music')
+        call.add_child(IIDX23music)
+        IIDX23music.set_attribute('clid', str(chart))
+        IIDX23music.set_attribute('method', 'appoint')
+        IIDX23music.set_attribute('ctype', '0')
+        IIDX23music.set_attribute('iidxid', str(extid))
+        IIDX23music.set_attribute('subtype', '')
+        IIDX23music.set_attribute('mid', str(musicid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX23music/mydata/@score")
+
+        return (
+            int(resp.child('IIDX23music/mydata').attribute('score')),
+            resp.child_value('IIDX23music/mydata'),
+        )
+
+    def verify_iidx23pc_reg(self, ref_id: str, card_id: str, lid: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        call.add_child(IIDX23pc)
+        IIDX23pc.set_attribute('lid', lid)
+        IIDX23pc.set_attribute('pid', '51')
+        IIDX23pc.set_attribute('method', 'reg')
+        IIDX23pc.set_attribute('cid', card_id)
+        IIDX23pc.set_attribute('did', ref_id)
+        IIDX23pc.set_attribute('rid', ref_id)
+        IIDX23pc.set_attribute('name', self.NAME)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23pc/@id")
+        self.assert_path(resp, "response/IIDX23pc/@id_str")
+
+        return int(resp.child('IIDX23pc').attribute('id'))
+
+    def verify_iidx23pc_playstart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        IIDX23pc.set_attribute('method', 'playstart')
+        IIDX23pc.set_attribute('side', '1')
+        call.add_child(IIDX23pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23pc")
+
+    def verify_iidx23music_play(self, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23music = Node.void('IIDX23music')
+        IIDX23music.set_attribute('opt', '64')
+        IIDX23music.set_attribute('clid', str(score['chart']))
+        IIDX23music.set_attribute('mid', str(score['id']))
+        IIDX23music.set_attribute('gnum', str(score['gnum']))
+        IIDX23music.set_attribute('cflg', str(score['clear_status']))
+        IIDX23music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX23music.set_attribute('pid', '51')
+        IIDX23music.set_attribute('method', 'play')
+        call.add_child(IIDX23music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23music/@clid")
+        self.assert_path(resp, "response/IIDX23music/@crate")
+        self.assert_path(resp, "response/IIDX23music/@frate")
+        self.assert_path(resp, "response/IIDX23music/@mid")
+
+    def verify_iidx23pc_playend(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23pc = Node.void('IIDX23pc')
+        IIDX23pc.set_attribute('cltype', '0')
+        IIDX23pc.set_attribute('bookkeep', '0')
+        IIDX23pc.set_attribute('mode', '1')
+        IIDX23pc.set_attribute('method', 'playend')
+        call.add_child(IIDX23pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23pc")
+
+    def verify_iidx23music_breg(self, iidxid: int, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23music = Node.void('IIDX23music')
+        IIDX23music.set_attribute('gnum', str(score['gnum']))
+        IIDX23music.set_attribute('iidxid', str(iidxid))
+        IIDX23music.set_attribute('mid', str(score['id']))
+        IIDX23music.set_attribute('method', 'breg')
+        IIDX23music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX23music.set_attribute('cflg', str(score['clear_status']))
+        call.add_child(IIDX23music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23music")
+
+    def verify_iidx23grade_raised(self, iidxid: int, shop_name: str, dantype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23grade = Node.void('IIDX23grade')
+        IIDX23grade.set_attribute('opname', shop_name)
+        IIDX23grade.set_attribute('is_mirror', '0')
+        IIDX23grade.set_attribute('oppid', '51')
+        IIDX23grade.set_attribute('achi', '50')
+        IIDX23grade.set_attribute('cstage', '4')
+        IIDX23grade.set_attribute('gid', '5')
+        IIDX23grade.set_attribute('iidxid', str(iidxid))
+        IIDX23grade.set_attribute('gtype', '0' if dantype == 'sp' else '1')
+        IIDX23grade.set_attribute('is_ex', '0')
+        IIDX23grade.set_attribute('pside', '0')
+        IIDX23grade.set_attribute('method', 'raised')
+        call.add_child(IIDX23grade)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23grade/@pnum")
+
+    def verify_iidx23ranking_entry(self, iidxid: int, shop_name: str, coursetype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX23ranking = Node.void('IIDX23ranking')
+        IIDX23ranking.set_attribute('opname', shop_name)
+        IIDX23ranking.set_attribute('clr', '4')
+        IIDX23ranking.set_attribute('pgnum', '1771')
+        IIDX23ranking.set_attribute('coid', '2')
+        IIDX23ranking.set_attribute('method', 'entry')
+        IIDX23ranking.set_attribute('opt', '8208')
+        IIDX23ranking.set_attribute('opt2', '0')
+        IIDX23ranking.set_attribute('oppid', '51')
+        IIDX23ranking.set_attribute('cstage', '4')
+        IIDX23ranking.set_attribute('gnum', '967')
+        IIDX23ranking.set_attribute('pside', '1')
+        IIDX23ranking.set_attribute('clid', '1')
+        IIDX23ranking.set_attribute('regist_type', '0' if coursetype == 'ir' else '1')
+        IIDX23ranking.set_attribute('iidxid', str(iidxid))
+        call.add_child(IIDX23ranking)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX23ranking/@anum")
+        self.assert_path(resp, "response/IIDX23ranking/@jun")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_package_list()
+        self.verify_message_get()
+        lid = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_iidx23shop_getname(lid)
+        self.verify_iidx23pc_common()
+        self.verify_iidx23music_crate()
+        self.verify_iidx23shop_getconvention(lid)
+        self.verify_iidx23ranking_getranker(lid)
+        self.verify_iidx23shop_sentinfo(lid)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_iidx23pc_reg(ref_id, card, lid)
+            self.verify_iidx23pc_get(ref_id, card, lid)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            profile = self.verify_iidx23pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != -1:
+                raise Exception('Somehow has SP DAN ranking on new profile!')
+            if profile['dp_dan'] != -1:
+                raise Exception('Somehow has DP DAN ranking on new profile!')
+            if profile['deller'] != 0:
+                raise Exception('Somehow has deller on new profile!')
+            if len(profile['ir_data'].keys()) > 0:
+                raise Exception('Somehow has internet ranking data on new profile!')
+            if len(profile['secret_course_data'].keys()) > 0:
+                raise Exception('Somehow has secret course data on new profile!')
+            if len(profile['expert_point'].keys()) > 0:
+                raise Exception('Somehow has expert point data on new profile!')
+            scores = self.verify_iidx23music_getrank(profile['extid'])
+            if len(scores.keys()) > 0:
+                raise Exception('Somehow have scores on a new profile!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 7,
+                            'pgnum': 246,
+                            'gnum': 0,
+                            'mnum': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 1003,
+                            'chart': 2,
+                            'clear_status': 1,
+                            'pgnum': 10,
+                            'gnum': 20,
+                            'mnum': 50,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 1003,
+                            'chart': 0,
+                            'clear_status': 1,
+                            'pgnum': 2,
+                            'gnum': 5,
+                            'mnum': 75,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 5,
+                            'pgnum': 234,
+                            'gnum': 234,
+                            'mnum': 3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 35,
+                            'expected_clear_status': 7,
+                            'expected_ex_score': 492,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_iidx23music_reg(profile['extid'], lid, dummyscore)
+                self.verify_iidx23pc_visit(profile['extid'], lid)
+                self.verify_iidx23pc_save(profile['extid'], card, lid)
+                scores = self.verify_iidx23music_getrank(profile['extid'])
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    if 'expected_ex_score' in score:
+                        expected_score = score['expected_ex_score']
+                    else:
+                        expected_score = (score['pgnum'] * 2) + score['gnum']
+                    if 'expected_clear_status' in score:
+                        expected_clear_status = score['expected_clear_status']
+                    else:
+                        expected_clear_status = score['clear_status']
+                    if 'expected_miss_count' in score:
+                        expected_miss_count = score['expected_miss_count']
+                    else:
+                        expected_miss_count = score['mnum']
+
+                    if data['ex_score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+                    if data['clear_status'] != expected_clear_status:
+                        raise Exception('Expected a clear status of \'{}\' for song \'{}\' chart \'{}\' but got clear status \'{}\''.format(
+                            expected_clear_status, score['id'], score['chart'], data['clear_status'],
+                        ))
+                    if data['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, score['id'], score['chart'], data['miss_count'],
+                        ))
+
+                    # Verify we can fetch our own ghost
+                    ex_score, ghost = self.verify_iidx23music_appoint(profile['extid'], score['id'], score['chart'])
+                    if ex_score != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+
+                    if len(ghost) != 64:
+                        raise Exception('Wrong ghost length {} for ghost!'.format(len(ghost)))
+                    for g in ghost:
+                        if g != 0x01:
+                            raise Exception('Got back wrong ghost data for song \'{}\' chart \'{}\''.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Verify that we can save/load expert points
+            self.verify_iidx23pc_save(profile['extid'], card, lid, {'course_id': 1, 'n_point': 0, 'h_point': 500, 'a_point': 0})
+            profile = self.verify_iidx23pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 500, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            self.verify_iidx23pc_save(profile['extid'], card, lid, {'course_id': 1, 'n_point': 0, 'h_point': 1000, 'a_point': 0})
+            profile = self.verify_iidx23pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 1000, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            self.verify_iidx23pc_save(profile['extid'], card, lid, {'course_id': 2, 'n_point': 0, 'h_point': 0, 'a_point': 500})
+            profile = self.verify_iidx23pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1, 2]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 1000, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            if profile['expert_point'][2] != {'n_point': 0, 'h_point': 0, 'a_point': 500}:
+                raise Exception('Got back wrong expert points after saving!')
+
+            # Verify that a player without a card can play
+            self.verify_iidx23pc_playstart()
+            self.verify_iidx23music_play({
+                'id': 1000,
+                'chart': 2,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            self.verify_iidx23pc_playend()
+
+            # Verify shop name change setting
+            self.verify_iidx23shop_savename(lid, 'newname1')
+            newname = self.verify_iidx23shop_getname(lid)
+            if newname != 'newname1':
+                raise Exception('Invalid shop name returned after change!')
+            self.verify_iidx23shop_savename(lid, 'newname2')
+            newname = self.verify_iidx23shop_getname(lid)
+            if newname != 'newname2':
+                raise Exception('Invalid shop name returned after change!')
+
+            # Verify beginner score saving
+            self.verify_iidx23music_breg(profile['extid'], {
+                'id': 1000,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            scores = self.verify_iidx23music_getrank(profile['extid'])
+            if 1000 not in scores:
+                raise Exception('Didn\'t get expected scores back for song {} beginner chart!'.format(1000))
+            if 6 not in scores[1000]:
+                raise Exception('Didn\'t get beginner score back for song {}!'.format(1000))
+            if scores[1000][6] != {'clear_status': 4, 'ex_score': -1, 'miss_count': -1}:
+                raise Exception('Didn\'t get correct status back from beginner save!')
+
+            # Verify DAN score saving and loading
+            self.verify_iidx23grade_raised(profile['extid'], newname, 'sp')
+            self.verify_iidx23grade_raised(profile['extid'], newname, 'dp')
+            profile = self.verify_iidx23pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for SP!')
+            if profile['dp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for DP!')
+
+            # Verify secret course and internet ranking course saving
+            self.verify_iidx23ranking_entry(profile['extid'], newname, 'ir')
+            self.verify_iidx23ranking_entry(profile['extid'], newname, 'secret')
+            profile = self.verify_iidx23pc_get(ref_id, card, lid)
+            for ptype in ['ir_data', 'secret_course_data']:
+                if profile[ptype] != {2: {1: {'clear_status': 4, 'pgnum': 1771, 'gnum': 967}}}:
+                    raise Exception('Invalid data {} returned on profile load for {}!'.format(profile[ptype], ptype))
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/iidx/pendual.py b/bemani/client/iidx/pendual.py
new file mode 100644
index 0000000..dd41379
--- /dev/null
+++ b/bemani/client/iidx/pendual.py
@@ -0,0 +1,907 @@
+import random
+import time
+from typing import Any, Dict, Optional, Tuple
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class IIDXPendualClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_iidx22shop_getname(self, lid: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22shop = Node.void('IIDX22shop')
+        call.add_child(IIDX22shop)
+        IIDX22shop.set_attribute('method', 'getname')
+        IIDX22shop.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX22shop/@opname")
+        self.assert_path(resp, "response/IIDX22shop/@pid")
+        self.assert_path(resp, "response/IIDX22shop/@cls_opt")
+
+        return resp.child('IIDX22shop').attribute('opname')
+
+    def verify_iidx22shop_savename(self, lid: str, name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22shop = Node.void('IIDX22shop')
+        IIDX22shop.set_attribute('lid', lid)
+        IIDX22shop.set_attribute('pid', '51')
+        IIDX22shop.set_attribute('method', 'savename')
+        IIDX22shop.set_attribute('cls_opt', '0')
+        IIDX22shop.set_attribute('ccode', 'US')
+        IIDX22shop.set_attribute('opname', name)
+        IIDX22shop.set_attribute('rcode', '.')
+
+        call.add_child(IIDX22shop)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX22shop")
+
+    def verify_iidx22pc_common(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX22pc/ir/@beat")
+        self.assert_path(resp, "response/IIDX22pc/newsong_another/@open")
+        self.assert_path(resp, "response/IIDX22pc/limit/@phase")
+        self.assert_path(resp, "response/IIDX22pc/boss/@phase")
+        self.assert_path(resp, "response/IIDX22pc/chrono_diver/@phase")
+        self.assert_path(resp, "response/IIDX22pc/qpronicle_chord/@phase")
+        self.assert_path(resp, "response/IIDX22pc/common_cd_event/@open_list")
+        self.assert_path(resp, "response/IIDX22pc/pre_play/@phase")
+        self.assert_path(resp, "response/IIDX22pc/common_timeshift_phase/@phase")
+
+    def verify_iidx22music_crate(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22music')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('method', 'crate')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/IIDX22music")
+        for child in resp.child("IIDX22music").children:
+            if child.name != 'c':
+                raise Exception('Invalid node {} in clear rate response!'.format(child))
+            if len(child.value) != 12:
+                raise Exception('Invalid node data {} in clear rate response!'.format(child))
+            for v in child.value:
+                if v < 0 or v > 101:
+                    raise Exception('Invalid clear percent {} in clear rate response!'.format(child))
+
+    def verify_iidx22shop_getconvention(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22shop')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('method', 'getconvention')
+        IIDX22pc.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX22shop/valid")
+        self.assert_path(resp, "response/IIDX22shop/@music_0")
+        self.assert_path(resp, "response/IIDX22shop/@music_1")
+        self.assert_path(resp, "response/IIDX22shop/@music_2")
+        self.assert_path(resp, "response/IIDX22shop/@music_3")
+
+    def verify_iidx22pc_visit(self, extid: int, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('iidxid', str(extid))
+        IIDX22pc.set_attribute('lid', lid)
+        IIDX22pc.set_attribute('method', 'visit')
+        IIDX22pc.set_attribute('pid', '51')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX22pc/@aflg")
+        self.assert_path(resp, "response/IIDX22pc/@anum")
+        self.assert_path(resp, "response/IIDX22pc/@pflg")
+        self.assert_path(resp, "response/IIDX22pc/@pnum")
+        self.assert_path(resp, "response/IIDX22pc/@sflg")
+        self.assert_path(resp, "response/IIDX22pc/@snum")
+
+    def verify_iidx22ranking_getranker(self, lid: str) -> None:
+        for clid in [0, 1, 2, 3, 4, 5, 6]:
+            call = self.call_node()
+
+            # Construct node
+            IIDX22pc = Node.void('IIDX22ranking')
+            call.add_child(IIDX22pc)
+            IIDX22pc.set_attribute('method', 'getranker')
+            IIDX22pc.set_attribute('lid', lid)
+            IIDX22pc.set_attribute('clid', str(clid))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            # Verify that response is correct
+            self.assert_path(resp, "response/IIDX22ranking")
+
+    def verify_iidx22shop_sentinfo(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22shop')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('method', 'sentinfo')
+        IIDX22pc.set_attribute('lid', lid)
+        IIDX22pc.set_attribute('bflg', '1')
+        IIDX22pc.set_attribute('bnum', '2')
+        IIDX22pc.set_attribute('ioid', '0')
+        IIDX22pc.set_attribute('tax_phase', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX22shop")
+
+    def verify_iidx22pc_get(self, ref_id: str, card_id: str, lid: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('rid', ref_id)
+        IIDX22pc.set_attribute('did', ref_id)
+        IIDX22pc.set_attribute('pid', '51')
+        IIDX22pc.set_attribute('lid', lid)
+        IIDX22pc.set_attribute('cid', card_id)
+        IIDX22pc.set_attribute('method', 'get')
+        IIDX22pc.set_attribute('ctype', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that the response is correct
+        self.assert_path(resp, "response/IIDX22pc/pcdata/@name")
+        self.assert_path(resp, "response/IIDX22pc/pcdata/@pid")
+        self.assert_path(resp, "response/IIDX22pc/pcdata/@id")
+        self.assert_path(resp, "response/IIDX22pc/pcdata/@idstr")
+        self.assert_path(resp, "response/IIDX22pc/packinfo")
+        self.assert_path(resp, "response/IIDX22pc/deller")
+        self.assert_path(resp, "response/IIDX22pc/secret/flg1")
+        self.assert_path(resp, "response/IIDX22pc/secret/flg2")
+        self.assert_path(resp, "response/IIDX22pc/secret/flg3")
+        self.assert_path(resp, "response/IIDX22pc/achievements/trophy")
+        self.assert_path(resp, "response/IIDX22pc/skin")
+        self.assert_path(resp, "response/IIDX22pc/grade")
+        self.assert_path(resp, "response/IIDX22pc/ir_data")
+        self.assert_path(resp, "response/IIDX22pc/secret_course_data")
+        self.assert_path(resp, "response/IIDX22pc/rlist")
+        self.assert_path(resp, "response/IIDX22pc/step/album")
+        self.assert_path(resp, "response/IIDX22pc/favorite/sp_mlist")
+        self.assert_path(resp, "response/IIDX22pc/favorite/sp_clist")
+        self.assert_path(resp, "response/IIDX22pc/favorite/dp_mlist")
+        self.assert_path(resp, "response/IIDX22pc/favorite/dp_clist")
+
+        name = resp.child('IIDX22pc/pcdata').attribute('name')
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+        # Extract and return account data
+        ir_data: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for child in resp.child('IIDX22pc/ir_data').children:
+            if child.name == 'e':
+                course_id = child.value[0]
+                course_chart = child.value[1]
+                clear_status = child.value[2]
+                pgnum = child.value[3]
+                gnum = child.value[4]
+
+                if course_id not in ir_data:
+                    ir_data[course_id] = {}
+                ir_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        secret_course_data: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for child in resp.child('IIDX22pc/secret_course_data').children:
+            if child.name == 'e':
+                course_id = child.value[0]
+                course_chart = child.value[1]
+                clear_status = child.value[2]
+                pgnum = child.value[3]
+                gnum = child.value[4]
+
+                if course_id not in secret_course_data:
+                    secret_course_data[course_id] = {}
+                secret_course_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        expert_point: Dict[int, Dict[str, int]] = {}
+        for child in resp.child('IIDX22pc/expert_point').children:
+            if child.name == 'detail':
+                expert_point[int(child.attribute('course_id'))] = {
+                    'n_point': int(child.attribute('n_point')),
+                    'h_point': int(child.attribute('h_point')),
+                    'a_point': int(child.attribute('a_point')),
+                }
+
+        return {
+            'extid': int(resp.child('IIDX22pc/pcdata').attribute('id')),
+            'sp_dan': int(resp.child('IIDX22pc/grade').attribute('sgid')),
+            'dp_dan': int(resp.child('IIDX22pc/grade').attribute('dgid')),
+            'deller': int(resp.child('IIDX22pc/deller').attribute('deller')),
+            'ir_data': ir_data,
+            'secret_course_data': secret_course_data,
+            'expert_point': expert_point,
+        }
+
+    def verify_iidx22music_getrank(self, extid: int) -> Dict[int, Dict[int, Dict[str, int]]]:
+        scores: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for cltype in [0, 1]:  # singles, doubles
+            call = self.call_node()
+
+            # Construct node
+            IIDX22music = Node.void('IIDX22music')
+            call.add_child(IIDX22music)
+            IIDX22music.set_attribute('method', 'getrank')
+            IIDX22music.set_attribute('iidxid', str(extid))
+            IIDX22music.set_attribute('cltype', str(cltype))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            self.assert_path(resp, "response/IIDX22music/style")
+            if int(resp.child('IIDX22music/style').attribute('type')) != cltype:
+                raise Exception('Returned wrong clear type for IIDX22music.getrank!')
+
+            for child in resp.child('IIDX22music').children:
+                if child.name == 'm':
+                    if child.value[0] != -1:
+                        raise Exception('Got non-self score back when requesting only our scores!')
+
+                    music_id = child.value[1]
+                    normal_clear_status = child.value[2]
+                    hyper_clear_status = child.value[3]
+                    another_clear_status = child.value[4]
+                    normal_ex_score = child.value[5]
+                    hyper_ex_score = child.value[6]
+                    another_ex_score = child.value[7]
+                    normal_miss_count = child.value[8]
+                    hyper_miss_count = child.value[9]
+                    another_miss_count = child.value[10]
+
+                    if cltype == 0:
+                        normal = 0
+                        hyper = 1
+                        another = 2
+                    else:
+                        normal = 3
+                        hyper = 4
+                        another = 5
+
+                    if music_id not in scores:
+                        scores[music_id] = {}
+
+                    scores[music_id][normal] = {
+                        'clear_status': normal_clear_status,
+                        'ex_score': normal_ex_score,
+                        'miss_count': normal_miss_count,
+                    }
+                    scores[music_id][hyper] = {
+                        'clear_status': hyper_clear_status,
+                        'ex_score': hyper_ex_score,
+                        'miss_count': hyper_miss_count,
+                    }
+                    scores[music_id][another] = {
+                        'clear_status': another_clear_status,
+                        'ex_score': another_ex_score,
+                        'miss_count': another_miss_count,
+                    }
+                elif child.name == 'b':
+                    music_id = child.value[0]
+                    clear_status = child.value[1]
+
+                    scores[music_id][6] = {
+                        'clear_status': clear_status,
+                        'ex_score': -1,
+                        'miss_count': -1,
+                    }
+
+        return scores
+
+    def verify_iidx22pc_save(self, extid: int, card: str, lid: str, expert_point: Optional[Dict[str, int]]=None) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('s_disp_judge', '1')
+        IIDX22pc.set_attribute('mode', '6')
+        IIDX22pc.set_attribute('pmode', '0')
+        IIDX22pc.set_attribute('method', 'save')
+        IIDX22pc.set_attribute('s_sorttype', '0')
+        IIDX22pc.set_attribute('s_exscore', '0')
+        IIDX22pc.set_attribute('d_notes', '0.000000')
+        IIDX22pc.set_attribute('gpos', '0')
+        IIDX22pc.set_attribute('s_gno', '8')
+        IIDX22pc.set_attribute('s_hispeed', '5.771802')
+        IIDX22pc.set_attribute('s_judge', '0')
+        IIDX22pc.set_attribute('d_timing', '0')
+        IIDX22pc.set_attribute('rtype', '0')
+        IIDX22pc.set_attribute('d_largejudge', '0')
+        IIDX22pc.set_attribute('d_lift', '60')
+        IIDX22pc.set_attribute('s_pace', '0')
+        IIDX22pc.set_attribute('d_exscore', '0')
+        IIDX22pc.set_attribute('d_sdtype', '0')
+        IIDX22pc.set_attribute('s_opstyle', '1')
+        IIDX22pc.set_attribute('s_achi', '449')
+        IIDX22pc.set_attribute('s_largejudge', '0')
+        IIDX22pc.set_attribute('d_gno', '0')
+        IIDX22pc.set_attribute('s_lift', '60')
+        IIDX22pc.set_attribute('s_notes', '31.484070')
+        IIDX22pc.set_attribute('d_tune', '0')
+        IIDX22pc.set_attribute('d_sdlen', '0')
+        IIDX22pc.set_attribute('d_achi', '4')
+        IIDX22pc.set_attribute('d_opstyle', '0')
+        IIDX22pc.set_attribute('sp_opt', '8208')
+        IIDX22pc.set_attribute('iidxid', str(extid))
+        IIDX22pc.set_attribute('lid', lid)
+        IIDX22pc.set_attribute('s_judgeAdj', '0')
+        IIDX22pc.set_attribute('s_tune', '3')
+        IIDX22pc.set_attribute('s_sdtype', '1')
+        IIDX22pc.set_attribute('s_gtype', '2')
+        IIDX22pc.set_attribute('d_judge', '0')
+        IIDX22pc.set_attribute('cid', card)
+        IIDX22pc.set_attribute('cltype', '0')
+        IIDX22pc.set_attribute('ctype', '1')
+        IIDX22pc.set_attribute('bookkeep', '0')
+        IIDX22pc.set_attribute('d_hispeed', '0.000000')
+        IIDX22pc.set_attribute('d_pace', '0')
+        IIDX22pc.set_attribute('d_judgeAdj', '0')
+        IIDX22pc.set_attribute('s_timing', '1')
+        IIDX22pc.set_attribute('d_disp_judge', '0')
+        IIDX22pc.set_attribute('s_sdlen', '121')
+        IIDX22pc.set_attribute('dp_opt2', '0')
+        IIDX22pc.set_attribute('d_gtype', '0')
+        IIDX22pc.set_attribute('d_sorttype', '0')
+        IIDX22pc.set_attribute('dp_opt', '0')
+        pyramid = Node.void('pyramid')
+        IIDX22pc.add_child(pyramid)
+        pyramid.set_attribute('point', '290')
+        destiny_catharsis = Node.void('destiny_catharsis')
+        IIDX22pc.add_child(destiny_catharsis)
+        destiny_catharsis.set_attribute('point', '290')
+        bemani_summer_collabo = Node.void('bemani_summer_collabo')
+        IIDX22pc.add_child(bemani_summer_collabo)
+        bemani_summer_collabo.set_attribute('point', '290')
+        deller = Node.void('deller')
+        IIDX22pc.add_child(deller)
+        deller.set_attribute('deller', '150')
+
+        if expert_point is not None:
+            epnode = Node.void('expert_point')
+            epnode.set_attribute('h_point', str(expert_point['h_point']))
+            epnode.set_attribute('course_id', str(expert_point['course_id']))
+            epnode.set_attribute('n_point', str(expert_point['n_point']))
+            epnode.set_attribute('a_point', str(expert_point['a_point']))
+            IIDX22pc.add_child(epnode)
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX22pc")
+
+    def verify_iidx22music_reg(self, extid: int, lid: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22music = Node.void('IIDX22music')
+        call.add_child(IIDX22music)
+        IIDX22music.set_attribute('convid', '-1')
+        IIDX22music.set_attribute('iidxid', str(extid))
+        IIDX22music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX22music.set_attribute('pid', '51')
+        IIDX22music.set_attribute('rankside', '1')
+        IIDX22music.set_attribute('cflg', str(score['clear_status']))
+        IIDX22music.set_attribute('method', 'reg')
+        IIDX22music.set_attribute('gnum', str(score['gnum']))
+        IIDX22music.set_attribute('clid', str(score['chart']))
+        IIDX22music.set_attribute('mnum', str(score['mnum']))
+        IIDX22music.set_attribute('is_death', '0')
+        IIDX22music.set_attribute('theory', '0')
+        IIDX22music.set_attribute('shopconvid', lid)
+        IIDX22music.set_attribute('mid', str(score['id']))
+        IIDX22music.set_attribute('shopflg', '1')
+        IIDX22music.add_child(Node.binary('ghost', bytes([1] * 64)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX22music/shopdata/@rank")
+        self.assert_path(resp, "response/IIDX22music/ranklist/data")
+
+    def verify_iidx22music_appoint(self, extid: int, musicid: int, chart: int) -> Tuple[int, bytes]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22music = Node.void('IIDX22music')
+        call.add_child(IIDX22music)
+        IIDX22music.set_attribute('clid', str(chart))
+        IIDX22music.set_attribute('method', 'appoint')
+        IIDX22music.set_attribute('ctype', '0')
+        IIDX22music.set_attribute('iidxid', str(extid))
+        IIDX22music.set_attribute('subtype', '')
+        IIDX22music.set_attribute('mid', str(musicid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX22music/mydata/@score")
+
+        return (
+            int(resp.child('IIDX22music/mydata').attribute('score')),
+            resp.child_value('IIDX22music/mydata'),
+        )
+
+    def verify_iidx22pc_reg(self, ref_id: str, card_id: str, lid: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        call.add_child(IIDX22pc)
+        IIDX22pc.set_attribute('lid', lid)
+        IIDX22pc.set_attribute('pid', '51')
+        IIDX22pc.set_attribute('method', 'reg')
+        IIDX22pc.set_attribute('cid', card_id)
+        IIDX22pc.set_attribute('did', ref_id)
+        IIDX22pc.set_attribute('rid', ref_id)
+        IIDX22pc.set_attribute('name', self.NAME)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22pc/@id")
+        self.assert_path(resp, "response/IIDX22pc/@id_str")
+
+        return int(resp.child('IIDX22pc').attribute('id'))
+
+    def verify_iidx22pc_playstart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        IIDX22pc.set_attribute('method', 'playstart')
+        IIDX22pc.set_attribute('side', '1')
+        call.add_child(IIDX22pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22pc")
+
+    def verify_iidx22music_play(self, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22music = Node.void('IIDX22music')
+        IIDX22music.set_attribute('opt', '64')
+        IIDX22music.set_attribute('clid', str(score['chart']))
+        IIDX22music.set_attribute('mid', str(score['id']))
+        IIDX22music.set_attribute('gnum', str(score['gnum']))
+        IIDX22music.set_attribute('cflg', str(score['clear_status']))
+        IIDX22music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX22music.set_attribute('pid', '51')
+        IIDX22music.set_attribute('method', 'play')
+        call.add_child(IIDX22music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22music/@clid")
+        self.assert_path(resp, "response/IIDX22music/@crate")
+        self.assert_path(resp, "response/IIDX22music/@frate")
+        self.assert_path(resp, "response/IIDX22music/@mid")
+
+    def verify_iidx22pc_playend(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22pc = Node.void('IIDX22pc')
+        IIDX22pc.set_attribute('cltype', '0')
+        IIDX22pc.set_attribute('bookkeep', '0')
+        IIDX22pc.set_attribute('mode', '1')
+        IIDX22pc.set_attribute('method', 'playend')
+        call.add_child(IIDX22pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22pc")
+
+    def verify_iidx22music_breg(self, iidxid: int, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22music = Node.void('IIDX22music')
+        IIDX22music.set_attribute('gnum', str(score['gnum']))
+        IIDX22music.set_attribute('iidxid', str(iidxid))
+        IIDX22music.set_attribute('mid', str(score['id']))
+        IIDX22music.set_attribute('method', 'breg')
+        IIDX22music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX22music.set_attribute('cflg', str(score['clear_status']))
+        call.add_child(IIDX22music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22music")
+
+    def verify_iidx22grade_raised(self, iidxid: int, shop_name: str, dantype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22grade = Node.void('IIDX22grade')
+        IIDX22grade.set_attribute('opname', shop_name)
+        IIDX22grade.set_attribute('is_mirror', '0')
+        IIDX22grade.set_attribute('oppid', '51')
+        IIDX22grade.set_attribute('achi', '50')
+        IIDX22grade.set_attribute('cflg', '4' if dantype == 'sp' else '3')
+        IIDX22grade.set_attribute('gid', '5')
+        IIDX22grade.set_attribute('iidxid', str(iidxid))
+        IIDX22grade.set_attribute('gtype', '0' if dantype == 'sp' else '1')
+        IIDX22grade.set_attribute('is_ex', '0')
+        IIDX22grade.set_attribute('pside', '0')
+        IIDX22grade.set_attribute('method', 'raised')
+        call.add_child(IIDX22grade)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22grade/@pnum")
+
+    def verify_iidx22ranking_entry(self, iidxid: int, shop_name: str, coursetype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX22ranking = Node.void('IIDX22ranking')
+        IIDX22ranking.set_attribute('opname', shop_name)
+        IIDX22ranking.set_attribute('clr', '4')
+        IIDX22ranking.set_attribute('pgnum', '1771')
+        IIDX22ranking.set_attribute('coid', '2')
+        IIDX22ranking.set_attribute('method', 'entry')
+        IIDX22ranking.set_attribute('opt', '8208')
+        IIDX22ranking.set_attribute('opt2', '0')
+        IIDX22ranking.set_attribute('oppid', '51')
+        IIDX22ranking.set_attribute('cstage', '4')
+        IIDX22ranking.set_attribute('gnum', '967')
+        IIDX22ranking.set_attribute('pside', '1')
+        IIDX22ranking.set_attribute('clid', '1')
+        IIDX22ranking.set_attribute('regist_type', '0' if coursetype == 'ir' else '1')
+        IIDX22ranking.set_attribute('iidxid', str(iidxid))
+        call.add_child(IIDX22ranking)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX22ranking/@anum")
+        self.assert_path(resp, "response/IIDX22ranking/@jun")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_package_list()
+        self.verify_message_get()
+        lid = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_iidx22shop_getname(lid)
+        self.verify_iidx22pc_common()
+        self.verify_iidx22music_crate()
+        self.verify_iidx22shop_getconvention(lid)
+        self.verify_iidx22ranking_getranker(lid)
+        self.verify_iidx22shop_sentinfo(lid)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_iidx22pc_reg(ref_id, card, lid)
+            self.verify_iidx22pc_get(ref_id, card, lid)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            profile = self.verify_iidx22pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != -1:
+                raise Exception('Somehow has SP DAN ranking on new profile!')
+            if profile['dp_dan'] != -1:
+                raise Exception('Somehow has DP DAN ranking on new profile!')
+            if profile['deller'] != 0:
+                raise Exception('Somehow has deller on new profile!')
+            if len(profile['ir_data'].keys()) > 0:
+                raise Exception('Somehow has internet ranking data on new profile!')
+            if len(profile['secret_course_data'].keys()) > 0:
+                raise Exception('Somehow has secret course data on new profile!')
+            if len(profile['expert_point'].keys()) > 0:
+                raise Exception('Somehow has expert point data on new profile!')
+            scores = self.verify_iidx22music_getrank(profile['extid'])
+            if len(scores.keys()) > 0:
+                raise Exception('Somehow have scores on a new profile!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 7,
+                            'pgnum': 246,
+                            'gnum': 0,
+                            'mnum': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 1003,
+                            'chart': 2,
+                            'clear_status': 1,
+                            'pgnum': 10,
+                            'gnum': 20,
+                            'mnum': 50,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 1003,
+                            'chart': 0,
+                            'clear_status': 1,
+                            'pgnum': 2,
+                            'gnum': 5,
+                            'mnum': 75,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 5,
+                            'pgnum': 234,
+                            'gnum': 234,
+                            'mnum': 3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 35,
+                            'expected_clear_status': 7,
+                            'expected_ex_score': 492,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_iidx22music_reg(profile['extid'], lid, dummyscore)
+                self.verify_iidx22pc_visit(profile['extid'], lid)
+                self.verify_iidx22pc_save(profile['extid'], card, lid)
+                scores = self.verify_iidx22music_getrank(profile['extid'])
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    if 'expected_ex_score' in score:
+                        expected_score = score['expected_ex_score']
+                    else:
+                        expected_score = (score['pgnum'] * 2) + score['gnum']
+                    if 'expected_clear_status' in score:
+                        expected_clear_status = score['expected_clear_status']
+                    else:
+                        expected_clear_status = score['clear_status']
+                    if 'expected_miss_count' in score:
+                        expected_miss_count = score['expected_miss_count']
+                    else:
+                        expected_miss_count = score['mnum']
+
+                    if data['ex_score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+                    if data['clear_status'] != expected_clear_status:
+                        raise Exception('Expected a clear status of \'{}\' for song \'{}\' chart \'{}\' but got clear status \'{}\''.format(
+                            expected_clear_status, score['id'], score['chart'], data['clear_status'],
+                        ))
+                    if data['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, score['id'], score['chart'], data['miss_count'],
+                        ))
+
+                    # Verify we can fetch our own ghost
+                    ex_score, ghost = self.verify_iidx22music_appoint(profile['extid'], score['id'], score['chart'])
+                    if ex_score != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+
+                    if len(ghost) != 64:
+                        raise Exception('Wrong ghost length {} for ghost!'.format(len(ghost)))
+                    for g in ghost:
+                        if g != 0x01:
+                            raise Exception('Got back wrong ghost data for song \'{}\' chart \'{}\''.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Verify that we can save/load expert points
+            self.verify_iidx22pc_save(profile['extid'], card, lid, {'course_id': 1, 'n_point': 0, 'h_point': 500, 'a_point': 0})
+            profile = self.verify_iidx22pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 500, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            self.verify_iidx22pc_save(profile['extid'], card, lid, {'course_id': 1, 'n_point': 0, 'h_point': 1000, 'a_point': 0})
+            profile = self.verify_iidx22pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 1000, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            self.verify_iidx22pc_save(profile['extid'], card, lid, {'course_id': 2, 'n_point': 0, 'h_point': 0, 'a_point': 500})
+            profile = self.verify_iidx22pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1, 2]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 1000, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            if profile['expert_point'][2] != {'n_point': 0, 'h_point': 0, 'a_point': 500}:
+                raise Exception('Got back wrong expert points after saving!')
+
+            # Verify that a player without a card can play
+            self.verify_iidx22pc_playstart()
+            self.verify_iidx22music_play({
+                'id': 1000,
+                'chart': 2,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            self.verify_iidx22pc_playend()
+
+            # Verify shop name change setting
+            self.verify_iidx22shop_savename(lid, 'newname1')
+            newname = self.verify_iidx22shop_getname(lid)
+            if newname != 'newname1':
+                raise Exception('Invalid shop name returned after change!')
+            self.verify_iidx22shop_savename(lid, 'newname2')
+            newname = self.verify_iidx22shop_getname(lid)
+            if newname != 'newname2':
+                raise Exception('Invalid shop name returned after change!')
+
+            # Verify beginner score saving
+            self.verify_iidx22music_breg(profile['extid'], {
+                'id': 1000,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            scores = self.verify_iidx22music_getrank(profile['extid'])
+            if 1000 not in scores:
+                raise Exception('Didn\'t get expected scores back for song {} beginner chart!'.format(1000))
+            if 6 not in scores[1000]:
+                raise Exception('Didn\'t get beginner score back for song {}!'.format(1000))
+            if scores[1000][6] != {'clear_status': 4, 'ex_score': -1, 'miss_count': -1}:
+                raise Exception('Didn\'t get correct status back from beginner save!')
+
+            # Verify DAN score saving and loading
+            self.verify_iidx22grade_raised(profile['extid'], newname, 'sp')
+            self.verify_iidx22grade_raised(profile['extid'], newname, 'dp')
+            profile = self.verify_iidx22pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for SP!')
+            if profile['dp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for DP!')
+
+            # Verify secret course and internet ranking course saving
+            self.verify_iidx22ranking_entry(profile['extid'], newname, 'ir')
+            self.verify_iidx22ranking_entry(profile['extid'], newname, 'secret')
+            profile = self.verify_iidx22pc_get(ref_id, card, lid)
+            for ptype in ['ir_data', 'secret_course_data']:
+                if profile[ptype] != {2: {1: {'clear_status': 4, 'pgnum': 1771, 'gnum': 967}}}:
+                    raise Exception('Invalid data {} returned on profile load for {}!'.format(profile[ptype], ptype))
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/iidx/sinobuz.py b/bemani/client/iidx/sinobuz.py
new file mode 100644
index 0000000..6899034
--- /dev/null
+++ b/bemani/client/iidx/sinobuz.py
@@ -0,0 +1,955 @@
+import random
+import time
+from typing import Any, Dict, Optional, Tuple
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class IIDXSinobuzClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_iidx24shop_getname(self, lid: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24shop = Node.void('IIDX24shop')
+        call.add_child(IIDX24shop)
+        IIDX24shop.set_attribute('method', 'getname')
+        IIDX24shop.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX24shop/@opname")
+        self.assert_path(resp, "response/IIDX24shop/@pid")
+        self.assert_path(resp, "response/IIDX24shop/@cls_opt")
+        self.assert_path(resp, "response/IIDX24shop/@hr")
+        self.assert_path(resp, "response/IIDX24shop/@mi")
+
+        return resp.child('IIDX24shop').attribute('opname')
+
+    def verify_iidx24shop_savename(self, lid: str, name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24shop = Node.void('IIDX24shop')
+        IIDX24shop.set_attribute('lid', lid)
+        IIDX24shop.set_attribute('pid', '51')
+        IIDX24shop.set_attribute('method', 'savename')
+        IIDX24shop.set_attribute('cls_opt', '0')
+        IIDX24shop.set_attribute('ccode', 'US')
+        IIDX24shop.set_attribute('opname', name)
+        IIDX24shop.set_attribute('rcode', '.')
+
+        call.add_child(IIDX24shop)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX24shop")
+
+    def verify_iidx24pc_common(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX24pc/ir/@beat")
+        self.assert_path(resp, "response/IIDX24pc/newsong_another/@open")
+        self.assert_path(resp, "response/IIDX24pc/boss/@phase")
+        self.assert_path(resp, "response/IIDX24pc/event1_phase/@phase")
+        self.assert_path(resp, "response/IIDX24pc/event2_phase/@phase")
+        self.assert_path(resp, "response/IIDX24pc/extra_boss_event/@phase")
+        self.assert_path(resp, "response/IIDX24pc/expert/@phase")
+        self.assert_path(resp, "response/IIDX24pc/expert_random_select/@phase")
+        self.assert_path(resp, "response/IIDX24pc/common_evnet/@flg")
+
+    def verify_iidx24music_crate(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24music')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('method', 'crate')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/IIDX24music")
+        for child in resp.child("IIDX24music").children:
+            if child.name != 'c':
+                raise Exception('Invalid node {} in clear rate response!'.format(child))
+            if len(child.value) != 12:
+                raise Exception('Invalid node data {} in clear rate response!'.format(child))
+            for v in child.value:
+                if v < 0 or v > 1001:
+                    raise Exception('Invalid clear percent {} in clear rate response!'.format(child))
+
+    def verify_iidx24shop_getconvention(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24shop')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('method', 'getconvention')
+        IIDX24pc.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX24shop/valid")
+        self.assert_path(resp, "response/IIDX24shop/@music_0")
+        self.assert_path(resp, "response/IIDX24shop/@music_1")
+        self.assert_path(resp, "response/IIDX24shop/@music_2")
+        self.assert_path(resp, "response/IIDX24shop/@music_3")
+
+    def verify_iidx24pc_visit(self, extid: int, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('iidxid', str(extid))
+        IIDX24pc.set_attribute('lid', lid)
+        IIDX24pc.set_attribute('method', 'visit')
+        IIDX24pc.set_attribute('pid', '51')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX24pc/@aflg")
+        self.assert_path(resp, "response/IIDX24pc/@anum")
+        self.assert_path(resp, "response/IIDX24pc/@pflg")
+        self.assert_path(resp, "response/IIDX24pc/@pnum")
+        self.assert_path(resp, "response/IIDX24pc/@sflg")
+        self.assert_path(resp, "response/IIDX24pc/@snum")
+
+    def verify_iidx24ranking_getranker(self, lid: str) -> None:
+        for clid in [0, 1, 2, 3, 4, 5, 6]:
+            call = self.call_node()
+
+            # Construct node
+            IIDX24pc = Node.void('IIDX24ranking')
+            call.add_child(IIDX24pc)
+            IIDX24pc.set_attribute('method', 'getranker')
+            IIDX24pc.set_attribute('lid', lid)
+            IIDX24pc.set_attribute('clid', str(clid))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            # Verify that response is correct
+            self.assert_path(resp, "response/IIDX24ranking")
+
+    def verify_iidx24shop_sentinfo(self, lid: str, shop_name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24shop')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('method', 'sentinfo')
+        IIDX24pc.set_attribute('lid', lid)
+        IIDX24pc.set_attribute('bflg', '1')
+        IIDX24pc.set_attribute('bnum', '2')
+        IIDX24pc.set_attribute('ioid', '0')
+        IIDX24pc.set_attribute('company_code', '')
+        IIDX24pc.set_attribute('consumer_code', '')
+        IIDX24pc.set_attribute('location_name', shop_name)
+        IIDX24pc.set_attribute('tax_phase', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX24shop")
+
+    def verify_iidx24pc_get(self, ref_id: str, card_id: str, lid: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('rid', ref_id)
+        IIDX24pc.set_attribute('did', ref_id)
+        IIDX24pc.set_attribute('pid', '51')
+        IIDX24pc.set_attribute('lid', lid)
+        IIDX24pc.set_attribute('cid', card_id)
+        IIDX24pc.set_attribute('method', 'get')
+        IIDX24pc.set_attribute('ctype', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that the response is correct
+        self.assert_path(resp, "response/IIDX24pc/pcdata/@name")
+        self.assert_path(resp, "response/IIDX24pc/pcdata/@pid")
+        self.assert_path(resp, "response/IIDX24pc/pcdata/@id")
+        self.assert_path(resp, "response/IIDX24pc/pcdata/@idstr")
+        self.assert_path(resp, "response/IIDX24pc/deller")
+        self.assert_path(resp, "response/IIDX24pc/secret/flg1")
+        self.assert_path(resp, "response/IIDX24pc/secret/flg2")
+        self.assert_path(resp, "response/IIDX24pc/secret/flg3")
+        self.assert_path(resp, "response/IIDX24pc/achievements/trophy")
+        self.assert_path(resp, "response/IIDX24pc/skin")
+        self.assert_path(resp, "response/IIDX24pc/qprodata")
+        self.assert_path(resp, "response/IIDX24pc/grade")
+        self.assert_path(resp, "response/IIDX24pc/ir_data")
+        self.assert_path(resp, "response/IIDX24pc/secret_course_data")
+        self.assert_path(resp, "response/IIDX24pc/classic_course_data")
+        self.assert_path(resp, "response/IIDX24pc/rlist")
+        self.assert_path(resp, "response/IIDX24pc/step")
+        self.assert_path(resp, "response/IIDX24pc/favorite/sp_mlist")
+        self.assert_path(resp, "response/IIDX24pc/favorite/sp_clist")
+        self.assert_path(resp, "response/IIDX24pc/favorite/dp_mlist")
+        self.assert_path(resp, "response/IIDX24pc/favorite/dp_clist")
+        self.assert_path(resp, "response/IIDX24pc/extra_favorite/sp_mlist")
+        self.assert_path(resp, "response/IIDX24pc/extra_favorite/sp_clist")
+        self.assert_path(resp, "response/IIDX24pc/extra_favorite/dp_mlist")
+        self.assert_path(resp, "response/IIDX24pc/extra_favorite/dp_clist")
+
+        name = resp.child('IIDX24pc/pcdata').attribute('name')
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+        # Extract and return account data
+        ir_data: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for child in resp.child('IIDX24pc/ir_data').children:
+            if child.name == 'e':
+                course_id = child.value[0]
+                course_chart = child.value[1]
+                clear_status = child.value[2]
+                pgnum = child.value[3]
+                gnum = child.value[4]
+
+                if course_id not in ir_data:
+                    ir_data[course_id] = {}
+                ir_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        secret_course_data: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for child in resp.child('IIDX24pc/secret_course_data').children:
+            if child.name == 'e':
+                course_id = child.value[0]
+                course_chart = child.value[1]
+                clear_status = child.value[2]
+                pgnum = child.value[3]
+                gnum = child.value[4]
+
+                if course_id not in secret_course_data:
+                    secret_course_data[course_id] = {}
+                secret_course_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        classic_course_data: Dict[int, Dict[int, Dict[str, int]]] = {}  # noqa: E701
+        for child in resp.child('IIDX24pc/classic_course_data').children:
+            if child.name == 'score_data':
+                course_id = int(child.attribute('course_id'))
+                course_chart = int(child.attribute('play_style'))
+                clear_status = int(child.attribute('cflg'))
+                pgnum = int(child.attribute('pgnum'))
+                gnum = int(child.attribute('gnum'))
+
+                if course_id not in classic_course_data:
+                    classic_course_data[course_id] = {}
+                classic_course_data[course_id][course_chart] = {
+                    'clear_status': clear_status,
+                    'pgnum': pgnum,
+                    'gnum': gnum,
+                }
+
+        expert_point: Dict[int, Dict[str, int]] = {}
+        for child in resp.child('IIDX24pc/expert_point').children:
+            if child.name == 'detail':
+                expert_point[int(child.attribute('course_id'))] = {
+                    'n_point': int(child.attribute('n_point')),
+                    'h_point': int(child.attribute('h_point')),
+                    'a_point': int(child.attribute('a_point')),
+                }
+
+        return {
+            'extid': int(resp.child('IIDX24pc/pcdata').attribute('id')),
+            'sp_dan': int(resp.child('IIDX24pc/grade').attribute('sgid')),
+            'dp_dan': int(resp.child('IIDX24pc/grade').attribute('dgid')),
+            'deller': int(resp.child('IIDX24pc/deller').attribute('deller')),
+            'ir_data': ir_data,
+            'secret_course_data': secret_course_data,
+            'classic_course_data': classic_course_data,
+            'expert_point': expert_point,
+        }
+
+    def verify_iidx24music_getrank(self, extid: int) -> Dict[int, Dict[int, Dict[str, int]]]:
+        scores: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for cltype in [0, 1]:  # singles, doubles
+            call = self.call_node()
+
+            # Construct node
+            IIDX24music = Node.void('IIDX24music')
+            call.add_child(IIDX24music)
+            IIDX24music.set_attribute('method', 'getrank')
+            IIDX24music.set_attribute('iidxid', str(extid))
+            IIDX24music.set_attribute('cltype', str(cltype))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            self.assert_path(resp, "response/IIDX24music/style")
+            if int(resp.child('IIDX24music/style').attribute('type')) != cltype:
+                raise Exception('Returned wrong clear type for IIDX24music.getrank!')
+
+            for child in resp.child('IIDX24music').children:
+                if child.name == 'm':
+                    if child.value[0] != -1:
+                        raise Exception('Got non-self score back when requesting only our scores!')
+
+                    music_id = child.value[1]
+                    normal_clear_status = child.value[2]
+                    hyper_clear_status = child.value[3]
+                    another_clear_status = child.value[4]
+                    normal_ex_score = child.value[5]
+                    hyper_ex_score = child.value[6]
+                    another_ex_score = child.value[7]
+                    normal_miss_count = child.value[8]
+                    hyper_miss_count = child.value[9]
+                    another_miss_count = child.value[10]
+
+                    if cltype == 0:
+                        normal = 0
+                        hyper = 1
+                        another = 2
+                    else:
+                        normal = 3
+                        hyper = 4
+                        another = 5
+
+                    if music_id not in scores:
+                        scores[music_id] = {}
+
+                    scores[music_id][normal] = {
+                        'clear_status': normal_clear_status,
+                        'ex_score': normal_ex_score,
+                        'miss_count': normal_miss_count,
+                    }
+                    scores[music_id][hyper] = {
+                        'clear_status': hyper_clear_status,
+                        'ex_score': hyper_ex_score,
+                        'miss_count': hyper_miss_count,
+                    }
+                    scores[music_id][another] = {
+                        'clear_status': another_clear_status,
+                        'ex_score': another_ex_score,
+                        'miss_count': another_miss_count,
+                    }
+                elif child.name == 'b':
+                    music_id = child.value[0]
+                    clear_status = child.value[1]
+
+                    scores[music_id][6] = {
+                        'clear_status': clear_status,
+                        'ex_score': -1,
+                        'miss_count': -1,
+                    }
+
+        return scores
+
+    def verify_iidx24pc_save(self, extid: int, card: str, lid: str, expert_point: Optional[Dict[str, int]]=None) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('s_disp_judge', '1')
+        IIDX24pc.set_attribute('mode', '6')
+        IIDX24pc.set_attribute('pmode', '0')
+        IIDX24pc.set_attribute('method', 'save')
+        IIDX24pc.set_attribute('s_sorttype', '0')
+        IIDX24pc.set_attribute('s_exscore', '0')
+        IIDX24pc.set_attribute('d_notes', '0.000000')
+        IIDX24pc.set_attribute('gpos', '0')
+        IIDX24pc.set_attribute('s_gno', '8')
+        IIDX24pc.set_attribute('s_hispeed', '5.771802')
+        IIDX24pc.set_attribute('s_judge', '0')
+        IIDX24pc.set_attribute('d_timing', '0')
+        IIDX24pc.set_attribute('rtype', '0')
+        IIDX24pc.set_attribute('d_graph_score', '0')
+        IIDX24pc.set_attribute('d_lift', '60')
+        IIDX24pc.set_attribute('s_pace', '0')
+        IIDX24pc.set_attribute('d_exscore', '0')
+        IIDX24pc.set_attribute('d_sdtype', '0')
+        IIDX24pc.set_attribute('s_opstyle', '1')
+        IIDX24pc.set_attribute('s_achi', '449')
+        IIDX24pc.set_attribute('s_graph_score', '0')
+        IIDX24pc.set_attribute('d_gno', '0')
+        IIDX24pc.set_attribute('s_lift', '60')
+        IIDX24pc.set_attribute('s_notes', '31.484070')
+        IIDX24pc.set_attribute('d_tune', '0')
+        IIDX24pc.set_attribute('d_sdlen', '0')
+        IIDX24pc.set_attribute('d_achi', '4')
+        IIDX24pc.set_attribute('d_opstyle', '0')
+        IIDX24pc.set_attribute('sp_opt', '8208')
+        IIDX24pc.set_attribute('iidxid', str(extid))
+        IIDX24pc.set_attribute('lid', lid)
+        IIDX24pc.set_attribute('s_judgeAdj', '0')
+        IIDX24pc.set_attribute('s_tune', '3')
+        IIDX24pc.set_attribute('s_sdtype', '1')
+        IIDX24pc.set_attribute('s_gtype', '2')
+        IIDX24pc.set_attribute('d_judge', '0')
+        IIDX24pc.set_attribute('cid', card)
+        IIDX24pc.set_attribute('cltype', '0')
+        IIDX24pc.set_attribute('ctype', '1')
+        IIDX24pc.set_attribute('bookkeep', '0')
+        IIDX24pc.set_attribute('d_hispeed', '0.000000')
+        IIDX24pc.set_attribute('d_pace', '0')
+        IIDX24pc.set_attribute('d_judgeAdj', '0')
+        IIDX24pc.set_attribute('s_timing', '1')
+        IIDX24pc.set_attribute('d_disp_judge', '0')
+        IIDX24pc.set_attribute('s_sdlen', '121')
+        IIDX24pc.set_attribute('dp_opt2', '0')
+        IIDX24pc.set_attribute('d_gtype', '0')
+        IIDX24pc.set_attribute('d_sorttype', '0')
+        IIDX24pc.set_attribute('dp_opt', '0')
+        deller = Node.void('deller')
+        IIDX24pc.add_child(deller)
+        deller.set_attribute('deller', '150')
+
+        if expert_point is not None:
+            epnode = Node.void('expert_point')
+            epnode.set_attribute('h_point', str(expert_point['h_point']))
+            epnode.set_attribute('course_id', str(expert_point['course_id']))
+            epnode.set_attribute('n_point', str(expert_point['n_point']))
+            epnode.set_attribute('a_point', str(expert_point['a_point']))
+            IIDX24pc.add_child(epnode)
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX24pc")
+
+    def verify_iidx24music_reg(self, extid: int, lid: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24music = Node.void('IIDX24music')
+        call.add_child(IIDX24music)
+        IIDX24music.set_attribute('convid', '-1')
+        IIDX24music.set_attribute('iidxid', str(extid))
+        IIDX24music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX24music.set_attribute('pid', '51')
+        IIDX24music.set_attribute('rankside', '1')
+        IIDX24music.set_attribute('cflg', str(score['clear_status']))
+        IIDX24music.set_attribute('method', 'reg')
+        IIDX24music.set_attribute('gnum', str(score['gnum']))
+        IIDX24music.set_attribute('clid', str(score['chart']))
+        IIDX24music.set_attribute('mnum', str(score['mnum']))
+        IIDX24music.set_attribute('is_death', '0')
+        IIDX24music.set_attribute('theory', '0')
+        IIDX24music.set_attribute('dj_level', '1')
+        IIDX24music.set_attribute('shopconvid', lid)
+        IIDX24music.set_attribute('mid', str(score['id']))
+        IIDX24music.set_attribute('shopflg', '1')
+        IIDX24music.add_child(Node.binary('ghost', bytes([1] * 64)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX24music/shopdata/@rank")
+        self.assert_path(resp, "response/IIDX24music/ranklist/data")
+
+    def verify_iidx24music_appoint(self, extid: int, musicid: int, chart: int) -> Tuple[int, bytes]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24music = Node.void('IIDX24music')
+        call.add_child(IIDX24music)
+        IIDX24music.set_attribute('clid', str(chart))
+        IIDX24music.set_attribute('method', 'appoint')
+        IIDX24music.set_attribute('ctype', '0')
+        IIDX24music.set_attribute('iidxid', str(extid))
+        IIDX24music.set_attribute('subtype', '')
+        IIDX24music.set_attribute('mid', str(musicid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX24music/mydata/@score")
+
+        return (
+            int(resp.child('IIDX24music/mydata').attribute('score')),
+            resp.child_value('IIDX24music/mydata'),
+        )
+
+    def verify_iidx24pc_reg(self, ref_id: str, card_id: str, lid: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        call.add_child(IIDX24pc)
+        IIDX24pc.set_attribute('lid', lid)
+        IIDX24pc.set_attribute('pid', '51')
+        IIDX24pc.set_attribute('method', 'reg')
+        IIDX24pc.set_attribute('cid', card_id)
+        IIDX24pc.set_attribute('did', ref_id)
+        IIDX24pc.set_attribute('rid', ref_id)
+        IIDX24pc.set_attribute('name', self.NAME)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24pc/@id")
+        self.assert_path(resp, "response/IIDX24pc/@id_str")
+
+        return int(resp.child('IIDX24pc').attribute('id'))
+
+    def verify_iidx24pc_playstart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        IIDX24pc.set_attribute('method', 'playstart')
+        IIDX24pc.set_attribute('side', '1')
+        call.add_child(IIDX24pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24pc")
+
+    def verify_iidx24music_play(self, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24music = Node.void('IIDX24music')
+        IIDX24music.set_attribute('opt', '64')
+        IIDX24music.set_attribute('clid', str(score['chart']))
+        IIDX24music.set_attribute('mid', str(score['id']))
+        IIDX24music.set_attribute('gnum', str(score['gnum']))
+        IIDX24music.set_attribute('cflg', str(score['clear_status']))
+        IIDX24music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX24music.set_attribute('pid', '51')
+        IIDX24music.set_attribute('method', 'play')
+        call.add_child(IIDX24music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24music/@clid")
+        self.assert_path(resp, "response/IIDX24music/@crate")
+        self.assert_path(resp, "response/IIDX24music/@frate")
+        self.assert_path(resp, "response/IIDX24music/@mid")
+
+    def verify_iidx24pc_playend(self, lid: str, shop_name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24pc = Node.void('IIDX24pc')
+        IIDX24pc.set_attribute('cltype', '0')
+        IIDX24pc.set_attribute('bookkeep', '0')
+        IIDX24pc.set_attribute('mode', '1')
+        IIDX24pc.set_attribute('pay_coin', '1')
+        IIDX24pc.set_attribute('method', 'playend')
+        IIDX24pc.set_attribute('company_code', '')
+        IIDX24pc.set_attribute('consumer_code', '')
+        IIDX24pc.set_attribute('location_name', shop_name)
+        IIDX24pc.set_attribute('lid', lid)
+        call.add_child(IIDX24pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24pc")
+
+    def verify_iidx24music_breg(self, iidxid: int, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24music = Node.void('IIDX24music')
+        IIDX24music.set_attribute('gnum', str(score['gnum']))
+        IIDX24music.set_attribute('iidxid', str(iidxid))
+        IIDX24music.set_attribute('mid', str(score['id']))
+        IIDX24music.set_attribute('method', 'breg')
+        IIDX24music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX24music.set_attribute('cflg', str(score['clear_status']))
+        call.add_child(IIDX24music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24music")
+
+    def verify_iidx24grade_raised(self, iidxid: int, shop_name: str, dantype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24grade = Node.void('IIDX24grade')
+        IIDX24grade.set_attribute('opname', shop_name)
+        IIDX24grade.set_attribute('is_mirror', '0')
+        IIDX24grade.set_attribute('oppid', '51')
+        IIDX24grade.set_attribute('achi', '50')
+        IIDX24grade.set_attribute('cstage', '4')
+        IIDX24grade.set_attribute('gid', '5')
+        IIDX24grade.set_attribute('iidxid', str(iidxid))
+        IIDX24grade.set_attribute('gtype', '0' if dantype == 'sp' else '1')
+        IIDX24grade.set_attribute('is_ex', '0')
+        IIDX24grade.set_attribute('pside', '0')
+        IIDX24grade.set_attribute('method', 'raised')
+        call.add_child(IIDX24grade)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24grade/@pnum")
+
+    def verify_iidx24ranking_entry(self, iidxid: int, shop_name: str, coursetype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24ranking = Node.void('IIDX24ranking')
+        IIDX24ranking.set_attribute('opname', shop_name)
+        IIDX24ranking.set_attribute('clr', '4')
+        IIDX24ranking.set_attribute('pgnum', '1771')
+        IIDX24ranking.set_attribute('coid', '2')
+        IIDX24ranking.set_attribute('method', 'entry')
+        IIDX24ranking.set_attribute('opt', '8208')
+        IIDX24ranking.set_attribute('opt2', '0')
+        IIDX24ranking.set_attribute('oppid', '51')
+        IIDX24ranking.set_attribute('cstage', '4')
+        IIDX24ranking.set_attribute('gnum', '967')
+        IIDX24ranking.set_attribute('pside', '1')
+        IIDX24ranking.set_attribute('clid', '1')
+        IIDX24ranking.set_attribute('regist_type', '0' if coursetype == 'ir' else '1')
+        IIDX24ranking.set_attribute('iidxid', str(iidxid))
+        call.add_child(IIDX24ranking)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24ranking/@anum")
+        self.assert_path(resp, "response/IIDX24ranking/@jun")
+
+    def verify_iidx24ranking_classicentry(self, iidxid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX24ranking = Node.void('IIDX24ranking')
+        IIDX24ranking.set_attribute('clear_stage', '4')
+        IIDX24ranking.set_attribute('clear_flg', '4')
+        IIDX24ranking.set_attribute('course_id', '2')
+        IIDX24ranking.set_attribute('score', '4509')
+        IIDX24ranking.set_attribute('gnum', '967')
+        IIDX24ranking.set_attribute('iidx_id', str(iidxid))
+        IIDX24ranking.set_attribute('method', 'classicentry')
+        IIDX24ranking.set_attribute('pgnum', '1771')
+        IIDX24ranking.set_attribute('play_style', '1')
+        call.add_child(IIDX24ranking)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX24ranking/@status")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_package_list()
+        self.verify_message_get()
+        lid = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_iidx24shop_getname(lid)
+        self.verify_iidx24pc_common()
+        self.verify_iidx24music_crate()
+        self.verify_iidx24shop_getconvention(lid)
+        self.verify_iidx24ranking_getranker(lid)
+        self.verify_iidx24shop_sentinfo(lid, 'newname1')
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_iidx24pc_reg(ref_id, card, lid)
+            self.verify_iidx24pc_get(ref_id, card, lid)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            profile = self.verify_iidx24pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != -1:
+                raise Exception('Somehow has SP DAN ranking on new profile!')
+            if profile['dp_dan'] != -1:
+                raise Exception('Somehow has DP DAN ranking on new profile!')
+            if profile['deller'] != 0:
+                raise Exception('Somehow has deller on new profile!')
+            if len(profile['ir_data'].keys()) > 0:
+                raise Exception('Somehow has internet ranking data on new profile!')
+            if len(profile['secret_course_data'].keys()) > 0:
+                raise Exception('Somehow has secret course data on new profile!')
+            if len(profile['expert_point'].keys()) > 0:
+                raise Exception('Somehow has expert point data on new profile!')
+            scores = self.verify_iidx24music_getrank(profile['extid'])
+            if len(scores.keys()) > 0:
+                raise Exception('Somehow have scores on a new profile!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 7,
+                            'pgnum': 246,
+                            'gnum': 0,
+                            'mnum': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 1003,
+                            'chart': 2,
+                            'clear_status': 1,
+                            'pgnum': 10,
+                            'gnum': 20,
+                            'mnum': 50,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 1003,
+                            'chart': 0,
+                            'clear_status': 1,
+                            'pgnum': 2,
+                            'gnum': 5,
+                            'mnum': 75,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 5,
+                            'pgnum': 234,
+                            'gnum': 234,
+                            'mnum': 3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 35,
+                            'expected_clear_status': 7,
+                            'expected_ex_score': 492,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_iidx24music_reg(profile['extid'], lid, dummyscore)
+                self.verify_iidx24pc_visit(profile['extid'], lid)
+                self.verify_iidx24pc_save(profile['extid'], card, lid)
+                scores = self.verify_iidx24music_getrank(profile['extid'])
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    if 'expected_ex_score' in score:
+                        expected_score = score['expected_ex_score']
+                    else:
+                        expected_score = (score['pgnum'] * 2) + score['gnum']
+                    if 'expected_clear_status' in score:
+                        expected_clear_status = score['expected_clear_status']
+                    else:
+                        expected_clear_status = score['clear_status']
+                    if 'expected_miss_count' in score:
+                        expected_miss_count = score['expected_miss_count']
+                    else:
+                        expected_miss_count = score['mnum']
+
+                    if data['ex_score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+                    if data['clear_status'] != expected_clear_status:
+                        raise Exception('Expected a clear status of \'{}\' for song \'{}\' chart \'{}\' but got clear status \'{}\''.format(
+                            expected_clear_status, score['id'], score['chart'], data['clear_status'],
+                        ))
+                    if data['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, score['id'], score['chart'], data['miss_count'],
+                        ))
+
+                    # Verify we can fetch our own ghost
+                    ex_score, ghost = self.verify_iidx24music_appoint(profile['extid'], score['id'], score['chart'])
+                    if ex_score != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+
+                    if len(ghost) != 64:
+                        raise Exception('Wrong ghost length {} for ghost!'.format(len(ghost)))
+                    for g in ghost:
+                        if g != 0x01:
+                            raise Exception('Got back wrong ghost data for song \'{}\' chart \'{}\''.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Verify that we can save/load expert points
+            self.verify_iidx24pc_save(profile['extid'], card, lid, {'course_id': 1, 'n_point': 0, 'h_point': 500, 'a_point': 0})
+            profile = self.verify_iidx24pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 500, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            self.verify_iidx24pc_save(profile['extid'], card, lid, {'course_id': 1, 'n_point': 0, 'h_point': 1000, 'a_point': 0})
+            profile = self.verify_iidx24pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 1000, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            self.verify_iidx24pc_save(profile['extid'], card, lid, {'course_id': 2, 'n_point': 0, 'h_point': 0, 'a_point': 500})
+            profile = self.verify_iidx24pc_get(ref_id, card, lid)
+            if sorted(profile['expert_point'].keys()) != [1, 2]:
+                raise Exception('Got back wrong number of expert course points!')
+            if profile['expert_point'][1] != {'n_point': 0, 'h_point': 1000, 'a_point': 0}:
+                raise Exception('Got back wrong expert points after saving!')
+            if profile['expert_point'][2] != {'n_point': 0, 'h_point': 0, 'a_point': 500}:
+                raise Exception('Got back wrong expert points after saving!')
+
+            # Verify that a player without a card can play
+            self.verify_iidx24pc_playstart()
+            self.verify_iidx24music_play({
+                'id': 1000,
+                'chart': 2,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            self.verify_iidx24pc_playend(lid, 'newname1')
+
+            # Verify shop name change setting
+            self.verify_iidx24shop_savename(lid, 'newname1')
+            newname = self.verify_iidx24shop_getname(lid)
+            if newname != 'newname1':
+                raise Exception('Invalid shop name returned after change!')
+            self.verify_iidx24shop_savename(lid, 'newname2')
+            newname = self.verify_iidx24shop_getname(lid)
+            if newname != 'newname2':
+                raise Exception('Invalid shop name returned after change!')
+
+            # Verify beginner score saving
+            self.verify_iidx24music_breg(profile['extid'], {
+                'id': 1000,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            scores = self.verify_iidx24music_getrank(profile['extid'])
+            if 1000 not in scores:
+                raise Exception('Didn\'t get expected scores back for song {} beginner chart!'.format(1000))
+            if 6 not in scores[1000]:
+                raise Exception('Didn\'t get beginner score back for song {}!'.format(1000))
+            if scores[1000][6] != {'clear_status': 4, 'ex_score': -1, 'miss_count': -1}:
+                raise Exception('Didn\'t get correct status back from beginner save!')
+
+            # Verify DAN score saving and loading
+            self.verify_iidx24grade_raised(profile['extid'], newname, 'sp')
+            self.verify_iidx24grade_raised(profile['extid'], newname, 'dp')
+            profile = self.verify_iidx24pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for SP!')
+            if profile['dp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for DP!')
+
+            # Verify secret course and internet ranking course saving
+            self.verify_iidx24ranking_entry(profile['extid'], newname, 'ir')
+            self.verify_iidx24ranking_entry(profile['extid'], newname, 'secret')
+            self.verify_iidx24ranking_classicentry(profile['extid'])
+            profile = self.verify_iidx24pc_get(ref_id, card, lid)
+            for ptype in ['ir_data', 'secret_course_data', 'classic_course_data']:
+                if profile[ptype] != {2: {1: {'clear_status': 4, 'pgnum': 1771, 'gnum': 967}}}:
+                    raise Exception('Invalid data {} returned on profile load for {}!'.format(profile[ptype], ptype))
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/iidx/spada.py b/bemani/client/iidx/spada.py
new file mode 100644
index 0000000..ea055c0
--- /dev/null
+++ b/bemani/client/iidx/spada.py
@@ -0,0 +1,788 @@
+import random
+import time
+from typing import Any, Dict, Optional, Tuple
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class IIDXSpadaClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_iidx21shop_getname(self, lid: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21shop = Node.void('IIDX21shop')
+        call.add_child(IIDX21shop)
+        IIDX21shop.set_attribute('method', 'getname')
+        IIDX21shop.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX21shop/@opname")
+        self.assert_path(resp, "response/IIDX21shop/@pid")
+        self.assert_path(resp, "response/IIDX21shop/@cls_opt")
+
+        return resp.child('IIDX21shop').attribute('opname')
+
+    def verify_iidx21shop_savename(self, lid: str, name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21shop = Node.void('IIDX21shop')
+        IIDX21shop.set_attribute('lid', lid)
+        IIDX21shop.set_attribute('pid', '51')
+        IIDX21shop.set_attribute('method', 'savename')
+        IIDX21shop.set_attribute('cls_opt', '0')
+        IIDX21shop.set_attribute('ccode', 'US')
+        IIDX21shop.set_attribute('opname', name)
+        IIDX21shop.set_attribute('rcode', '.')
+
+        call.add_child(IIDX21shop)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX21shop")
+
+    def verify_iidx21pc_common(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX21pc/ir/@beat")
+        self.assert_path(resp, "response/IIDX21pc/limit/@phase")
+        self.assert_path(resp, "response/IIDX21pc/boss/@phase")
+        self.assert_path(resp, "response/IIDX21pc/boss1/@phase")
+        self.assert_path(resp, "response/IIDX21pc/medal/@phase")
+        self.assert_path(resp, "response/IIDX21pc/tricolettepark_skip/@phase")
+        self.assert_path(resp, "response/IIDX21pc/superstar/@phase")
+        self.assert_path(resp, "response/IIDX21pc/tricolettepark/@open")
+        self.assert_path(resp, "response/IIDX21pc/cafe/@open")
+        self.assert_path(resp, "response/IIDX21pc/newsong_another/@open")
+        self.assert_path(resp, "response/IIDX21pc/vip_pass_black")
+
+    def verify_iidx21music_crate(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21music')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'crate')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/IIDX21music")
+        for child in resp.child("IIDX21music").children:
+            if child.name != 'c':
+                raise Exception('Invalid node {} in clear rate response!'.format(child))
+            if len(child.value) != 12:
+                raise Exception('Invalid node data {} in clear rate response!'.format(child))
+            for v in child.value:
+                if v < 0 or v > 101:
+                    raise Exception('Invalid clear percent {} in clear rate response!'.format(child))
+
+    def verify_iidx21shop_getconvention(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21shop')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'getconvention')
+        IIDX21pc.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX21shop/valid")
+        self.assert_path(resp, "response/IIDX21shop/@music_0")
+        self.assert_path(resp, "response/IIDX21shop/@music_1")
+        self.assert_path(resp, "response/IIDX21shop/@music_2")
+        self.assert_path(resp, "response/IIDX21shop/@music_3")
+
+    def verify_iidx21pc_visit(self, extid: int, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('iidxid', str(extid))
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('method', 'visit')
+        IIDX21pc.set_attribute('pid', '51')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX21pc/@aflg")
+        self.assert_path(resp, "response/IIDX21pc/@anum")
+        self.assert_path(resp, "response/IIDX21pc/@pflg")
+        self.assert_path(resp, "response/IIDX21pc/@pnum")
+        self.assert_path(resp, "response/IIDX21pc/@sflg")
+        self.assert_path(resp, "response/IIDX21pc/@snum")
+
+    def verify_iidx21ranking_getranker(self, lid: str) -> None:
+        for clid in [0, 1, 2, 3, 4, 5, 6]:
+            call = self.call_node()
+
+            # Construct node
+            IIDX21pc = Node.void('IIDX21ranking')
+            call.add_child(IIDX21pc)
+            IIDX21pc.set_attribute('method', 'getranker')
+            IIDX21pc.set_attribute('lid', lid)
+            IIDX21pc.set_attribute('clid', str(clid))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            # Verify that response is correct
+            self.assert_path(resp, "response/IIDX21ranking")
+
+    def verify_iidx21shop_sentinfo(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21shop')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'sentinfo')
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('bflg', '1')
+        IIDX21pc.set_attribute('bnum', '2')
+        IIDX21pc.set_attribute('ioid', '0')
+        IIDX21pc.set_attribute('tax_phase', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/IIDX21shop")
+
+    def verify_iidx21pc_get(self, ref_id: str, card_id: str, lid: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('rid', ref_id)
+        IIDX21pc.set_attribute('did', ref_id)
+        IIDX21pc.set_attribute('pid', '51')
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('cid', card_id)
+        IIDX21pc.set_attribute('method', 'get')
+        IIDX21pc.set_attribute('ctype', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that the response is correct
+        self.assert_path(resp, "response/IIDX21pc/pcdata/@name")
+        self.assert_path(resp, "response/IIDX21pc/pcdata/@pid")
+        self.assert_path(resp, "response/IIDX21pc/pcdata/@id")
+        self.assert_path(resp, "response/IIDX21pc/pcdata/@idstr")
+        self.assert_path(resp, "response/IIDX21pc/packinfo")
+        self.assert_path(resp, "response/IIDX21pc/deller")
+        self.assert_path(resp, "response/IIDX21pc/secret/flg1")
+        self.assert_path(resp, "response/IIDX21pc/secret/flg2")
+        self.assert_path(resp, "response/IIDX21pc/secret/flg3")
+        self.assert_path(resp, "response/IIDX21pc/achievements/trophy")
+        self.assert_path(resp, "response/IIDX21pc/skin")
+        self.assert_path(resp, "response/IIDX21pc/grade")
+        self.assert_path(resp, "response/IIDX21pc/rlist")
+        self.assert_path(resp, "response/IIDX21pc/step/album")
+        self.assert_path(resp, "response/IIDX21pc/favorite/sp_mlist")
+        self.assert_path(resp, "response/IIDX21pc/favorite/sp_clist")
+        self.assert_path(resp, "response/IIDX21pc/favorite/dp_mlist")
+        self.assert_path(resp, "response/IIDX21pc/favorite/dp_clist")
+
+        name = resp.child('IIDX21pc/pcdata').attribute('name')
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+        return {
+            'extid': int(resp.child('IIDX21pc/pcdata').attribute('id')),
+            'sp_dan': int(resp.child('IIDX21pc/grade').attribute('sgid')),
+            'dp_dan': int(resp.child('IIDX21pc/grade').attribute('dgid')),
+            'deller': int(resp.child('IIDX21pc/deller').attribute('deller')),
+        }
+
+    def verify_iidx21music_getrank(self, extid: int) -> Dict[int, Dict[int, Dict[str, int]]]:
+        scores: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for cltype in [0, 1]:  # singles, doubles
+            call = self.call_node()
+
+            # Construct node
+            IIDX21music = Node.void('IIDX21music')
+            call.add_child(IIDX21music)
+            IIDX21music.set_attribute('method', 'getrank')
+            IIDX21music.set_attribute('iidxid', str(extid))
+            IIDX21music.set_attribute('cltype', str(cltype))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            self.assert_path(resp, "response/IIDX21music/style")
+            if int(resp.child('IIDX21music/style').attribute('type')) != cltype:
+                raise Exception('Returned wrong clear type for IIDX21music.getrank!')
+
+            for child in resp.child('IIDX21music').children:
+                if child.name == 'm':
+                    if child.value[0] != -1:
+                        raise Exception('Got non-self score back when requesting only our scores!')
+
+                    music_id = child.value[1]
+                    normal_clear_status = child.value[2]
+                    hyper_clear_status = child.value[3]
+                    another_clear_status = child.value[4]
+                    normal_ex_score = child.value[5]
+                    hyper_ex_score = child.value[6]
+                    another_ex_score = child.value[7]
+                    normal_miss_count = child.value[8]
+                    hyper_miss_count = child.value[9]
+                    another_miss_count = child.value[10]
+
+                    if cltype == 0:
+                        normal = 0
+                        hyper = 1
+                        another = 2
+                    else:
+                        normal = 3
+                        hyper = 4
+                        another = 5
+
+                    if music_id not in scores:
+                        scores[music_id] = {}
+
+                    scores[music_id][normal] = {
+                        'clear_status': normal_clear_status,
+                        'ex_score': normal_ex_score,
+                        'miss_count': normal_miss_count,
+                    }
+                    scores[music_id][hyper] = {
+                        'clear_status': hyper_clear_status,
+                        'ex_score': hyper_ex_score,
+                        'miss_count': hyper_miss_count,
+                    }
+                    scores[music_id][another] = {
+                        'clear_status': another_clear_status,
+                        'ex_score': another_ex_score,
+                        'miss_count': another_miss_count,
+                    }
+                elif child.name == 'b':
+                    music_id = child.value[0]
+                    clear_status = child.value[1]
+
+                    scores[music_id][6] = {
+                        'clear_status': clear_status,
+                        'ex_score': -1,
+                        'miss_count': -1,
+                    }
+
+        return scores
+
+    def verify_iidx21pc_save(self, extid: int, card: str, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('s_disp_judge', '1')
+        IIDX21pc.set_attribute('mode', '6')
+        IIDX21pc.set_attribute('pmode', '0')
+        IIDX21pc.set_attribute('method', 'save')
+        IIDX21pc.set_attribute('s_sorttype', '0')
+        IIDX21pc.set_attribute('s_exscore', '0')
+        IIDX21pc.set_attribute('d_notes', '0.000000')
+        IIDX21pc.set_attribute('gpos', '0')
+        IIDX21pc.set_attribute('s_gno', '8')
+        IIDX21pc.set_attribute('s_hispeed', '5.771802')
+        IIDX21pc.set_attribute('s_judge', '0')
+        IIDX21pc.set_attribute('d_timing', '0')
+        IIDX21pc.set_attribute('rtype', '0')
+        IIDX21pc.set_attribute('d_largejudge', '0')
+        IIDX21pc.set_attribute('d_lift', '60')
+        IIDX21pc.set_attribute('s_pace', '0')
+        IIDX21pc.set_attribute('d_exscore', '0')
+        IIDX21pc.set_attribute('d_sdtype', '0')
+        IIDX21pc.set_attribute('s_opstyle', '1')
+        IIDX21pc.set_attribute('s_achi', '449')
+        IIDX21pc.set_attribute('s_largejudge', '0')
+        IIDX21pc.set_attribute('d_gno', '0')
+        IIDX21pc.set_attribute('s_lift', '60')
+        IIDX21pc.set_attribute('s_notes', '31.484070')
+        IIDX21pc.set_attribute('d_tune', '0')
+        IIDX21pc.set_attribute('d_sdlen', '0')
+        IIDX21pc.set_attribute('d_achi', '4')
+        IIDX21pc.set_attribute('d_opstyle', '0')
+        IIDX21pc.set_attribute('sp_opt', '8208')
+        IIDX21pc.set_attribute('iidxid', str(extid))
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('s_judgeAdj', '0')
+        IIDX21pc.set_attribute('s_tune', '3')
+        IIDX21pc.set_attribute('s_sdtype', '1')
+        IIDX21pc.set_attribute('s_gtype', '2')
+        IIDX21pc.set_attribute('d_judge', '0')
+        IIDX21pc.set_attribute('cid', card)
+        IIDX21pc.set_attribute('cltype', '0')
+        IIDX21pc.set_attribute('ctype', '1')
+        IIDX21pc.set_attribute('bookkeep', '0')
+        IIDX21pc.set_attribute('d_hispeed', '0.000000')
+        IIDX21pc.set_attribute('d_pace', '0')
+        IIDX21pc.set_attribute('d_judgeAdj', '0')
+        IIDX21pc.set_attribute('s_timing', '1')
+        IIDX21pc.set_attribute('d_disp_judge', '0')
+        IIDX21pc.set_attribute('s_sdlen', '121')
+        IIDX21pc.set_attribute('dp_opt2', '0')
+        IIDX21pc.set_attribute('d_gtype', '0')
+        IIDX21pc.set_attribute('d_sorttype', '0')
+        IIDX21pc.set_attribute('dp_opt', '0')
+        pyramid = Node.void('pyramid')
+        IIDX21pc.add_child(pyramid)
+        pyramid.set_attribute('point', '290')
+        destiny_catharsis = Node.void('destiny_catharsis')
+        IIDX21pc.add_child(destiny_catharsis)
+        destiny_catharsis.set_attribute('point', '290')
+        bemani_summer_collabo = Node.void('bemani_summer_collabo')
+        IIDX21pc.add_child(bemani_summer_collabo)
+        bemani_summer_collabo.set_attribute('point', '290')
+        deller = Node.void('deller')
+        IIDX21pc.add_child(deller)
+        deller.set_attribute('deller', '150')
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX21pc")
+
+    def verify_iidx21music_reg(self, extid: int, lid: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('IIDX21music')
+        call.add_child(IIDX21music)
+        IIDX21music.set_attribute('convid', '-1')
+        IIDX21music.set_attribute('iidxid', str(extid))
+        IIDX21music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX21music.set_attribute('pid', '51')
+        IIDX21music.set_attribute('rankside', '1')
+        IIDX21music.set_attribute('cflg', str(score['clear_status']))
+        IIDX21music.set_attribute('method', 'reg')
+        IIDX21music.set_attribute('gnum', str(score['gnum']))
+        IIDX21music.set_attribute('clid', str(score['chart']))
+        IIDX21music.set_attribute('mnum', str(score['mnum']))
+        IIDX21music.set_attribute('is_death', '0')
+        IIDX21music.set_attribute('theory', '0')
+        IIDX21music.set_attribute('shopconvid', lid)
+        IIDX21music.set_attribute('mid', str(score['id']))
+        IIDX21music.set_attribute('shopflg', '1')
+        IIDX21music.add_child(Node.binary('ghost', bytes([1] * 64)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX21music/shopdata/@rank")
+        self.assert_path(resp, "response/IIDX21music/ranklist/data")
+
+    def verify_iidx21music_appoint(self, extid: int, musicid: int, chart: int) -> Tuple[int, bytes]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('IIDX21music')
+        call.add_child(IIDX21music)
+        IIDX21music.set_attribute('clid', str(chart))
+        IIDX21music.set_attribute('method', 'appoint')
+        IIDX21music.set_attribute('ctype', '0')
+        IIDX21music.set_attribute('iidxid', str(extid))
+        IIDX21music.set_attribute('subtype', '')
+        IIDX21music.set_attribute('mid', str(musicid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/IIDX21music/mydata/@score")
+
+        return (
+            int(resp.child('IIDX21music/mydata').attribute('score')),
+            resp.child_value('IIDX21music/mydata'),
+        )
+
+    def verify_iidx21pc_reg(self, ref_id: str, card_id: str, lid: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('pid', '51')
+        IIDX21pc.set_attribute('method', 'reg')
+        IIDX21pc.set_attribute('cid', card_id)
+        IIDX21pc.set_attribute('did', ref_id)
+        IIDX21pc.set_attribute('rid', ref_id)
+        IIDX21pc.set_attribute('name', self.NAME)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX21pc/@id")
+        self.assert_path(resp, "response/IIDX21pc/@id_str")
+
+        return int(resp.child('IIDX21pc').attribute('id'))
+
+    def verify_iidx21pc_playstart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        IIDX21pc.set_attribute('method', 'playstart')
+        IIDX21pc.set_attribute('side', '1')
+        call.add_child(IIDX21pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX21pc")
+
+    def verify_iidx21music_play(self, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('IIDX21music')
+        IIDX21music.set_attribute('opt', '64')
+        IIDX21music.set_attribute('clid', str(score['chart']))
+        IIDX21music.set_attribute('mid', str(score['id']))
+        IIDX21music.set_attribute('gnum', str(score['gnum']))
+        IIDX21music.set_attribute('cflg', str(score['clear_status']))
+        IIDX21music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX21music.set_attribute('pid', '51')
+        IIDX21music.set_attribute('method', 'play')
+        call.add_child(IIDX21music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX21music/@clid")
+        self.assert_path(resp, "response/IIDX21music/@crate")
+        self.assert_path(resp, "response/IIDX21music/@frate")
+        self.assert_path(resp, "response/IIDX21music/@mid")
+
+    def verify_iidx21pc_playend(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('IIDX21pc')
+        IIDX21pc.set_attribute('cltype', '0')
+        IIDX21pc.set_attribute('bookkeep', '0')
+        IIDX21pc.set_attribute('mode', '1')
+        IIDX21pc.set_attribute('method', 'playend')
+        call.add_child(IIDX21pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX21pc")
+
+    def verify_iidx21music_breg(self, iidxid: int, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('IIDX21music')
+        IIDX21music.set_attribute('gnum', str(score['gnum']))
+        IIDX21music.set_attribute('iidxid', str(iidxid))
+        IIDX21music.set_attribute('mid', str(score['id']))
+        IIDX21music.set_attribute('method', 'breg')
+        IIDX21music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX21music.set_attribute('cflg', str(score['clear_status']))
+        call.add_child(IIDX21music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX21music")
+
+    def verify_iidx21grade_raised(self, iidxid: int, shop_name: str, dantype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21grade = Node.void('IIDX21grade')
+        IIDX21grade.set_attribute('opname', shop_name)
+        IIDX21grade.set_attribute('is_mirror', '0')
+        IIDX21grade.set_attribute('oppid', '51')
+        IIDX21grade.set_attribute('achi', '50')
+        IIDX21grade.set_attribute('cflg', '4' if dantype == 'sp' else '3')
+        IIDX21grade.set_attribute('gid', '5')
+        IIDX21grade.set_attribute('iidxid', str(iidxid))
+        IIDX21grade.set_attribute('gtype', '0' if dantype == 'sp' else '1')
+        IIDX21grade.set_attribute('is_ex', '0')
+        IIDX21grade.set_attribute('pside', '0')
+        IIDX21grade.set_attribute('method', 'raised')
+        call.add_child(IIDX21grade)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/IIDX21grade/@pnum")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_package_list()
+        self.verify_message_get()
+        lid = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_iidx21shop_getname(lid)
+        self.verify_iidx21pc_common()
+        self.verify_iidx21music_crate()
+        self.verify_iidx21shop_getconvention(lid)
+        self.verify_iidx21ranking_getranker(lid)
+        self.verify_iidx21shop_sentinfo(lid)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_iidx21pc_reg(ref_id, card, lid)
+            self.verify_iidx21pc_get(ref_id, card, lid)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            profile = self.verify_iidx21pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != -1:
+                raise Exception('Somehow has SP DAN ranking on new profile!')
+            if profile['dp_dan'] != -1:
+                raise Exception('Somehow has DP DAN ranking on new profile!')
+            if profile['deller'] != 0:
+                raise Exception('Somehow has deller on new profile!')
+            scores = self.verify_iidx21music_getrank(profile['extid'])
+            if len(scores.keys()) > 0:
+                raise Exception('Somehow have scores on a new profile!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 7,
+                            'pgnum': 246,
+                            'gnum': 0,
+                            'mnum': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 1003,
+                            'chart': 2,
+                            'clear_status': 1,
+                            'pgnum': 10,
+                            'gnum': 20,
+                            'mnum': 50,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 1003,
+                            'chart': 0,
+                            'clear_status': 1,
+                            'pgnum': 2,
+                            'gnum': 5,
+                            'mnum': 75,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 5,
+                            'pgnum': 234,
+                            'gnum': 234,
+                            'mnum': 3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 35,
+                            'expected_clear_status': 7,
+                            'expected_ex_score': 492,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_iidx21music_reg(profile['extid'], lid, dummyscore)
+                self.verify_iidx21pc_visit(profile['extid'], lid)
+                self.verify_iidx21pc_save(profile['extid'], card, lid)
+                scores = self.verify_iidx21music_getrank(profile['extid'])
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    if 'expected_ex_score' in score:
+                        expected_score = score['expected_ex_score']
+                    else:
+                        expected_score = (score['pgnum'] * 2) + score['gnum']
+                    if 'expected_clear_status' in score:
+                        expected_clear_status = score['expected_clear_status']
+                    else:
+                        expected_clear_status = score['clear_status']
+                    if 'expected_miss_count' in score:
+                        expected_miss_count = score['expected_miss_count']
+                    else:
+                        expected_miss_count = score['mnum']
+
+                    if data['ex_score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+                    if data['clear_status'] != expected_clear_status:
+                        raise Exception('Expected a clear status of \'{}\' for song \'{}\' chart \'{}\' but got clear status \'{}\''.format(
+                            expected_clear_status, score['id'], score['chart'], data['clear_status'],
+                        ))
+                    if data['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, score['id'], score['chart'], data['miss_count'],
+                        ))
+
+                    # Verify we can fetch our own ghost
+                    ex_score, ghost = self.verify_iidx21music_appoint(profile['extid'], score['id'], score['chart'])
+                    if ex_score != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+
+                    if len(ghost) != 64:
+                        raise Exception('Wrong ghost length {} for ghost!'.format(len(ghost)))
+                    for g in ghost:
+                        if g != 0x01:
+                            raise Exception('Got back wrong ghost data for song \'{}\' chart \'{}\''.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Verify that a player without a card can play
+            self.verify_iidx21pc_playstart()
+            self.verify_iidx21music_play({
+                'id': 1000,
+                'chart': 2,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            self.verify_iidx21pc_playend()
+
+            # Verify shop name change setting
+            self.verify_iidx21shop_savename(lid, 'newname1')
+            newname = self.verify_iidx21shop_getname(lid)
+            if newname != 'newname1':
+                raise Exception('Invalid shop name returned after change!')
+            self.verify_iidx21shop_savename(lid, 'newname2')
+            newname = self.verify_iidx21shop_getname(lid)
+            if newname != 'newname2':
+                raise Exception('Invalid shop name returned after change!')
+
+            # Verify beginner score saving
+            self.verify_iidx21music_breg(profile['extid'], {
+                'id': 1000,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            scores = self.verify_iidx21music_getrank(profile['extid'])
+            if 1000 not in scores:
+                raise Exception('Didn\'t get expected scores back for song {} beginner chart!'.format(1000))
+            if 6 not in scores[1000]:
+                raise Exception('Didn\'t get beginner score back for song {}!'.format(1000))
+            if scores[1000][6] != {'clear_status': 4, 'ex_score': -1, 'miss_count': -1}:
+                raise Exception('Didn\'t get correct status back from beginner save!')
+
+            # Verify DAN score saving and loading
+            self.verify_iidx21grade_raised(profile['extid'], newname, 'sp')
+            self.verify_iidx21grade_raised(profile['extid'], newname, 'dp')
+            profile = self.verify_iidx21pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for SP!')
+            if profile['dp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for DP!')
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/iidx/tricoro.py b/bemani/client/iidx/tricoro.py
new file mode 100644
index 0000000..1ea4a00
--- /dev/null
+++ b/bemani/client/iidx/tricoro.py
@@ -0,0 +1,758 @@
+import random
+import time
+from typing import Any, Dict, Optional, Tuple
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class IIDXTricoroClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_shop_getname(self, lid: str) -> str:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21shop = Node.void('shop')
+        call.add_child(IIDX21shop)
+        IIDX21shop.set_attribute('method', 'getname')
+        IIDX21shop.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shop/@opname")
+        self.assert_path(resp, "response/shop/@pid")
+        self.assert_path(resp, "response/shop/@cls_opt")
+
+        return resp.child('shop').attribute('opname')
+
+    def verify_shop_savename(self, lid: str, name: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21shop = Node.void('shop')
+        IIDX21shop.set_attribute('lid', lid)
+        IIDX21shop.set_attribute('pid', '51')
+        IIDX21shop.set_attribute('method', 'savename')
+        IIDX21shop.set_attribute('cls_opt', '0')
+        IIDX21shop.set_attribute('ccode', 'US')
+        IIDX21shop.set_attribute('opname', name)
+        IIDX21shop.set_attribute('rcode', '.')
+
+        call.add_child(IIDX21shop)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shop")
+
+    def verify_pc_common(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pc/ir/@beat")
+        self.assert_path(resp, "response/pc/limit/@phase")
+        self.assert_path(resp, "response/pc/boss/@phase")
+        self.assert_path(resp, "response/pc/red/@phase")
+        self.assert_path(resp, "response/pc/yellow/@phase")
+        self.assert_path(resp, "response/pc/medal/@phase")
+        self.assert_path(resp, "response/pc/tricolettepark/@open")
+        self.assert_path(resp, "response/pc/cafe/@open")
+
+    def verify_music_crate(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('music')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'crate')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        self.assert_path(resp, "response/music")
+        for child in resp.child("music").children:
+            if child.name != 'c':
+                raise Exception('Invalid node {} in clear rate response!'.format(child))
+            if len(child.value) != 12:
+                raise Exception('Invalid node data {} in clear rate response!'.format(child))
+            for v in child.value:
+                if v < 0 or v > 101:
+                    raise Exception('Invalid clear percent {} in clear rate response!'.format(child))
+
+    def verify_shop_getconvention(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('shop')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'getconvention')
+        IIDX21pc.set_attribute('lid', lid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shop/valid")
+        self.assert_path(resp, "response/shop/@music_0")
+        self.assert_path(resp, "response/shop/@music_1")
+        self.assert_path(resp, "response/shop/@music_2")
+        self.assert_path(resp, "response/shop/@music_3")
+
+    def verify_pc_visit(self, extid: int, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('iidxid', str(extid))
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('method', 'visit')
+        IIDX21pc.set_attribute('pid', '51')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pc/@aflg")
+        self.assert_path(resp, "response/pc/@anum")
+        self.assert_path(resp, "response/pc/@pflg")
+        self.assert_path(resp, "response/pc/@pnum")
+        self.assert_path(resp, "response/pc/@sflg")
+        self.assert_path(resp, "response/pc/@snum")
+
+    def verify_ranking_getranker(self, lid: str) -> None:
+        for clid in [0, 1, 2, 3, 4, 5, 6]:
+            call = self.call_node()
+
+            # Construct node
+            IIDX21pc = Node.void('ranking')
+            call.add_child(IIDX21pc)
+            IIDX21pc.set_attribute('method', 'getranker')
+            IIDX21pc.set_attribute('lid', lid)
+            IIDX21pc.set_attribute('clid', str(clid))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            # Verify that response is correct
+            self.assert_path(resp, "response/ranking")
+
+    def verify_shop_sentinfo(self, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('shop')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('method', 'sentinfo')
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('bflg', '1')
+        IIDX21pc.set_attribute('bnum', '2')
+        IIDX21pc.set_attribute('ioid', '0')
+        IIDX21pc.set_attribute('tax_phase', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shop")
+
+    def verify_pc_get(self, ref_id: str, card_id: str, lid: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('rid', ref_id)
+        IIDX21pc.set_attribute('did', ref_id)
+        IIDX21pc.set_attribute('pid', '51')
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('cid', card_id)
+        IIDX21pc.set_attribute('method', 'get')
+        IIDX21pc.set_attribute('ctype', '1')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that the response is correct
+        self.assert_path(resp, "response/pc/pcdata/@name")
+        self.assert_path(resp, "response/pc/pcdata/@pid")
+        self.assert_path(resp, "response/pc/pcdata/@id")
+        self.assert_path(resp, "response/pc/pcdata/@idstr")
+        self.assert_path(resp, "response/pc/packinfo")
+        self.assert_path(resp, "response/pc/commonboss/@deller")
+        self.assert_path(resp, "response/pc/commonboss/@orb")
+        self.assert_path(resp, "response/pc/commonboss/@baron")
+        self.assert_path(resp, "response/pc/secret/flg1")
+        self.assert_path(resp, "response/pc/secret/flg2")
+        self.assert_path(resp, "response/pc/secret/flg3")
+        self.assert_path(resp, "response/pc/achievements/trophy")
+        self.assert_path(resp, "response/pc/skin")
+        self.assert_path(resp, "response/pc/grade")
+        self.assert_path(resp, "response/pc/rlist")
+        self.assert_path(resp, "response/pc/step")
+
+        name = resp.child('pc/pcdata').attribute('name')
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+        return {
+            'extid': int(resp.child('pc/pcdata').attribute('id')),
+            'sp_dan': int(resp.child('pc/grade').attribute('sgid')),
+            'dp_dan': int(resp.child('pc/grade').attribute('dgid')),
+            'deller': int(resp.child('pc/commonboss').attribute('deller')),
+        }
+
+    def verify_music_getrank(self, extid: int) -> Dict[int, Dict[int, Dict[str, int]]]:
+        scores: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for cltype in [0, 1]:  # singles, doubles
+            call = self.call_node()
+
+            # Construct node
+            IIDX21music = Node.void('music')
+            call.add_child(IIDX21music)
+            IIDX21music.set_attribute('method', 'getrank')
+            IIDX21music.set_attribute('iidxid', str(extid))
+            IIDX21music.set_attribute('cltype', str(cltype))
+
+            # Swap with server
+            resp = self.exchange('', call)
+
+            self.assert_path(resp, "response/music/style")
+            if int(resp.child('music/style').attribute('type')) != cltype:
+                raise Exception('Returned wrong clear type for IIDX21music.getrank!')
+
+            for child in resp.child('music').children:
+                if child.name == 'm':
+                    if child.value[0] != -1:
+                        raise Exception('Got non-self score back when requesting only our scores!')
+
+                    music_id = child.value[1]
+                    normal_clear_status = child.value[2]
+                    hyper_clear_status = child.value[3]
+                    another_clear_status = child.value[4]
+                    normal_ex_score = child.value[5]
+                    hyper_ex_score = child.value[6]
+                    another_ex_score = child.value[7]
+                    normal_miss_count = child.value[8]
+                    hyper_miss_count = child.value[9]
+                    another_miss_count = child.value[10]
+
+                    if cltype == 0:
+                        normal = 0
+                        hyper = 1
+                        another = 2
+                    else:
+                        normal = 3
+                        hyper = 4
+                        another = 5
+
+                    if music_id not in scores:
+                        scores[music_id] = {}
+
+                    scores[music_id][normal] = {
+                        'clear_status': normal_clear_status,
+                        'ex_score': normal_ex_score,
+                        'miss_count': normal_miss_count,
+                    }
+                    scores[music_id][hyper] = {
+                        'clear_status': hyper_clear_status,
+                        'ex_score': hyper_ex_score,
+                        'miss_count': hyper_miss_count,
+                    }
+                    scores[music_id][another] = {
+                        'clear_status': another_clear_status,
+                        'ex_score': another_ex_score,
+                        'miss_count': another_miss_count,
+                    }
+                elif child.name == 'b':
+                    music_id = child.value[0]
+                    clear_status = child.value[1]
+
+                    scores[music_id][6] = {
+                        'clear_status': clear_status,
+                        'ex_score': -1,
+                        'miss_count': -1,
+                    }
+
+        return scores
+
+    def verify_pc_save(self, extid: int, card: str, lid: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('achi', '449')
+        IIDX21pc.set_attribute('opt', '8208')
+        IIDX21pc.set_attribute('gpos', '0')
+        IIDX21pc.set_attribute('gno', '8')
+        IIDX21pc.set_attribute('timing', '0')
+        IIDX21pc.set_attribute('help', '0')
+        IIDX21pc.set_attribute('sdhd', '0')
+        IIDX21pc.set_attribute('sdtype', '0')
+        IIDX21pc.set_attribute('notes', '31.484070')
+        IIDX21pc.set_attribute('pase', '0')
+        IIDX21pc.set_attribute('judge', '0')
+        IIDX21pc.set_attribute('opstyle', '1')
+        IIDX21pc.set_attribute('hispeed', '5.771802')
+        IIDX21pc.set_attribute('mode', '6')
+        IIDX21pc.set_attribute('pmode', '0')
+        IIDX21pc.set_attribute('lift', '60')
+        IIDX21pc.set_attribute('judgeAdj', '0')
+
+        IIDX21pc.set_attribute('method', 'save')
+        IIDX21pc.set_attribute('iidxid', str(extid))
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('cid', card)
+        IIDX21pc.set_attribute('cltype', '0')
+        IIDX21pc.set_attribute('ctype', '1')
+
+        pyramid = Node.void('pyramid')
+        IIDX21pc.add_child(pyramid)
+        pyramid.set_attribute('point', '290')
+        destiny_catharsis = Node.void('destiny_catharsis')
+        IIDX21pc.add_child(destiny_catharsis)
+        destiny_catharsis.set_attribute('point', '290')
+        bemani_summer_collabo = Node.void('bemani_summer_collabo')
+        IIDX21pc.add_child(bemani_summer_collabo)
+        bemani_summer_collabo.set_attribute('point', '290')
+        deller = Node.void('deller')
+        IIDX21pc.add_child(deller)
+        deller.set_attribute('deller', '150')
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/pc")
+
+    def verify_music_reg(self, extid: int, lid: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('music')
+        call.add_child(IIDX21music)
+        IIDX21music.set_attribute('convid', '-1')
+        IIDX21music.set_attribute('iidxid', str(extid))
+        IIDX21music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX21music.set_attribute('pid', '51')
+        IIDX21music.set_attribute('rankside', '1')
+        IIDX21music.set_attribute('cflg', str(score['clear_status']))
+        IIDX21music.set_attribute('method', 'reg')
+        IIDX21music.set_attribute('gnum', str(score['gnum']))
+        IIDX21music.set_attribute('clid', str(score['chart']))
+        IIDX21music.set_attribute('mnum', str(score['mnum']))
+        IIDX21music.set_attribute('is_death', '0')
+        IIDX21music.set_attribute('theory', '0')
+        IIDX21music.set_attribute('shopconvid', lid)
+        IIDX21music.set_attribute('mid', str(score['id']))
+        IIDX21music.set_attribute('shopflg', '1')
+        IIDX21music.add_child(Node.binary('ghost', bytes([1] * 64)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/music/shopdata/@rank")
+        self.assert_path(resp, "response/music/ranklist/data")
+
+    def verify_music_appoint(self, extid: int, musicid: int, chart: int) -> Tuple[int, bytes]:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('music')
+        call.add_child(IIDX21music)
+        IIDX21music.set_attribute('clid', str(chart))
+        IIDX21music.set_attribute('method', 'appoint')
+        IIDX21music.set_attribute('ctype', '0')
+        IIDX21music.set_attribute('iidxid', str(extid))
+        IIDX21music.set_attribute('subtype', '')
+        IIDX21music.set_attribute('mid', str(musicid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/music/mydata/@score")
+
+        return (
+            int(resp.child('music/mydata').attribute('score')),
+            resp.child_value('music/mydata'),
+        )
+
+    def verify_pc_reg(self, ref_id: str, card_id: str, lid: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        call.add_child(IIDX21pc)
+        IIDX21pc.set_attribute('lid', lid)
+        IIDX21pc.set_attribute('pid', '51')
+        IIDX21pc.set_attribute('method', 'reg')
+        IIDX21pc.set_attribute('cid', card_id)
+        IIDX21pc.set_attribute('did', ref_id)
+        IIDX21pc.set_attribute('rid', ref_id)
+        IIDX21pc.set_attribute('name', self.NAME)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/pc/@id")
+        self.assert_path(resp, "response/pc/@id_str")
+
+        return int(resp.child('pc').attribute('id'))
+
+    def verify_pc_playstart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        IIDX21pc.set_attribute('method', 'playstart')
+        IIDX21pc.set_attribute('side', '1')
+        call.add_child(IIDX21pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/pc")
+
+    def verify_music_play(self, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('music')
+        IIDX21music.set_attribute('opt', '64')
+        IIDX21music.set_attribute('clid', str(score['chart']))
+        IIDX21music.set_attribute('mid', str(score['id']))
+        IIDX21music.set_attribute('gnum', str(score['gnum']))
+        IIDX21music.set_attribute('cflg', str(score['clear_status']))
+        IIDX21music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX21music.set_attribute('pid', '51')
+        IIDX21music.set_attribute('method', 'play')
+        call.add_child(IIDX21music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/music/@clid")
+        self.assert_path(resp, "response/music/@crate")
+        self.assert_path(resp, "response/music/@frate")
+        self.assert_path(resp, "response/music/@mid")
+
+    def verify_pc_playend(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21pc = Node.void('pc')
+        IIDX21pc.set_attribute('cltype', '0')
+        IIDX21pc.set_attribute('bookkeep', '0')
+        IIDX21pc.set_attribute('mode', '1')
+        IIDX21pc.set_attribute('method', 'playend')
+        call.add_child(IIDX21pc)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/pc")
+
+    def verify_music_breg(self, iidxid: int, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21music = Node.void('music')
+        IIDX21music.set_attribute('gnum', str(score['gnum']))
+        IIDX21music.set_attribute('iidxid', str(iidxid))
+        IIDX21music.set_attribute('mid', str(score['id']))
+        IIDX21music.set_attribute('method', 'breg')
+        IIDX21music.set_attribute('pgnum', str(score['pgnum']))
+        IIDX21music.set_attribute('cflg', str(score['clear_status']))
+        call.add_child(IIDX21music)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/music")
+
+    def verify_grade_raised(self, iidxid: int, shop_name: str, dantype: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        IIDX21grade = Node.void('grade')
+        IIDX21grade.set_attribute('opname', shop_name)
+        IIDX21grade.set_attribute('is_mirror', '0')
+        IIDX21grade.set_attribute('oppid', '51')
+        IIDX21grade.set_attribute('achi', '50')
+        IIDX21grade.set_attribute('cflg', '4' if dantype == 'sp' else '3')
+        IIDX21grade.set_attribute('gid', '5')
+        IIDX21grade.set_attribute('iidxid', str(iidxid))
+        IIDX21grade.set_attribute('gtype', '0' if dantype == 'sp' else '1')
+        IIDX21grade.set_attribute('is_ex', '0')
+        IIDX21grade.set_attribute('pside', '0')
+        IIDX21grade.set_attribute('method', 'raised')
+        call.add_child(IIDX21grade)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/grade/@pnum")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_package_list()
+        self.verify_message_get()
+        lid = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_shop_getname(lid)
+        self.verify_pc_common()
+        self.verify_music_crate()
+        self.verify_shop_getconvention(lid)
+        self.verify_ranking_getranker(lid)
+        self.verify_shop_sentinfo(lid)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_pc_reg(ref_id, card, lid)
+            self.verify_pc_get(ref_id, card, lid)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            profile = self.verify_pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != -1:
+                raise Exception('Somehow has SP DAN ranking on new profile!')
+            if profile['dp_dan'] != -1:
+                raise Exception('Somehow has DP DAN ranking on new profile!')
+            if profile['deller'] != 0:
+                raise Exception('Somehow has deller on new profile!')
+            scores = self.verify_music_getrank(profile['extid'])
+            if len(scores.keys()) > 0:
+                raise Exception('Somehow have scores on a new profile!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 7,
+                            'pgnum': 246,
+                            'gnum': 0,
+                            'mnum': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 1003,
+                            'chart': 2,
+                            'clear_status': 1,
+                            'pgnum': 10,
+                            'gnum': 20,
+                            'mnum': 50,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 1003,
+                            'chart': 0,
+                            'clear_status': 1,
+                            'pgnum': 2,
+                            'gnum': 5,
+                            'mnum': 75,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1000,
+                            'chart': 2,
+                            'clear_status': 5,
+                            'pgnum': 234,
+                            'gnum': 234,
+                            'mnum': 3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1000,
+                            'chart': 0,
+                            'clear_status': 4,
+                            'pgnum': 123,
+                            'gnum': 123,
+                            'mnum': 35,
+                            'expected_clear_status': 7,
+                            'expected_ex_score': 492,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_music_reg(profile['extid'], lid, dummyscore)
+                self.verify_pc_visit(profile['extid'], lid)
+                self.verify_pc_save(profile['extid'], card, lid)
+                scores = self.verify_music_getrank(profile['extid'])
+                for score in dummyscores:
+                    data = scores.get(score['id'], {}).get(score['chart'], None)
+                    if data is None:
+                        raise Exception('Expected to get score back for song {} chart {}!'.format(score['id'], score['chart']))
+
+                    if 'expected_ex_score' in score:
+                        expected_score = score['expected_ex_score']
+                    else:
+                        expected_score = (score['pgnum'] * 2) + score['gnum']
+                    if 'expected_clear_status' in score:
+                        expected_clear_status = score['expected_clear_status']
+                    else:
+                        expected_clear_status = score['clear_status']
+                    if 'expected_miss_count' in score:
+                        expected_miss_count = score['expected_miss_count']
+                    else:
+                        expected_miss_count = score['mnum']
+
+                    if data['ex_score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+                    if data['clear_status'] != expected_clear_status:
+                        raise Exception('Expected a clear status of \'{}\' for song \'{}\' chart \'{}\' but got clear status \'{}\''.format(
+                            expected_clear_status, score['id'], score['chart'], data['clear_status'],
+                        ))
+                    if data['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, score['id'], score['chart'], data['miss_count'],
+                        ))
+
+                    # Verify we can fetch our own ghost
+                    ex_score, ghost = self.verify_music_appoint(profile['extid'], score['id'], score['chart'])
+                    if ex_score != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], data['ex_score'],
+                        ))
+
+                    if len(ghost) != 64:
+                        raise Exception('Wrong ghost length {} for ghost!'.format(len(ghost)))
+                    for g in ghost:
+                        if g != 0x01:
+                            raise Exception('Got back wrong ghost data for song \'{}\' chart \'{}\''.format(score['id'], score['chart']))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Verify that a player without a card can play
+            self.verify_pc_playstart()
+            self.verify_music_play({
+                'id': 1000,
+                'chart': 2,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            self.verify_pc_playend()
+
+            # Verify shop name change setting
+            self.verify_shop_savename(lid, 'newname1')
+            newname = self.verify_shop_getname(lid)
+            if newname != 'newname1':
+                raise Exception('Invalid shop name returned after change!')
+            self.verify_shop_savename(lid, 'newname2')
+            newname = self.verify_shop_getname(lid)
+            if newname != 'newname2':
+                raise Exception('Invalid shop name returned after change!')
+
+            # Verify beginner score saving
+            self.verify_music_breg(profile['extid'], {
+                'id': 1000,
+                'clear_status': 4,
+                'pgnum': 123,
+                'gnum': 123,
+            })
+            scores = self.verify_music_getrank(profile['extid'])
+            if 1000 not in scores:
+                raise Exception('Didn\'t get expected scores back for song {} beginner chart!'.format(1000))
+            if 6 not in scores[1000]:
+                raise Exception('Didn\'t get beginner score back for song {}!'.format(1000))
+            if scores[1000][6] != {'clear_status': 4, 'ex_score': -1, 'miss_count': -1}:
+                raise Exception('Didn\'t get correct status back from beginner save!')
+
+            # Verify DAN score saving and loading
+            self.verify_grade_raised(profile['extid'], newname, 'sp')
+            self.verify_grade_raised(profile['extid'], newname, 'dp')
+            profile = self.verify_pc_get(ref_id, card, lid)
+            if profile['sp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for SP!')
+            if profile['dp_dan'] != 5:
+                raise Exception('Got wrong DAN score back for DP!')
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/jubeat/__init__.py b/bemani/client/jubeat/__init__.py
new file mode 100644
index 0000000..280b8f7
--- /dev/null
+++ b/bemani/client/jubeat/__init__.py
@@ -0,0 +1,5 @@
+from bemani.client.jubeat.saucer import JubeatSaucerClient
+from bemani.client.jubeat.saucerfulfill import JubeatSaucerFulfillClient
+from bemani.client.jubeat.prop import JubeatPropClient
+from bemani.client.jubeat.qubell import JubeatQubellClient
+from bemani.client.jubeat.clan import JubeatClanClient
diff --git a/bemani/client/jubeat/clan.py b/bemani/client/jubeat/clan.py
new file mode 100644
index 0000000..55be5be
--- /dev/null
+++ b/bemani/client/jubeat/clan.py
@@ -0,0 +1,738 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.common import CardCipher, Time
+from bemani.protocol import Node
+
+
+class JubeatClanClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_shopinfo_regist(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        shopinfo = Node.void('shopinfo')
+        shopinfo.set_attribute('method', 'regist')
+        call.add_child(shopinfo)
+        shop = Node.void('shop')
+        shopinfo.add_child(shop)
+        shop.add_child(Node.string('name', ''))
+        shop.add_child(Node.string('pref', 'JP-14'))
+        shop.add_child(Node.string('softwareid', ''))
+        shop.add_child(Node.string('systemid', self.pcbid))
+        shop.add_child(Node.string('hardwareid', '01020304050607080900'))
+        shop.add_child(Node.string('locationid', 'US-1'))
+        shop.add_child(Node.string('monitor', 'D26L155             6252     151'))
+        testmode = Node.void('testmode')
+        shop.add_child(testmode)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shopinfo/data/cabid")
+        self.assert_path(resp, "response/shopinfo/data/locationid")
+        self.assert_path(resp, "response/shopinfo/data/tax_phase")
+        self.assert_path(resp, "response/shopinfo/data/facility/exist")
+        self.assert_path(resp, "response/shopinfo/data/info/event_info")
+        self.assert_path(resp, "response/shopinfo/data/info/share_music")
+        self.assert_path(resp, "response/shopinfo/data/info/genre_def_music")
+        self.assert_path(resp, "response/shopinfo/data/info/black_jacket_list")
+        self.assert_path(resp, "response/shopinfo/data/info/white_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/white_marker_list")
+        self.assert_path(resp, "response/shopinfo/data/info/white_theme_list")
+        self.assert_path(resp, "response/shopinfo/data/info/open_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/shareable_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/point")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/shopinfo/data/info/born/status")
+        self.assert_path(resp, "response/shopinfo/data/info/born/year")
+        self.assert_path(resp, "response/shopinfo/data/info/collection/rating_s")
+        self.assert_path(resp, "response/shopinfo/data/info/expert_option/is_available")
+        self.assert_path(resp, "response/shopinfo/data/info/all_music_matching/is_available")
+        self.assert_path(resp, "response/shopinfo/data/info/all_music_matching/team/default_flag")
+        self.assert_path(resp, "response/shopinfo/data/info/all_music_matching/team/redbelk_flag")
+        self.assert_path(resp, "response/shopinfo/data/info/all_music_matching/team/cyanttle_flag")
+        self.assert_path(resp, "response/shopinfo/data/info/all_music_matching/team/greenesia_flag")
+        self.assert_path(resp, "response/shopinfo/data/info/all_music_matching/team/plumpark_flag")
+        self.assert_path(resp, "response/shopinfo/data/info/question_list")
+        self.assert_path(resp, "response/shopinfo/data/info/drop_list")
+        self.assert_path(resp, "response/shopinfo/data/info/daily_bonus_list")
+        self.assert_path(resp, "response/shopinfo/data/info/department/pack_list")
+
+    def verify_demodata_get_info(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_info')
+        pcbinfo = Node.void('pcbinfo')
+        demodata.add_child(pcbinfo)
+        pcbinfo.set_attribute('client_data_version', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/data/info/black_jacket_list")
+
+    def verify_demodata_get_news(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_news')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/data/officialnews")
+
+    def verify_demodata_get_jbox_list(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_jbox_list')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/@status")
+
+    def __verify_profile(self, resp: Node) -> int:
+        self.assert_path(resp, "response/gametop/data/info/event_info")
+        self.assert_path(resp, "response/gametop/data/info/share_music")
+        self.assert_path(resp, "response/gametop/data/info/genre_def_music")
+        self.assert_path(resp, "response/gametop/data/info/black_jacket_list")
+        self.assert_path(resp, "response/gametop/data/info/white_music_list")
+        self.assert_path(resp, "response/gametop/data/info/white_marker_list")
+        self.assert_path(resp, "response/gametop/data/info/white_theme_list")
+        self.assert_path(resp, "response/gametop/data/info/open_music_list")
+        self.assert_path(resp, "response/gametop/data/info/shareable_music_list")
+        self.assert_path(resp, "response/gametop/data/info/jbox/point")
+        self.assert_path(resp, "response/gametop/data/info/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/gametop/data/info/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/gametop/data/info/born/status")
+        self.assert_path(resp, "response/gametop/data/info/born/year")
+        self.assert_path(resp, "response/gametop/data/info/collection/rating_s")
+        self.assert_path(resp, "response/gametop/data/info/expert_option/is_available")
+        self.assert_path(resp, "response/gametop/data/info/all_music_matching/is_available")
+        self.assert_path(resp, "response/gametop/data/info/all_music_matching/team/default_flag")
+        self.assert_path(resp, "response/gametop/data/info/all_music_matching/team/redbelk_flag")
+        self.assert_path(resp, "response/gametop/data/info/all_music_matching/team/cyanttle_flag")
+        self.assert_path(resp, "response/gametop/data/info/all_music_matching/team/greenesia_flag")
+        self.assert_path(resp, "response/gametop/data/info/all_music_matching/team/plumpark_flag")
+        self.assert_path(resp, "response/gametop/data/info/question_list")
+        self.assert_path(resp, "response/gametop/data/info/drop_list")
+        self.assert_path(resp, "response/gametop/data/info/daily_bonus_list")
+        self.assert_path(resp, "response/gametop/data/info/department/pack_list")
+
+        for item in [
+            'tune_cnt',
+            'save_cnt',
+            'saved_cnt',
+            'fc_cnt',
+            'ex_cnt',
+            'clear_cnt',
+            'match_cnt',
+            'beat_cnt',
+            'mynews_cnt',
+            'bonus_tune_points',
+            'is_bonus_tune_played',
+            'inherit',
+            'mtg_entry_cnt',
+            'mtg_hold_cnt',
+            'mtg_result',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/info/{}".format(item))
+
+        for item in [
+            'music_list',
+            'secret_list',
+            'theme_list',
+            'marker_list',
+            'title_list',
+            'parts_list',
+            'emblem_list',
+            'commu_list',
+            'new/secret_list',
+            'new/theme_list',
+            'new/marker_list',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/item/{}".format(item))
+
+        for item in [
+            'play_time',
+            'shopname',
+            'areaname',
+            'music_id',
+            'seq_id',
+            'sort',
+            'category',
+            'expert_option',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/{}".format(item))
+
+        for item in [
+            'marker',
+            'theme',
+            'title',
+            'parts',
+            'rank_sort',
+            'combo_disp',
+            'emblem',
+            'matching',
+            'hard',
+            'hazard',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/settings/{}".format(item))
+
+        # Misc stuff
+        self.assert_path(resp, "response/gametop/data/player/session_id")
+        self.assert_path(resp, "response/gametop/data/player/event_flag")
+
+        # Profile settings
+        self.assert_path(resp, "response/gametop/data/player/name")
+        self.assert_path(resp, "response/gametop/data/player/jid")
+
+        # Required nodes for events and stuff
+        self.assert_path(resp, "response/gametop/data/player/history")
+        self.assert_path(resp, "response/gametop/data/player/lab_edit_seq")
+        self.assert_path(resp, "response/gametop/data/player/event_info")
+        self.assert_path(resp, "response/gametop/data/player/navi/flag")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/today/music_id")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/today/state")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/whim/music_id")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/whim/state")
+        self.assert_path(resp, "response/gametop/data/player/official_news/news_list")
+        self.assert_path(resp, "response/gametop/data/player/rivallist")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/is_available")
+        self.assert_path(resp, "response/gametop/data/player/jbox/point")
+        self.assert_path(resp, "response/gametop/data/player/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/gametop/data/player/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/gametop/data/player/new_music")
+        self.assert_path(resp, "response/gametop/data/player/gift_list")
+        self.assert_path(resp, "response/gametop/data/player/born/status")
+        self.assert_path(resp, "response/gametop/data/player/question_list")
+        self.assert_path(resp, "response/gametop/data/player/jubility/@param")
+        self.assert_path(resp, "response/gametop/data/player/jubility/target_music_list")
+        self.assert_path(resp, "response/gametop/data/player/team/@id")
+        self.assert_path(resp, "response/gametop/data/player/team/section")
+        self.assert_path(resp, "response/gametop/data/player/team/street")
+        self.assert_path(resp, "response/gametop/data/player/team/house_number_1")
+        self.assert_path(resp, "response/gametop/data/player/team/house_number_2")
+        self.assert_path(resp, "response/gametop/data/player/team/move/@house_number_1")
+        self.assert_path(resp, "response/gametop/data/player/team/move/@house_number_2")
+        self.assert_path(resp, "response/gametop/data/player/team/move/@id")
+        self.assert_path(resp, "response/gametop/data/player/team/move/@section")
+        self.assert_path(resp, "response/gametop/data/player/team/move/@street")
+        self.assert_path(resp, "response/gametop/data/player/union_battle/@id")
+        self.assert_path(resp, "response/gametop/data/player/union_battle/power")
+        self.assert_path(resp, "response/gametop/data/player/server")
+        self.assert_path(resp, "response/gametop/data/player/eamuse_gift_list")
+        self.assert_path(resp, "response/gametop/data/player/clan_course_list")
+        self.assert_path(resp, "response/gametop/data/player/category_list")
+        self.assert_path(resp, "response/gametop/data/player/drop_list/drop/@id")
+        self.assert_path(resp, "response/gametop/data/player/drop_list/drop/exp")
+        self.assert_path(resp, "response/gametop/data/player/drop_list/drop/flag")
+        self.assert_path(resp, "response/gametop/data/player/drop_list/drop/item_list/item/@id")
+        self.assert_path(resp, "response/gametop/data/player/drop_list/drop/item_list/item/num")
+        self.assert_path(resp, "response/gametop/data/player/fill_in_category/no_gray_flag_list")
+        self.assert_path(resp, "response/gametop/data/player/fill_in_category/all_yellow_flag_list")
+        self.assert_path(resp, "response/gametop/data/player/fill_in_category/full_combo_flag_list")
+        self.assert_path(resp, "response/gametop/data/player/fill_in_category/excellent_flag_list")
+        self.assert_path(resp, "response/gametop/data/player/daily_bonus_list")
+        self.assert_path(resp, "response/gametop/data/player/ticket_list")
+
+        # Return the jid
+        return resp.child_value('gametop/data/player/jid')
+
+    def verify_gameend_regist(
+        self,
+        ref_id: str,
+        jid: int,
+        scores: List[Dict[str, Any]],
+    ) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gameend = Node.void('gameend')
+        call.add_child(gameend)
+        gameend.set_attribute('method', 'regist')
+        gameend.add_child(Node.s32('retry', 0))
+        pcbinfo = Node.void('pcbinfo')
+        gameend.add_child(pcbinfo)
+        pcbinfo.set_attribute('client_data_version', '0')
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.string('name', self.NAME))
+        result = Node.void('result')
+        data.add_child(result)
+        result.set_attribute('count', str(len(scores)))
+
+        # Send scores
+        scoreid = 0
+        for score in scores:
+            # Always played
+            bits = 0x1
+            if score['clear']:
+                bits |= 0x2
+            if score['fc']:
+                bits |= 0x4
+            if score['ex']:
+                bits |= 0x8
+
+            # Intentionally starting at 1 because that's what the game does
+            scoreid = scoreid + 1
+            tune = Node.void('tune')
+            result.add_child(tune)
+            tune.set_attribute('id', str(scoreid))
+            tune.add_child(Node.s32('music', score['id']))
+            tune.add_child(Node.s64('timestamp', Time.now() * 1000))
+            player_1 = Node.void('player')
+            tune.add_child(player_1)
+            player_1.set_attribute('rank', '1')
+            scorenode = Node.s32('score', score['score'])
+            player_1.add_child(scorenode)
+            scorenode.set_attribute('seq', str(score['chart']))
+            scorenode.set_attribute('clear', str(bits))
+            scorenode.set_attribute('combo', '69')
+            player_1.add_child(Node.u8_array('mbar', [239, 175, 170, 170, 190, 234, 187, 158, 153, 230, 170, 90, 102, 170, 85, 150, 150, 102, 85, 234, 171, 169, 157, 150, 170, 101, 230, 90, 214, 255]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/gameend/data/player/session_id")
+
+    def verify_gameend_final(
+        self,
+        ref_id: str,
+        jid: int,
+    ) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gameend = Node.void('gameend')
+        call.add_child(gameend)
+        gameend.set_attribute('method', 'final')
+        gameend.add_child(Node.s32('retry', 0))
+        pcbinfo = Node.void('pcbinfo')
+        gameend.add_child(pcbinfo)
+        pcbinfo.set_attribute('client_data_version', '0')
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.s32('jid', jid))
+        jbox = Node.void('jbox')
+        player.add_child(jbox)
+        jbox.add_child(Node.s32('point', 0))
+        emblem = Node.void('emblem')
+        jbox.add_child(emblem)
+        emblem.add_child(Node.u8('type', 0))
+        emblem.add_child(Node.s16('index', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/gameend/@status")
+
+    def verify_gametop_regist(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'regist')
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.string('datid', ref_id))
+        player.add_child(Node.string('uid', card_id))
+        player.add_child(Node.bool('inherit', True))
+        player.add_child(Node.string('name', self.NAME))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_pdata(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_pdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.string('datid', ref_id))
+        player.add_child(Node.string('uid', card_id))
+        player.add_child(Node.string('card_no', CardCipher.encode(card_id)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_mdata(self, jid: int) -> Dict[str, List[Dict[str, Any]]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_mdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        # Technically the game sends this same packet 3 times, one with
+        # each value 1, 2, 3 here. Unclear why, but we won't emulate it.
+        player.add_child(Node.s8('mdata_ver', 1))
+        player.add_child(Node.bool('rival', False))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Parse out scores
+        self.assert_path(resp, "response/gametop/data/player/mdata_list")
+
+        ret = {}
+        for musicdata in resp.child('gametop/data/player/mdata_list').children:
+            if musicdata.name != 'musicdata':
+                raise Exception('Unexpected node in playdata!')
+
+            music_id = musicdata.attribute('music_id')
+            scores_by_chart: List[Dict[str, int]] = [{}, {}, {}]
+
+            def extract_cnts(name: str, val: List[int]) -> None:
+                scores_by_chart[0][name] = val[0]
+                scores_by_chart[1][name] = val[1]
+                scores_by_chart[2][name] = val[2]
+
+            extract_cnts('plays', musicdata.child_value('play_cnt'))
+            extract_cnts('clears', musicdata.child_value('clear_cnt'))
+            extract_cnts('full_combos', musicdata.child_value('fc_cnt'))
+            extract_cnts('excellents', musicdata.child_value('ex_cnt'))
+            extract_cnts('score', musicdata.child_value('score'))
+            extract_cnts('medal', musicdata.child_value('clear'))
+            ret[music_id] = scores_by_chart
+
+        return ret
+
+    def verify_gametop_get_meeting(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_meeting')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        pcbinfo = Node.void('pcbinfo')
+        gametop.add_child(pcbinfo)
+        pcbinfo.set_attribute('client_data_version', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/meeting/single/@count")
+        self.assert_path(resp, "response/gametop/data/meeting/tag/@count")
+        self.assert_path(resp, "response/gametop/data/reward/total")
+        self.assert_path(resp, "response/gametop/data/reward/point")
+
+    def verify_recommend_get_recommend(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        recommend = Node.void('recommend')
+        call.add_child(recommend)
+        recommend.set_attribute('method', 'get_recommend')
+        recommend.add_child(Node.s32('retry', 0))
+        player = Node.void('player')
+        recommend.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.void('music_list'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/recommend/data/player/music_list")
+
+    def verify_demodata_get_hitchart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('demodata')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_hitchart')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/demodata/data/update")
+        self.assert_path(resp, "response/demodata/data/hitchart_lic")
+        self.assert_path(resp, "response/demodata/data/hitchart_org")
+
+    def verify_jbox_get_list(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        jbox = Node.void('jbox')
+        call.add_child(jbox)
+        jbox.set_attribute('method', 'get_list')
+        data = Node.void('data')
+        jbox.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/jbox/selection_list")
+
+    def verify_jbox_get_agreement(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        jbox = Node.void('jbox')
+        call.add_child(jbox)
+        jbox.set_attribute('method', 'get_agreement')
+        data = Node.void('data')
+        jbox.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/jbox/is_agreement")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive(ecflag=3)
+        self.verify_package_list()
+        self.verify_message_get()
+        self.verify_facility_get(encoding='Shift-JIS')
+        self.verify_pcbevent_put()
+        self.verify_shopinfo_regist()
+        self.verify_demodata_get_info()
+        self.verify_demodata_get_news()
+        self.verify_demodata_get_jbox_list()
+        self.verify_demodata_get_hitchart()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_gametop_regist(card, ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            self.verify_recommend_get_recommend(jid)
+            scores = self.verify_gametop_get_mdata(jid)
+            self.verify_gametop_get_meeting(jid)
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            if len(scores) > 0:
+                raise Exception('Got nonzero score count on a new card!')
+
+            # Verify end of game behavior
+            self.verify_jbox_get_list(jid)
+            self.verify_jbox_get_agreement(jid)
+            self.verify_gameend_final(ref_id, jid)
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 40000059,
+                            'chart': 2,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 800000,
+                            'expected_medal': 0x3,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': True,
+                            'ex': False,
+                            'score': 990000,
+                            'expected_medal': 0x5,
+                        },
+                        # A perfect score on an easiest chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': True,
+                            'ex': True,
+                            'score': 1000000,
+                            'expected_medal': 0x9,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 30000024,
+                            'chart': 2,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 400000,
+                            'expected_medal': 0x1,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 100000,
+                            'expected_medal': 0x1,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 850000,
+                            'expected_medal': 0x3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 925000,
+                            'expected_score': 990000,
+                            'expected_medal': 0x7,
+                        },
+                    ]
+
+                self.verify_gameend_regist(ref_id, jid, dummyscores)
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                scores = self.verify_gametop_get_mdata(jid)
+
+                for score in dummyscores:
+                    newscore = scores[str(score['id'])][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+
+                    if newscore['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore['score'],
+                        ))
+
+                    if newscore['medal'] != score['expected_medal']:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            score['expected_medal'], score['id'], score['chart'], newscore['medal'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/jubeat/prop.py b/bemani/client/jubeat/prop.py
new file mode 100644
index 0000000..2ac8c41
--- /dev/null
+++ b/bemani/client/jubeat/prop.py
@@ -0,0 +1,802 @@
+import random
+import time
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.client.base import BaseClient
+from bemani.common import CardCipher
+from bemani.protocol import Node
+
+
+class JubeatPropClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_shopinfo_regist(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        shopinfo = Node.void('shopinfo')
+        shopinfo.set_attribute('method', 'regist')
+        call.add_child(shopinfo)
+        shop = Node.void('shop')
+        shopinfo.add_child(shop)
+        shop.add_child(Node.string('name', ''))
+        shop.add_child(Node.string('pref', 'JP-14'))
+        shop.add_child(Node.string('softwareid', ''))
+        shop.add_child(Node.string('systemid', self.pcbid))
+        shop.add_child(Node.string('hardwareid', '01020304050607080900'))
+        shop.add_child(Node.string('locationid', 'US-1'))
+        shop.add_child(Node.string('monitor', 'D26L155             6252     151'))
+        testmode = Node.void('testmode')
+        shop.add_child(testmode)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shopinfo/data/cabid")
+        self.assert_path(resp, "response/shopinfo/data/locationid")
+        self.assert_path(resp, "response/shopinfo/data/tax_phase")
+        self.assert_path(resp, "response/shopinfo/data/facility/exist")
+        self.assert_path(resp, "response/shopinfo/data/info/event_info")
+        self.assert_path(resp, "response/shopinfo/data/info/share_music")
+        self.assert_path(resp, "response/shopinfo/data/info/bonus_music")
+        self.assert_path(resp, "response/shopinfo/data/info/only_now_music")
+        self.assert_path(resp, "response/shopinfo/data/info/fc_challenge/today/music_id")
+        self.assert_path(resp, "response/shopinfo/data/info/white_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/open_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/cabinet_survey/id")
+        self.assert_path(resp, "response/shopinfo/data/info/cabinet_survey/status")
+        self.assert_path(resp, "response/shopinfo/data/info/kaitou_bisco/remaining_days")
+        self.assert_path(resp, "response/shopinfo/data/info/league/status")
+        self.assert_path(resp, "response/shopinfo/data/info/bistro/bistro_id")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/point")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/emblem/premium/index")
+
+    def verify_demodata_get_news(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_news')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/data/officialnews")
+
+    def __verify_profile(self, resp: Node) -> int:
+        self.assert_path(resp, "response/gametop/data/info/event_info")
+        self.assert_path(resp, "response/gametop/data/info/share_music")
+        self.assert_path(resp, "response/gametop/data/info/bonus_music")
+        self.assert_path(resp, "response/gametop/data/info/only_now_music")
+        self.assert_path(resp, "response/gametop/data/info/fc_challenge/today/music_id")
+        self.assert_path(resp, "response/gametop/data/info/white_music_list")
+        self.assert_path(resp, "response/gametop/data/info/open_music_list")
+        self.assert_path(resp, "response/gametop/data/info/cabinet_survey/id")
+        self.assert_path(resp, "response/gametop/data/info/cabinet_survey/status")
+        self.assert_path(resp, "response/gametop/data/info/kaitou_bisco/remaining_days")
+        self.assert_path(resp, "response/gametop/data/info/league/status")
+        self.assert_path(resp, "response/gametop/data/info/bistro/bistro_id")
+        self.assert_path(resp, "response/gametop/data/info/jbox/point")
+        self.assert_path(resp, "response/gametop/data/info/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/gametop/data/info/jbox/emblem/premium/index")
+
+        for item in [
+            'jubility',
+            'jubility_yday',
+            'tune_cnt',
+            'save_cnt',
+            'saved_cnt',
+            'fc_cnt',
+            'ex_cnt',
+            'clear_cnt',
+            'pf_cnt',
+            'match_cnt',
+            'beat_cnt',
+            'mynews_cnt',
+            'bonus_tune_points',
+            'is_bonus_tune_played',
+            'inherit',
+            'mtg_entry_cnt',
+            'mtg_hold_cnt',
+            'mtg_result',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/info/{}".format(item))
+
+        for item in [
+            'music_list',
+            'secret_list',
+            'theme_list',
+            'marker_list',
+            'title_list',
+            'parts_list',
+            'emblem_list',
+            'new/secret_list',
+            'new/theme_list',
+            'new/marker_list',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/item/{}".format(item))
+
+        for item in [
+            'play_time',
+            'shopname',
+            'areaname',
+            'expert_option',
+            'category',
+            'sort',
+            'music_id',
+            'seq_id',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/{}".format(item))
+
+        for item in [
+            'marker',
+            'theme',
+            'title',
+            'parts',
+            'rank_sort',
+            'combo_disp',
+            'emblem',
+            'matching',
+            'hazard',
+            'hard',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/settings/{}".format(item))
+
+        # Misc stuff
+        self.assert_path(resp, "response/gametop/data/player/session_id")
+        self.assert_path(resp, "response/gametop/data/player/event_flag")
+
+        # Profile settings
+        self.assert_path(resp, "response/gametop/data/player/name")
+        self.assert_path(resp, "response/gametop/data/player/jid")
+
+        # Required nodes for events and stuff
+        self.assert_path(resp, "response/gametop/data/player/history")
+        self.assert_path(resp, "response/gametop/data/player/lab_edit_seq")
+        self.assert_path(resp, "response/gametop/data/player/event_info")
+        self.assert_path(resp, "response/gametop/data/player/cabinet_survey/read_flag")
+        self.assert_path(resp, "response/gametop/data/player/kaitou_bisco/read_flag")
+        self.assert_path(resp, "response/gametop/data/player/navi/flag")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/today/music_id")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/today/state")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/whim/music_id")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/whim/state")
+        self.assert_path(resp, "response/gametop/data/player/news/checked")
+        self.assert_path(resp, "response/gametop/data/player/news/checked_flag")
+        self.assert_path(resp, "response/gametop/data/player/rivallist")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/is_available")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/point")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/point_used")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/come_come_jbox/is_valid")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/come_come_jbox/end_time_if_paired")
+        self.assert_path(resp, "response/gametop/data/player/jbox/point")
+        self.assert_path(resp, "response/gametop/data/player/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/gametop/data/player/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/gametop/data/player/career/level")
+        self.assert_path(resp, "response/gametop/data/player/career/point")
+        self.assert_path(resp, "response/gametop/data/player/career/param")
+        self.assert_path(resp, "response/gametop/data/player/career/is_unlocked")
+        self.assert_path(resp, "response/gametop/data/player/league/is_first_play")
+        self.assert_path(resp, "response/gametop/data/player/league/class")
+        self.assert_path(resp, "response/gametop/data/player/league/subclass")
+        self.assert_path(resp, "response/gametop/data/player/new_music")
+        self.assert_path(resp, "response/gametop/data/player/eapass_privilege/emblem_list")
+        self.assert_path(resp, "response/gametop/data/player/bonus_music/music")
+        self.assert_path(resp, "response/gametop/data/player/bonus_music/event_id")
+        self.assert_path(resp, "response/gametop/data/player/bonus_music/till_time")
+        self.assert_path(resp, "response/gametop/data/player/bistro/chef/id")
+        self.assert_path(resp, "response/gametop/data/player/bistro/carry_over")
+        self.assert_path(resp, "response/gametop/data/player/bistro/route_list/route_count")
+        self.assert_path(resp, "response/gametop/data/player/bistro/extension")
+        self.assert_path(resp, "response/gametop/data/player/gift_list")
+
+        # Return the jid
+        return resp.child_value('gametop/data/player/jid')
+
+    def verify_gameend_regist(
+        self,
+        ref_id: str,
+        jid: int,
+        scores: List[Dict[str, Any]],
+        course: Dict[str, Any],
+        league: Optional[Tuple[int, Tuple[int, int, int]]],
+    ) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gameend = Node.void('gameend')
+        call.add_child(gameend)
+        gameend.set_attribute('method', 'regist')
+        gameend.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.string('name', self.NAME))
+        result = Node.void('result')
+        data.add_child(result)
+        result.set_attribute('count', str(len(scores)))
+
+        # Send scores
+        scoreid = 0
+        for score in scores:
+            # Always played
+            bits = 0x1
+            if score['clear']:
+                bits |= 0x2
+            if score['fc']:
+                bits |= 0x4
+            if score['ex']:
+                bits |= 0x8
+
+            # Intentionally starting at 1 because that's what the game does
+            scoreid = scoreid + 1
+            tune = Node.void('tune')
+            result.add_child(tune)
+            tune.set_attribute('id', str(scoreid))
+            tune.set_attribute('count', '0')
+            tune.add_child(Node.s32('music', score['id']))
+            player_1 = Node.void('player')
+            tune.add_child(player_1)
+            player_1.set_attribute('rank', '1')
+            scorenode = Node.s32('score', score['score'])
+            player_1.add_child(scorenode)
+            scorenode.set_attribute('seq', str(score['chart']))
+            scorenode.set_attribute('clear', str(bits))
+            scorenode.set_attribute('combo', '69')
+            player_1.add_child(Node.u8_array('mbar', [239, 175, 170, 170, 190, 234, 187, 158, 153, 230, 170, 90, 102, 170, 85, 150, 150, 102, 85, 234, 171, 169, 157, 150, 170, 101, 230, 90, 214, 255]))
+
+        if len(course) > 0:
+            coursenode = Node.void('course')
+            player.add_child(coursenode)
+            coursenode.add_child(Node.s32('course_id', course['course_id']))
+            coursenode.add_child(Node.u8('rating', course['rating']))
+            index = 0
+            for coursescore in course['scores']:
+                music = Node.void('music')
+                coursenode.add_child(music)
+                music.set_attribute('index', str(index))
+                music.add_child(Node.s32('score', coursescore))
+                index = index + 1
+
+        if league is not None:
+            leaguenode = Node.void('league')
+            player.add_child(leaguenode)
+            leaguenode.add_child(Node.s32('league_id', league[0]))
+            leaguenode.add_child(Node.bool('is_first_play', False))
+            leaguenode.add_child(Node.bool('is_checked', True))
+
+            index = 0
+            for leaguescore in league[1]:
+                musicnode = Node.void('music')
+                leaguenode.add_child(musicnode)
+                musicnode.set_attribute('index', str(index))
+                index = index + 1
+
+                scorenode = Node.s32('score', leaguescore)
+                musicnode.add_child(scorenode)
+                scorenode.set_attribute('clear', '3')
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/gameend/data/player/session_id")
+
+    def verify_gametop_regist(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'regist')
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.string('datid', ref_id))
+        player.add_child(Node.string('uid', card_id))
+        player.add_child(Node.bool('inherit', True))
+        player.add_child(Node.string('name', self.NAME))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_pdata(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_pdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.string('datid', ref_id))
+        player.add_child(Node.string('uid', card_id))
+        player.add_child(Node.string('card_no', CardCipher.encode(card_id)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_mdata(self, jid: int) -> Dict[str, List[Dict[str, Any]]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_mdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        # Technically the game sends this same packet 3 times, one with
+        # each value 1, 2, 3 here. Unclear why, but we won't emulate it.
+        player.add_child(Node.s8('mdata_ver', 1))
+        player.add_child(Node.bool('rival', False))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Parse out scores
+        self.assert_path(resp, "response/gametop/data/player/mdata_list")
+
+        ret = {}
+        for musicdata in resp.child('gametop/data/player/mdata_list').children:
+            if musicdata.name != 'musicdata':
+                raise Exception('Unexpected node in playdata!')
+
+            music_id = musicdata.attribute('music_id')
+            scores_by_chart: List[Dict[str, int]] = [{}, {}, {}]
+
+            def extract_cnts(name: str, val: List[int]) -> None:
+                scores_by_chart[0][name] = val[0]
+                scores_by_chart[1][name] = val[1]
+                scores_by_chart[2][name] = val[2]
+
+            extract_cnts('plays', musicdata.child_value('play_cnt'))
+            extract_cnts('clears', musicdata.child_value('clear_cnt'))
+            extract_cnts('full_combos', musicdata.child_value('fc_cnt'))
+            extract_cnts('excellents', musicdata.child_value('ex_cnt'))
+            extract_cnts('score', musicdata.child_value('score'))
+            extract_cnts('medal', musicdata.child_value('clear'))
+            ret[music_id] = scores_by_chart
+
+        return ret
+
+    def verify_gametop_get_course(self, jid: int) -> List[Dict[str, Any]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_course')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/course_list")
+        self.assert_path(resp, "response/gametop/data/player_list")
+        self.assert_path(resp, "response/gametop/data/last_course_id")
+
+        playernode = None
+        for player in resp.child('gametop/data/player_list').children:
+            if player.child_value('jid') == jid:
+                playernode = player
+                break
+
+        if playernode is None:
+            raise Exception("Didn't find any scores for ExtID {}".format(jid))
+
+        ret = []
+        for result in playernode.child('result_list').children:
+            if result.name != 'result':
+                raise Exception('Unexpected node in result_list!')
+
+            course_id = result.child_value('id')
+            rating = result.child_value('rating')
+            scores = result.child_value('score')
+
+            ret.append({'course_id': course_id, 'rating': rating, 'scores': scores})
+
+        return ret
+
+    def verify_gametop_get_league(self, jid: int) -> Tuple[int, Tuple[int, int, int]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_league')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.s32_array('rival_jid', [0] * 3))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/league_list/league/player_list")
+        self.assert_path(resp, "response/gametop/data/last_class")
+        self.assert_path(resp, "response/gametop/data/last_subclass")
+        self.assert_path(resp, "response/gametop/data/is_checked")
+
+        leagueid = resp.child_value('gametop/data/league_list/league/id')
+        playernode = None
+        for player in resp.child('gametop/data/league_list/league/player_list').children:
+            if player.child_value('jid') == jid:
+                playernode = player
+                break
+
+        if playernode is None:
+            raise Exception("Didn't find any scores for ExtID {}".format(jid))
+
+        result = playernode.child_value('result/score')
+        if result is not None:
+            return (leagueid, (result[0], result[1], result[2]))
+        else:
+            return (leagueid, (0, 0, 0))
+
+    def verify_gametop_get_meeting(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_meeting')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/meeting/single")
+        self.assert_path(resp, "response/gametop/data/meeting/tag")
+        self.assert_path(resp, "response/gametop/data/reward/total")
+        self.assert_path(resp, "response/gametop/data/reward/point")
+
+    def verify_demodata_get_hitchart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('demodata')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_hitchart')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/demodata/data/update")
+        self.assert_path(resp, "response/demodata/data/hitchart_lic")
+        self.assert_path(resp, "response/demodata/data/hitchart_org")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_shopinfo_regist()
+        self.verify_demodata_get_news()
+        self.verify_demodata_get_hitchart()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_gametop_regist(card, ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            scores = self.verify_gametop_get_mdata(jid)
+            courses = self.verify_gametop_get_course(jid)
+            league = self.verify_gametop_get_league(jid)
+            self.verify_gametop_get_meeting(jid)
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            if courses is None:
+                raise Exception('Expected to get courses back, didn\'t get anything!')
+            if league is None:
+                raise Exception('Expected to get league back, didn\'t get anything!')
+            if len(scores) > 0:
+                raise Exception('Got nonzero score count on a new card!')
+            if len(courses) > 0:
+                raise Exception('Got nonzero course count on a new card!')
+            if league[1][0] != 0 or league[1][1] != 0 or league[1][2] != 0:
+                raise Exception('Got nonzero league score on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 40000059,
+                            'chart': 2,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 800000,
+                            'expected_medal': 0x3,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': True,
+                            'ex': False,
+                            'score': 990000,
+                            'expected_medal': 0x5,
+                        },
+                        # A perfect score on an easiest chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': True,
+                            'ex': True,
+                            'score': 1000000,
+                            'expected_medal': 0x9,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 30000024,
+                            'chart': 2,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 400000,
+                            'expected_medal': 0x1,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 100000,
+                            'expected_medal': 0x1,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 850000,
+                            'expected_medal': 0x3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 925000,
+                            'expected_score': 990000,
+                            'expected_medal': 0x7,
+                        },
+                    ]
+
+                self.verify_gameend_regist(ref_id, jid, dummyscores, {}, None)
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                scores = self.verify_gametop_get_mdata(jid)
+                courses = self.verify_gametop_get_course(jid)
+                league = self.verify_gametop_get_league(jid)
+                if len(courses) > 0:
+                    raise Exception('Got nonzero course count without playing any courses!')
+                if league[1][0] != 0 or league[1][1] != 0 or league[1][2] != 0:
+                    raise Exception('Got nonzero league count without playing any league!')
+
+                for score in dummyscores:
+                    newscore = scores[str(score['id'])][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+
+                    if newscore['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore['score'],
+                        ))
+
+                    if newscore['medal'] != score['expected_medal']:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            score['expected_medal'], score['id'], score['chart'], newscore['medal'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            for phase in [1, 2]:
+                dummycourses: List[Dict[str, Any]] = []
+                if phase == 1:
+                    dummycourses.extend([
+                        {
+                            'course_id': 1,
+                            'rating': 1,
+                            'scores': [123456, 123457, 123458, 123459, 123460],
+                        },
+                        {
+                            'course_id': 2,
+                            'rating': 2,
+                            'scores': [123456, 123457, 123458, 123459, 123460],
+                        },
+                    ])
+                else:
+                    dummycourses.extend([
+                        {
+                            'course_id': 1,
+                            'rating': 2,
+                            'scores': [223456, 223457, 223458, 223459, 223460],
+                        },
+                        {
+                            'course_id': 2,
+                            'rating': 1,
+                            'expected_rating': 2,
+                            'scores': [23456, 23457, 23458, 23459, 23460],
+                            'expected_scores': [123456, 123457, 123458, 123459, 123460],
+                        },
+                    ])
+
+                for course in dummycourses:
+                    self.verify_gameend_regist(ref_id, jid, [], course, None)
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                courses = self.verify_gametop_get_course(jid)
+
+                for course in dummycourses:
+                    # Find the course
+                    foundcourses = [c for c in courses if c['course_id'] == course['course_id']]
+
+                    if len(foundcourses) == 0:
+                        raise Exception("Didn't find course by ID {}".format(course['course_id']))
+                    foundcourse = foundcourses[0]
+
+                    if 'expected_rating' in course:
+                        expected_rating = course['expected_rating']
+                    else:
+                        expected_rating = course['rating']
+
+                    if 'expected_scores' in course:
+                        expected_scores = course['expected_scores']
+                    else:
+                        expected_scores = course['scores']
+
+                    if foundcourse['course_id'] != course['course_id']:
+                        raise Exception("Logic error!")
+
+                    if foundcourse['rating'] != expected_rating:
+                        raise Exception('Expected a rating of \'{}\' for course \'{}\' but got rating \'{}\''.format(
+                            expected_rating, course['course_id'], foundcourse['rating'],
+                        ))
+
+                    for i in range(len(expected_scores)):
+                        if foundcourse['scores'][i] != expected_scores[i]:
+                            raise Exception('Expected a score of \'{}\' for course \'{}\' song number \'{}\' but got score \'{}\''.format(
+                                expected_scores[i], course['course_id'], i, foundcourse['scores'][i],
+                            ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            # Play a league course, save the score
+            self.verify_gameend_regist(ref_id, jid, [], {}, (league[0], (123456, 234567, 345678)))
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            league = self.verify_gametop_get_league(jid)
+
+            if league[1][0] != 123456 or league[1][1] != 234567 or league[1][2] != 345678:
+                raise Exception('League score didn\t save! Got wrong values {}, {}, {} back!'.format(
+                    league[1][0],
+                    league[1][1],
+                    league[1][2],
+                ))
+
+            # Play a league course, do worse, make sure it doesn't overwrite
+            self.verify_gameend_regist(ref_id, jid, [], {}, (league[0], (12345, 23456, 34567)))
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            league = self.verify_gametop_get_league(jid)
+
+            if league[1][0] != 123456 or league[1][1] != 234567 or league[1][2] != 345678:
+                raise Exception('League score got overwritten! Got wrong values {}, {}, {} back!'.format(
+                    league[1][0],
+                    league[1][1],
+                    league[1][2],
+                ))
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/jubeat/qubell.py b/bemani/client/jubeat/qubell.py
new file mode 100644
index 0000000..3b08d7b
--- /dev/null
+++ b/bemani/client/jubeat/qubell.py
@@ -0,0 +1,593 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.common import CardCipher, Time
+from bemani.protocol import Node
+
+
+class JubeatQubellClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_shopinfo_regist(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        shopinfo = Node.void('shopinfo')
+        shopinfo.set_attribute('method', 'regist')
+        call.add_child(shopinfo)
+        shop = Node.void('shop')
+        shopinfo.add_child(shop)
+        shop.add_child(Node.string('name', ''))
+        shop.add_child(Node.string('pref', 'JP-14'))
+        shop.add_child(Node.string('softwareid', ''))
+        shop.add_child(Node.string('systemid', self.pcbid))
+        shop.add_child(Node.string('hardwareid', '01020304050607080900'))
+        shop.add_child(Node.string('locationid', 'US-1'))
+        shop.add_child(Node.string('monitor', 'D26L155             6252     151'))
+        testmode = Node.void('testmode')
+        shop.add_child(testmode)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shopinfo/data/cabid")
+        self.assert_path(resp, "response/shopinfo/data/locationid")
+        self.assert_path(resp, "response/shopinfo/data/tax_phase")
+        self.assert_path(resp, "response/shopinfo/data/facility/exist")
+        self.assert_path(resp, "response/shopinfo/data/info/event_info")
+        self.assert_path(resp, "response/shopinfo/data/info/share_music")
+        self.assert_path(resp, "response/shopinfo/data/info/bonus_music")
+        self.assert_path(resp, "response/shopinfo/data/info/white_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/white_marker_list")
+        self.assert_path(resp, "response/shopinfo/data/info/white_theme_list")
+        self.assert_path(resp, "response/shopinfo/data/info/open_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/shareable_music_list")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/point")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/shopinfo/data/info/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/shopinfo/data/info/born/status")
+        self.assert_path(resp, "response/shopinfo/data/info/born/year")
+        self.assert_path(resp, "response/shopinfo/data/info/digdig/stage_list")
+        self.assert_path(resp, "response/shopinfo/data/info/collection/rating_s")
+        self.assert_path(resp, "response/shopinfo/data/info/generic_dig/map_list")
+
+    def verify_demodata_get_news(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_news')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/data/officialnews")
+
+    def __verify_profile(self, resp: Node) -> int:
+        self.assert_path(resp, "response/gametop/data/info/event_info")
+        self.assert_path(resp, "response/gametop/data/info/share_music")
+        self.assert_path(resp, "response/gametop/data/info/bonus_music")
+        self.assert_path(resp, "response/gametop/data/info/white_music_list")
+        self.assert_path(resp, "response/gametop/data/info/white_marker_list")
+        self.assert_path(resp, "response/gametop/data/info/white_theme_list")
+        self.assert_path(resp, "response/gametop/data/info/open_music_list")
+        self.assert_path(resp, "response/gametop/data/info/shareable_music_list")
+        self.assert_path(resp, "response/gametop/data/info/jbox/point")
+        self.assert_path(resp, "response/gametop/data/info/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/gametop/data/info/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/gametop/data/info/born/status")
+        self.assert_path(resp, "response/gametop/data/info/born/year")
+        self.assert_path(resp, "response/gametop/data/info/digdig/stage_list")
+        self.assert_path(resp, "response/gametop/data/info/collection/rating_s")
+        self.assert_path(resp, "response/gametop/data/info/generic_dig/map_list")
+
+        for item in [
+            'jubility',
+            'jubility_yday',
+            'tune_cnt',
+            'save_cnt',
+            'saved_cnt',
+            'fc_cnt',
+            'ex_cnt',
+            'clear_cnt',
+            'match_cnt',
+            'beat_cnt',
+            'mynews_cnt',
+            'bonus_tune_points',
+            'is_bonus_tune_played',
+            'inherit',
+            'mtg_entry_cnt',
+            'mtg_hold_cnt',
+            'mtg_result',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/info/{}".format(item))
+
+        for item in [
+            'music_list',
+            'secret_list',
+            'theme_list',
+            'marker_list',
+            'title_list',
+            'parts_list',
+            'emblem_list',
+            'new/secret_list',
+            'new/theme_list',
+            'new/marker_list',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/item/{}".format(item))
+
+        for item in [
+            'play_time',
+            'shopname',
+            'areaname',
+            'expert_option',
+            'category',
+            'sort',
+            'music_id',
+            'seq_id',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/{}".format(item))
+
+        for item in [
+            'marker',
+            'theme',
+            'title',
+            'parts',
+            'rank_sort',
+            'combo_disp',
+            'emblem',
+            'matching',
+            'hazard',
+            'hard',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/settings/{}".format(item))
+
+        # Misc stuff
+        self.assert_path(resp, "response/gametop/data/player/session_id")
+        self.assert_path(resp, "response/gametop/data/player/event_flag")
+
+        # Profile settings
+        self.assert_path(resp, "response/gametop/data/player/name")
+        self.assert_path(resp, "response/gametop/data/player/jid")
+
+        # Required nodes for events and stuff
+        self.assert_path(resp, "response/gametop/data/player/history")
+        self.assert_path(resp, "response/gametop/data/player/lab_edit_seq")
+        self.assert_path(resp, "response/gametop/data/player/event_info")
+        self.assert_path(resp, "response/gametop/data/player/navi/flag")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/today/music_id")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/today/state")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/whim/music_id")
+        self.assert_path(resp, "response/gametop/data/player/fc_challenge/whim/state")
+        self.assert_path(resp, "response/gametop/data/player/news/checked")
+        self.assert_path(resp, "response/gametop/data/player/news/checked_flag")
+        self.assert_path(resp, "response/gametop/data/player/rivallist")
+        self.assert_path(resp, "response/gametop/data/player/free_first_play/is_available")
+        self.assert_path(resp, "response/gametop/data/player/jbox/point")
+        self.assert_path(resp, "response/gametop/data/player/jbox/emblem/normal/index")
+        self.assert_path(resp, "response/gametop/data/player/jbox/emblem/premium/index")
+        self.assert_path(resp, "response/gametop/data/player/new_music")
+        self.assert_path(resp, "response/gametop/data/player/gift_list")
+        self.assert_path(resp, "response/gametop/data/player/born/status")
+        self.assert_path(resp, "response/gametop/data/player/born/year")
+        self.assert_path(resp, "response/gametop/data/player/generic_dig/map_list")
+        self.assert_path(resp, "response/gametop/data/player/unlock/main/stage_list")
+        self.assert_path(resp, "response/gametop/data/player/digdig/flag")
+        self.assert_path(resp, "response/gametop/data/player/digdig/main/stage/point")
+        self.assert_path(resp, "response/gametop/data/player/digdig/main/stage/param")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/ratio")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/used_point")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/point")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/excavated_point")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/state")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/item/kind")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/item/value")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/norma/till_time")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/norma/kind")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/norma/value")
+        self.assert_path(resp, "response/gametop/data/player/digdig/eternal/cube/norma/param")
+
+        # Return the jid
+        return resp.child_value('gametop/data/player/jid')
+
+    def verify_gameend_regist(
+        self,
+        ref_id: str,
+        jid: int,
+        scores: List[Dict[str, Any]],
+    ) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gameend = Node.void('gameend')
+        call.add_child(gameend)
+        gameend.set_attribute('method', 'regist')
+        gameend.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.string('name', self.NAME))
+        result = Node.void('result')
+        data.add_child(result)
+        result.set_attribute('count', str(len(scores)))
+
+        # Send scores
+        scoreid = 0
+        for score in scores:
+            # Always played
+            bits = 0x1
+            if score['clear']:
+                bits |= 0x2
+            if score['fc']:
+                bits |= 0x4
+            if score['ex']:
+                bits |= 0x8
+
+            # Intentionally starting at 1 because that's what the game does
+            scoreid = scoreid + 1
+            tune = Node.void('tune')
+            result.add_child(tune)
+            tune.set_attribute('id', str(scoreid))
+            tune.set_attribute('count', '0')
+            tune.add_child(Node.s32('music', score['id']))
+            tune.add_child(Node.s64('timestamp', Time.now() * 1000))
+            player_1 = Node.void('player')
+            tune.add_child(player_1)
+            player_1.set_attribute('rank', '1')
+            scorenode = Node.s32('score', score['score'])
+            player_1.add_child(scorenode)
+            scorenode.set_attribute('seq', str(score['chart']))
+            scorenode.set_attribute('clear', str(bits))
+            scorenode.set_attribute('combo', '69')
+            player_1.add_child(Node.u8_array('mbar', [239, 175, 170, 170, 190, 234, 187, 158, 153, 230, 170, 90, 102, 170, 85, 150, 150, 102, 85, 234, 171, 169, 157, 150, 170, 101, 230, 90, 214, 255]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/gameend/data/player/session_id")
+
+    def verify_gametop_regist(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'regist')
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.string('datid', ref_id))
+        player.add_child(Node.string('uid', card_id))
+        player.add_child(Node.bool('inherit', True))
+        player.add_child(Node.string('name', self.NAME))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_pdata(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_pdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.string('datid', ref_id))
+        player.add_child(Node.string('uid', card_id))
+        player.add_child(Node.string('card_no', CardCipher.encode(card_id)))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_mdata(self, jid: int) -> Dict[str, List[Dict[str, Any]]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_mdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        # Technically the game sends this same packet 3 times, one with
+        # each value 1, 2, 3 here. Unclear why, but we won't emulate it.
+        player.add_child(Node.s8('mdata_ver', 1))
+        player.add_child(Node.bool('rival', False))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Parse out scores
+        self.assert_path(resp, "response/gametop/data/player/mdata_list")
+
+        ret = {}
+        for musicdata in resp.child('gametop/data/player/mdata_list').children:
+            if musicdata.name != 'musicdata':
+                raise Exception('Unexpected node in playdata!')
+
+            music_id = musicdata.attribute('music_id')
+            scores_by_chart: List[Dict[str, int]] = [{}, {}, {}]
+
+            def extract_cnts(name: str, val: List[int]) -> None:
+                scores_by_chart[0][name] = val[0]
+                scores_by_chart[1][name] = val[1]
+                scores_by_chart[2][name] = val[2]
+
+            extract_cnts('plays', musicdata.child_value('play_cnt'))
+            extract_cnts('clears', musicdata.child_value('clear_cnt'))
+            extract_cnts('full_combos', musicdata.child_value('fc_cnt'))
+            extract_cnts('excellents', musicdata.child_value('ex_cnt'))
+            extract_cnts('score', musicdata.child_value('score'))
+            extract_cnts('medal', musicdata.child_value('clear'))
+            ret[music_id] = scores_by_chart
+
+        return ret
+
+    def verify_gametop_get_meeting(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_meeting')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/meeting/single")
+        self.assert_path(resp, "response/gametop/data/meeting/tag")
+        self.assert_path(resp, "response/gametop/data/reward/total")
+        self.assert_path(resp, "response/gametop/data/reward/point")
+
+    def verify_recommend_get_recommend(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        recommend = Node.void('recommend')
+        call.add_child(recommend)
+        recommend.set_attribute('method', 'get_recommend')
+        recommend.add_child(Node.s32('retry', 0))
+        player = Node.void('player')
+        recommend.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.void('music_list'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/recommend/data/player/music_list")
+
+    def verify_demodata_get_hitchart(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('demodata')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_hitchart')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/demodata/data/update")
+        self.assert_path(resp, "response/demodata/data/hitchart_lic")
+        self.assert_path(resp, "response/demodata/data/hitchart_org")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_shopinfo_regist()
+        self.verify_demodata_get_news()
+        self.verify_demodata_get_hitchart()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_gametop_regist(card, ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            self.verify_recommend_get_recommend(jid)
+            scores = self.verify_gametop_get_mdata(jid)
+            self.verify_gametop_get_meeting(jid)
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            if len(scores) > 0:
+                raise Exception('Got nonzero score count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 40000059,
+                            'chart': 2,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 800000,
+                            'expected_medal': 0x3,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': True,
+                            'ex': False,
+                            'score': 990000,
+                            'expected_medal': 0x5,
+                        },
+                        # A perfect score on an easiest chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': True,
+                            'ex': True,
+                            'score': 1000000,
+                            'expected_medal': 0x9,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 30000024,
+                            'chart': 2,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 400000,
+                            'expected_medal': 0x1,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 100000,
+                            'expected_medal': 0x1,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 850000,
+                            'expected_medal': 0x3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 925000,
+                            'expected_score': 990000,
+                            'expected_medal': 0x7,
+                        },
+                    ]
+
+                self.verify_gameend_regist(ref_id, jid, dummyscores)
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                scores = self.verify_gametop_get_mdata(jid)
+
+                for score in dummyscores:
+                    newscore = scores[str(score['id'])][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+
+                    if newscore['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore['score'],
+                        ))
+
+                    if newscore['medal'] != score['expected_medal']:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            score['expected_medal'], score['id'], score['chart'], newscore['medal'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/jubeat/saucer.py b/bemani/client/jubeat/saucer.py
new file mode 100644
index 0000000..04cd005
--- /dev/null
+++ b/bemani/client/jubeat/saucer.py
@@ -0,0 +1,489 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class JubeatSaucerClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_shopinfo_regist(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        shopinfo = Node.void('shopinfo')
+        shopinfo.set_attribute('method', 'regist')
+        call.add_child(shopinfo)
+        shop = Node.void('shop')
+        shopinfo.add_child(shop)
+        shop.add_child(Node.string('name', ''))
+        shop.add_child(Node.string('pref', 'JP-14'))
+        shop.add_child(Node.string('softwareid', ''))
+        shop.add_child(Node.string('systemid', self.pcbid))
+        shop.add_child(Node.string('hardwareid', '01020304050607080900'))
+        shop.add_child(Node.string('locationid', 'US-1'))
+        shop.add_child(Node.string('monitor', 'D26L155             6252     151'))
+        testmode = Node.void('testmode')
+        shop.add_child(testmode)
+        testmode.set_attribute('send', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shopinfo/data/cabid")
+        self.assert_path(resp, "response/shopinfo/data/locationid")
+        self.assert_path(resp, "response/shopinfo/data/is_send")
+        self.assert_path(resp, "response/shopinfo/data/white_music_list")
+        self.assert_path(resp, "response/shopinfo/data/tax_phase")
+        self.assert_path(resp, "response/shopinfo/data/lab/is_open")
+        self.assert_path(resp, "response/shopinfo/data/matching_off/is_open")
+        self.assert_path(resp, "response/shopinfo/data/vocaloid_event/state")
+        self.assert_path(resp, "response/shopinfo/data/vocaloid_event/music_id")
+
+    def verify_demodata_get_news(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_news')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/data/officialnews")
+
+    def __verify_profile(self, resp: Node) -> int:
+        for item in [
+            'jubility',
+            'jubility_yday',
+            'tune_cnt',
+            'save_cnt',
+            'saved_cnt',
+            'fc_cnt',
+            'ex_cnt',
+            'pf_cnt',
+            'clear_cnt',
+            'match_cnt',
+            'beat_cnt',
+            'mynews_cnt',
+            'inherit',
+            'mtg_entry_cnt',
+            'mtg_hold_cnt',
+            'mtg_result',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/info/{}".format(item))
+
+        for item in [
+            'secret_list',
+            'title_list',
+            'theme_list',
+            'marker_list',
+            'parts_list',
+            'new/secret_list',
+            'new/title_list',
+            'new/theme_list',
+            'new/marker_list',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/item/{}".format(item))
+
+        for item in [
+            'music_id',
+            'marker',
+            'title',
+            'theme',
+            'sort',
+            'rank_sort',
+            'combo_disp',
+            'seq_id',
+            'parts',
+            'category',
+            'play_time',
+            'shopname',
+            'areaname',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/{}".format(item))
+
+        # Misc stuff
+        self.assert_path(resp, "response/gametop/data/player/session_id")
+        self.assert_path(resp, "response/gametop/data/player/only_now_music")
+        self.assert_path(resp, "response/gametop/data/player/requested_music")
+        self.assert_path(resp, "response/gametop/data/player/kac_music")
+        self.assert_path(resp, "response/gametop/data/player/history")
+        self.assert_path(resp, "response/gametop/data/player/today_music/music_id")
+        self.assert_path(resp, "response/gametop/data/player/news/checked")
+        self.assert_path(resp, "response/gametop/data/player/bistro/chef/id")
+
+        # Profile settings
+        self.assert_path(resp, "response/gametop/data/player/name")
+        self.assert_path(resp, "response/gametop/data/player/jid")
+        self.assert_path(resp, "response/gametop/data/player/refid")
+
+        # Non-player stuff
+        self.assert_path(resp, "response/gametop/data/termver")
+        self.assert_path(resp, "response/gametop/data/season_etime")
+        self.assert_path(resp, "response/gametop/data/bistro_last_music_id")
+        self.assert_path(resp, "response/gametop/data/white_music_list")
+        self.assert_path(resp, "response/gametop/data/old_music_list")
+        self.assert_path(resp, "response/gametop/data/open_music_list")
+
+        # Return the jid
+        return resp.child_value('gametop/data/player/jid')
+
+    def verify_gameend_regist(self, ref_id: str, jid: int, scores: List[Dict[str, Any]]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gameend = Node.void('gameend')
+        call.add_child(gameend)
+        gameend.set_attribute('method', 'regist')
+        gameend.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.string('name', self.NAME))
+        result = Node.void('result')
+        data.add_child(result)
+        result.set_attribute('count', str(len(scores)))
+
+        # Send scores
+        scoreid = 0
+        for score in scores:
+            # Always played
+            bits = 0x1
+            if score['clear']:
+                bits |= 0x2
+            if score['fc']:
+                bits |= 0x4
+            if score['ex']:
+                bits |= 0x8
+
+            # Intentionally starting at 1 because that's what the game does
+            scoreid = scoreid + 1
+            tune = Node.void('tune')
+            result.add_child(tune)
+            tune.set_attribute('id', str(scoreid))
+            tune.set_attribute('count', '0')
+            tune.add_child(Node.s32('music', score['id']))
+            player_1 = Node.void('player')
+            tune.add_child(player_1)
+            player_1.set_attribute('rank', '1')
+            scorenode = Node.s32('score', score['score'])
+            player_1.add_child(scorenode)
+            scorenode.set_attribute('seq', str(score['chart']))
+            scorenode.set_attribute('clear', str(bits))
+            scorenode.set_attribute('combo', '69')
+            player_1.add_child(Node.u8_array('mbar', [239, 175, 170, 170, 190, 234, 187, 158, 153, 230, 170, 90, 102, 170, 85, 150, 150, 102, 85, 234, 171, 169, 157, 150, 170, 101, 230, 90, 214, 255]))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/gameend/data/player/session_id")
+
+    def verify_gametop_regist(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'regist')
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        passnode = Node.void('pass')
+        player.add_child(passnode)
+        passnode.add_child(Node.string('refid', ref_id))
+        passnode.add_child(Node.string('datid', ref_id))
+        passnode.add_child(Node.string('uid', card_id))
+        passnode.add_child(Node.bool('inherit', True))
+        player.add_child(Node.string('name', self.NAME))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_pdata(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_pdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        passnode = Node.void('pass')
+        player.add_child(passnode)
+        passnode.add_child(Node.string('refid', ref_id))
+        passnode.add_child(Node.string('datid', ref_id))
+        passnode.add_child(Node.string('uid', card_id))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_mdata(self, jid: int) -> Dict[str, List[Dict[str, Any]]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_mdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        # Technically the game sends this same packet 3 times, one with
+        # each value 1, 2, 3 here. Unclear why, but we won't emulate it.
+        player.add_child(Node.s8('mdata_ver', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Parse out scores
+        self.assert_path(resp, "response/gametop/data/player/playdata")
+
+        ret = {}
+        for musicdata in resp.child('gametop/data/player/playdata').children:
+            if musicdata.name != 'musicdata':
+                raise Exception('Unexpected node in playdata!')
+
+            music_id = musicdata.attribute('music_id')
+            scores_by_chart: List[Dict[str, int]] = [{}, {}, {}]
+
+            def extract_cnts(name: str, val: List[int]) -> None:
+                scores_by_chart[0][name] = val[0]
+                scores_by_chart[1][name] = val[1]
+                scores_by_chart[2][name] = val[2]
+
+            extract_cnts('plays', musicdata.child_value('play_cnt'))
+            extract_cnts('clears', musicdata.child_value('clear_cnt'))
+            extract_cnts('full_combos', musicdata.child_value('fc_cnt'))
+            extract_cnts('excellents', musicdata.child_value('ex_cnt'))
+            extract_cnts('score', musicdata.child_value('score'))
+            extract_cnts('medal', musicdata.child_value('clear'))
+            ret[music_id] = scores_by_chart
+
+        return ret
+
+    def verify_gametop_get_meeting(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_meeting')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/meeting/single")
+        self.assert_path(resp, "response/gametop/data/meeting/tag")
+        self.assert_path(resp, "response/gametop/data/reward/total")
+        self.assert_path(resp, "response/gametop/data/reward/point")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_shopinfo_regist()
+        self.verify_demodata_get_news()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_gametop_regist(card, ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            scores = self.verify_gametop_get_mdata(jid)
+            self.verify_gametop_get_meeting(jid)
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            if len(scores) > 0:
+                raise Exception('Got nonzero score count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 40000059,
+                            'chart': 2,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 800000,
+                            'expected_medal': 0x3,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': True,
+                            'ex': False,
+                            'score': 990000,
+                            'expected_medal': 0x5,
+                        },
+                        # A perfect score on an easiest chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': True,
+                            'ex': True,
+                            'score': 1000000,
+                            'expected_medal': 0x9,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 30000024,
+                            'chart': 2,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 400000,
+                            'expected_medal': 0x1,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 100000,
+                            'expected_medal': 0x1,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 850000,
+                            'expected_medal': 0x3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 925000,
+                            'expected_score': 990000,
+                            'expected_medal': 0x7,
+                        },
+                    ]
+
+                self.verify_gameend_regist(ref_id, jid, dummyscores)
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                scores = self.verify_gametop_get_mdata(jid)
+                for score in dummyscores:
+                    newscore = scores[str(score['id'])][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+
+                    if newscore['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore['score'],
+                        ))
+
+                    if newscore['medal'] != score['expected_medal']:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            score['expected_medal'], score['id'], score['chart'], newscore['medal'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/jubeat/saucerfulfill.py b/bemani/client/jubeat/saucerfulfill.py
new file mode 100644
index 0000000..cb7aad0
--- /dev/null
+++ b/bemani/client/jubeat/saucerfulfill.py
@@ -0,0 +1,643 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class JubeatSaucerFulfillClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_shopinfo_regist(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        shopinfo = Node.void('shopinfo')
+        shopinfo.set_attribute('method', 'regist')
+        call.add_child(shopinfo)
+        shop = Node.void('shop')
+        shopinfo.add_child(shop)
+        shop.add_child(Node.string('name', ''))
+        shop.add_child(Node.string('pref', 'JP-14'))
+        shop.add_child(Node.string('softwareid', ''))
+        shop.add_child(Node.string('systemid', self.pcbid))
+        shop.add_child(Node.string('hardwareid', '01020304050607080900'))
+        shop.add_child(Node.string('locationid', 'US-1'))
+        shop.add_child(Node.string('monitor', 'D26L155             6252     151'))
+        testmode = Node.void('testmode')
+        shop.add_child(testmode)
+        testmode.set_attribute('send', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/shopinfo/data/cabid")
+        self.assert_path(resp, "response/shopinfo/data/locationid")
+        self.assert_path(resp, "response/shopinfo/data/is_send")
+        self.assert_path(resp, "response/shopinfo/data/white_music_list")
+        self.assert_path(resp, "response/shopinfo/data/tax_phase")
+        self.assert_path(resp, "response/shopinfo/data/lab/is_open")
+        self.assert_path(resp, "response/shopinfo/data/vocaloid_event/state")
+        self.assert_path(resp, "response/shopinfo/data/vocaloid_event/music_id")
+        self.assert_path(resp, "response/shopinfo/data/vocaloid_event2/state")
+        self.assert_path(resp, "response/shopinfo/data/vocaloid_event2/music_id")
+        self.assert_path(resp, "response/shopinfo/data/matching_off/is_open")
+        self.assert_path(resp, "response/shopinfo/data/tenka/is_participant")
+
+    def verify_demodata_get_news(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        demodata = Node.void('demodata')
+        call.add_child(demodata)
+        demodata.set_attribute('method', 'get_news')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/demodata/data/officialnews")
+
+    def __verify_profile(self, resp: Node) -> int:
+        for item in [
+            'jubility',
+            'jubility_yday',
+            'tune_cnt',
+            'save_cnt',
+            'saved_cnt',
+            'fc_cnt',
+            'ex_cnt',
+            'pf_cnt',
+            'clear_cnt',
+            'match_cnt',
+            'beat_cnt',
+            'mynews_cnt',
+            'extra_point',
+            'is_extra_played',
+            'inherit',
+            'mtg_entry_cnt',
+            'mtg_hold_cnt',
+            'mtg_result',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/info/{}".format(item))
+
+        for item in [
+            'secret_list',
+            'title_list',
+            'theme_list',
+            'marker_list',
+            'parts_list',
+            'new/secret_list',
+            'new/title_list',
+            'new/theme_list',
+            'new/marker_list',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/item/{}".format(item))
+
+        for item in [
+            'music_id',
+            'marker',
+            'title',
+            'theme',
+            'sort',
+            'rank_sort',
+            'combo_disp',
+            'seq_id',
+            'parts',
+            'category',
+            'play_time',
+            'expert_option',
+            'matching',
+            'hazard',
+            'hard',
+            'shopname',
+            'areaname',
+        ]:
+            self.assert_path(resp, "response/gametop/data/player/last/{}".format(item))
+
+        # Misc stuff
+        self.assert_path(resp, "response/gametop/data/player/session_id")
+        self.assert_path(resp, "response/gametop/data/player/event_flag")
+        self.assert_path(resp, "response/gametop/data/player/only_now_music")
+        self.assert_path(resp, "response/gametop/data/player/lab_edit_seq")
+        self.assert_path(resp, "response/gametop/data/player/kac_music")
+        self.assert_path(resp, "response/gametop/data/player/rivallist")
+        self.assert_path(resp, "response/gametop/data/player/share_music")
+        self.assert_path(resp, "response/gametop/data/player/bonus_music")
+        self.assert_path(resp, "response/gametop/data/player/history")
+        self.assert_path(resp, "response/gametop/data/player/news/checked")
+        self.assert_path(resp, "response/gametop/data/player/group/group_id")
+        self.assert_path(resp, "response/gametop/data/player/bingo/reward/total")
+        self.assert_path(resp, "response/gametop/data/player/bingo/reward/point")
+        self.assert_path(resp, "response/gametop/data/player/challenge/today/music_id")
+        self.assert_path(resp, "response/gametop/data/player/challenge/today/state")
+        self.assert_path(resp, "response/gametop/data/player/challenge/whim/music_id")
+        self.assert_path(resp, "response/gametop/data/player/challenge/whim/state")
+
+        # Profile settings
+        self.assert_path(resp, "response/gametop/data/player/name")
+        self.assert_path(resp, "response/gametop/data/player/jid")
+        self.assert_path(resp, "response/gametop/data/player/refid")
+
+        # Non-player stuff
+        self.assert_path(resp, "response/gametop/data/termver")
+        self.assert_path(resp, "response/gametop/data/season_etime")
+        self.assert_path(resp, "response/gametop/data/white_music_list")
+        self.assert_path(resp, "response/gametop/data/open_music_list")
+
+        # Return the jid
+        return resp.child_value('gametop/data/player/jid')
+
+    def verify_gameend_regist(self, ref_id: str, jid: int, mode: int, scores: List[Dict[str, Any]], course: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gameend = Node.void('gameend')
+        call.add_child(gameend)
+        gameend.set_attribute('method', 'regist')
+        gameend.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gameend.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s8('mode', mode))
+        player.add_child(Node.string('refid', ref_id))
+        player.add_child(Node.s32('jid', jid))
+        player.add_child(Node.string('name', self.NAME))
+        result = Node.void('result')
+        data.add_child(result)
+        result.set_attribute('count', str(len(scores)))
+
+        # Send scores
+        scoreid = 0
+        for score in scores:
+            # Always played
+            bits = 0x1
+            if score['clear']:
+                bits |= 0x2
+            if score['fc']:
+                bits |= 0x4
+            if score['ex']:
+                bits |= 0x8
+
+            # Intentionally starting at 1 because that's what the game does
+            scoreid = scoreid + 1
+            tune = Node.void('tune')
+            result.add_child(tune)
+            tune.set_attribute('id', str(scoreid))
+            tune.set_attribute('count', '0')
+            tune.add_child(Node.s32('music', score['id']))
+            player_1 = Node.void('player')
+            tune.add_child(player_1)
+            player_1.set_attribute('rank', '1')
+            scorenode = Node.s32('score', score['score'])
+            player_1.add_child(scorenode)
+            scorenode.set_attribute('seq', str(score['chart']))
+            scorenode.set_attribute('clear', str(bits))
+            scorenode.set_attribute('combo', '69')
+            player_1.add_child(Node.u8_array('mbar', [239, 175, 170, 170, 190, 234, 187, 158, 153, 230, 170, 90, 102, 170, 85, 150, 150, 102, 85, 234, 171, 169, 157, 150, 170, 101, 230, 90, 214, 255]))
+
+        if len(course) > 0:
+            coursenode = Node.void('course')
+            data.add_child(coursenode)
+            coursenode.add_child(Node.s32('course_id', course['course_id']))
+            coursenode.add_child(Node.u8('rating', course['rating']))
+            index = 0
+            for coursescore in course['scores']:
+                music = Node.void('music')
+                coursenode.add_child(music)
+                music.set_attribute('index', str(index))
+                music.add_child(Node.s32('score', coursescore))
+                index = index + 1
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/gameend/data/player/session_id")
+
+    def verify_gametop_regist(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'regist')
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        passnode = Node.void('pass')
+        player.add_child(passnode)
+        passnode.add_child(Node.string('refid', ref_id))
+        passnode.add_child(Node.string('datid', ref_id))
+        passnode.add_child(Node.string('uid', card_id))
+        passnode.add_child(Node.bool('inherit', True))
+        player.add_child(Node.string('name', self.NAME))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_pdata(self, card_id: str, ref_id: str) -> int:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_pdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        passnode = Node.void('pass')
+        player.add_child(passnode)
+        passnode.add_child(Node.string('refid', ref_id))
+        passnode.add_child(Node.string('datid', ref_id))
+        passnode.add_child(Node.string('uid', card_id))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        return self.__verify_profile(resp)
+
+    def verify_gametop_get_mdata(self, jid: int) -> Dict[str, List[Dict[str, Any]]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_mdata')
+        retry = Node.s32('retry', 0)
+        gametop.add_child(retry)
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+        # Technically the game sends this same packet 3 times, one with
+        # each value 1, 2, 3 here. Unclear why, but we won't emulate it.
+        player.add_child(Node.s8('mdata_ver', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Parse out scores
+        self.assert_path(resp, "response/gametop/data/player/playdata")
+
+        ret = {}
+        for musicdata in resp.child('gametop/data/player/playdata').children:
+            if musicdata.name != 'musicdata':
+                raise Exception('Unexpected node in playdata!')
+
+            music_id = musicdata.attribute('music_id')
+            scores_by_chart: List[Dict[str, int]] = [{}, {}, {}]
+
+            def extract_cnts(name: str, val: List[int]) -> None:
+                scores_by_chart[0][name] = val[0]
+                scores_by_chart[1][name] = val[1]
+                scores_by_chart[2][name] = val[2]
+
+            extract_cnts('plays', musicdata.child_value('play_cnt'))
+            extract_cnts('clears', musicdata.child_value('clear_cnt'))
+            extract_cnts('full_combos', musicdata.child_value('fc_cnt'))
+            extract_cnts('excellents', musicdata.child_value('ex_cnt'))
+            extract_cnts('score', musicdata.child_value('score'))
+            extract_cnts('medal', musicdata.child_value('clear'))
+            ret[music_id] = scores_by_chart
+
+        return ret
+
+    def verify_gametop_get_course(self, jid: int) -> List[Dict[str, Any]]:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_course')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/course_list")
+        self.assert_path(resp, "response/gametop/data/player_list")
+        self.assert_path(resp, "response/gametop/data/last_course_id")
+
+        playernode = None
+        for player in resp.child('gametop/data/player_list').children:
+            if player.child_value('jid') == jid:
+                playernode = player
+                break
+
+        if playernode is None:
+            raise Exception("Didn't find any scores for ExtID {}".format(jid))
+
+        ret = []
+        for result in playernode.child('result_list').children:
+            if result.name != 'result':
+                raise Exception('Unexpected node in result_list!')
+
+            course_id = result.child_value('id')
+            rating = result.child_value('rating')
+            scores = result.child_value('score')
+
+            ret.append({'course_id': course_id, 'rating': rating, 'scores': scores})
+
+        return ret
+
+    def verify_gametop_get_meeting(self, jid: int) -> None:
+        call = self.call_node()
+
+        # Construct node
+        gametop = Node.void('gametop')
+        call.add_child(gametop)
+        gametop.set_attribute('method', 'get_meeting')
+        gametop.add_child(Node.s32('retry', 0))
+        data = Node.void('data')
+        gametop.add_child(data)
+        player = Node.void('player')
+        data.add_child(player)
+        player.add_child(Node.s32('jid', jid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify expected nodes
+        self.assert_path(resp, "response/gametop/data/meeting/single")
+        self.assert_path(resp, "response/gametop/data/meeting/tag")
+        self.assert_path(resp, "response/gametop/data/reward/total")
+        self.assert_path(resp, "response/gametop/data/reward/point")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_shopinfo_regist()
+        self.verify_demodata_get_news()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_gametop_regist(card, ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            jid = self.verify_gametop_get_pdata(card, ref_id)
+            scores = self.verify_gametop_get_mdata(jid)
+            courses = self.verify_gametop_get_course(jid)
+            self.verify_gametop_get_meeting(jid)
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            if courses is None:
+                raise Exception('Expected to get courses back, didn\'t get anything!')
+            if len(scores) > 0:
+                raise Exception('Got nonzero score count on a new card!')
+            if len(courses) > 0:
+                raise Exception('Got nonzero course count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 40000059,
+                            'chart': 2,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 800000,
+                            'expected_medal': 0x3,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': True,
+                            'ex': False,
+                            'score': 990000,
+                            'expected_medal': 0x5,
+                        },
+                        # A perfect score on an easiest chart of the same song
+                        {
+                            'id': 40000059,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': True,
+                            'ex': True,
+                            'score': 1000000,
+                            'expected_medal': 0x9,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 30000024,
+                            'chart': 2,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 400000,
+                            'expected_medal': 0x1,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': False,
+                            'fc': False,
+                            'ex': False,
+                            'score': 100000,
+                            'expected_medal': 0x1,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 50000045,
+                            'chart': 0,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 850000,
+                            'expected_medal': 0x3,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 40000059,
+                            'chart': 1,
+                            'clear': True,
+                            'fc': False,
+                            'ex': False,
+                            'score': 925000,
+                            'expected_score': 990000,
+                            'expected_medal': 0x7,
+                        },
+                    ]
+
+                self.verify_gameend_regist(ref_id, jid, 8, dummyscores, {})
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                scores = self.verify_gametop_get_mdata(jid)
+                courses = self.verify_gametop_get_course(jid)
+                if len(courses) > 0:
+                    raise Exception('Got nonzero course count without playing any courses!')
+
+                for score in dummyscores:
+                    newscore = scores[str(score['id'])][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+
+                    if newscore['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore['score'],
+                        ))
+
+                    if newscore['medal'] != score['expected_medal']:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            score['expected_medal'], score['id'], score['chart'], newscore['medal'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+            for phase in [1, 2]:
+                dummycourses: List[Dict[str, Any]] = []
+                if phase == 1:
+                    dummycourses.extend([
+                        {
+                            'course_id': 1,
+                            'rating': 1,
+                            'scores': [123456, 123457, 123458, 123459, 123460],
+                        },
+                        {
+                            'course_id': 2,
+                            'rating': 2,
+                            'scores': [123456, 123457, 123458, 123459, 123460],
+                        },
+                    ])
+                else:
+                    dummycourses.extend([
+                        {
+                            'course_id': 1,
+                            'rating': 2,
+                            'scores': [223456, 223457, 223458, 223459, 223460],
+                        },
+                        {
+                            'course_id': 2,
+                            'rating': 1,
+                            'expected_rating': 2,
+                            'scores': [23456, 23457, 23458, 23459, 23460],
+                            'expected_scores': [123456, 123457, 123458, 123459, 123460],
+                        },
+                    ])
+
+                for course in dummycourses:
+                    self.verify_gameend_regist(ref_id, jid, 6, [], course)
+                jid = self.verify_gametop_get_pdata(card, ref_id)
+                courses = self.verify_gametop_get_course(jid)
+
+                for course in dummycourses:
+                    # Find the course
+                    foundcourses = [c for c in courses if c['course_id'] == course['course_id']]
+
+                    if len(foundcourses) == 0:
+                        raise Exception("Didn't find course by ID {}".format(course['course_id']))
+                    foundcourse = foundcourses[0]
+
+                    if 'expected_rating' in course:
+                        expected_rating = course['expected_rating']
+                    else:
+                        expected_rating = course['rating']
+
+                    if 'expected_scores' in course:
+                        expected_scores = course['expected_scores']
+                    else:
+                        expected_scores = course['scores']
+
+                    if foundcourse['course_id'] != course['course_id']:
+                        raise Exception("Logic error!")
+
+                    if foundcourse['rating'] != expected_rating:
+                        raise Exception('Expected a rating of \'{}\' for course \'{}\' but got rating \'{}\''.format(
+                            expected_rating, course['course_id'], foundcourse['rating'],
+                        ))
+
+                    for i in range(len(expected_scores)):
+                        if foundcourse['scores'][i] != expected_scores[i]:
+                            raise Exception('Expected a score of \'{}\' for course \'{}\' song number \'{}\' but got score \'{}\''.format(
+                                expected_scores[i], course['course_id'], i, foundcourse['scores'][i],
+                            ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/museca/__init__.py b/bemani/client/museca/__init__.py
new file mode 100644
index 0000000..521ff9d
--- /dev/null
+++ b/bemani/client/museca/__init__.py
@@ -0,0 +1,2 @@
+from bemani.client.museca.museca1 import Museca1Client
+from bemani.client.museca.museca1plus import Museca1PlusClient
diff --git a/bemani/client/museca/museca1.py b/bemani/client/museca/museca1.py
new file mode 100644
index 0000000..3fbbdb4
--- /dev/null
+++ b/bemani/client/museca/museca1.py
@@ -0,0 +1,591 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class Museca1Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '2.4.0'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'hiscore')
+        game.add_child(Node.string('locid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/hitchart/info/id")
+        self.assert_path(resp, "response/game_3/hitchart/info/cnt")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/id")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/type")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/name")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/seq")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/score")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/id")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/type")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/name")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/seq")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/score")
+        self.assert_path(resp, "response/game_3/clear_rate/d/id")
+        self.assert_path(resp, "response/game_3/clear_rate/d/type")
+        self.assert_path(resp, "response/game_3/clear_rate/d/cr")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', False))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+        game.add_child(Node.bool('newpc', False))
+        game.add_child(Node.s32('s_paseli', 206))
+        game.add_child(Node.s32('monitor', 1))
+        game.add_child(Node.string('romnumber', '-'))
+        game.add_child(Node.string('etc', 'TaxMode:1,BasicRate:100/1,FirstFree:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/nxt_time")
+
+    def verify_game_exception(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'exception')
+        game.add_child(Node.string('text', ''))
+        game.add_child(Node.string('lid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/@status")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('name', self.NAME))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'frozen')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/result")
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, blaster_energy: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u16('appeal_id', 1001))
+        game.add_child(Node.u16('comment_id', 0))
+        game.add_child(Node.s32('music_id', 29))
+        game.add_child(Node.u8('music_type', 1))
+        game.add_child(Node.u8('sort_type', 1))
+        game.add_child(Node.u8('narrow_down', 0))
+        game.add_child(Node.u8('gauge_option', 0))
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        item = Node.void('item')
+        game.add_child(item)
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 1))
+        info.add_child(Node.u32('type', 5))
+        info.add_child(Node.u32('param', 333333376))
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 1))
+        info.add_child(Node.u32('type', 7))
+        info.add_child(Node.u32('param', 1))
+        info.add_child(Node.s32('diff_param', 1))
+        game.add_child(Node.s32_array('hidden_param', [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        game.add_child(Node.s16('skill_name_id', -1))
+        game.add_child(Node.s32('earned_blaster_energy', blaster_energy))
+        game.add_child(Node.u32('blaster_count', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'common')
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/music_limited")
+        self.assert_path(resp, "response/game_3/event")
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('cardid', cardid))
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game_3/result")
+            if resp.child_value('game_3/result') != 1:
+                raise Exception("Invalid result for new profile!")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game_3/name")
+            self.assert_path(resp, "response/game_3/code")
+            self.assert_path(resp, "response/game_3/gamecoin_packet")
+            self.assert_path(resp, "response/game_3/gamecoin_block")
+            self.assert_path(resp, "response/game_3/skill_name_id")
+            self.assert_path(resp, "response/game_3/hidden_param")
+            self.assert_path(resp, "response/game_3/blaster_energy")
+            self.assert_path(resp, "response/game_3/blaster_count")
+            self.assert_path(resp, "response/game_3/play_count")
+            self.assert_path(resp, "response/game_3/daily_count")
+            self.assert_path(resp, "response/game_3/play_chain")
+            self.assert_path(resp, "response/game_3/item")
+
+            items: Dict[int, Dict[int, int]] = {}
+            for child in resp.child('game_3/item').children:
+                if child.name != 'info':
+                    continue
+
+                itype = child.child_value('type')
+                iid = child.child_value('id')
+                param = child.child_value('param')
+
+                if itype not in items:
+                    items[itype] = {}
+                items[itype][iid] = param
+
+            return {
+                'name': resp.child_value('game_3/name'),
+                'packet': resp.child_value('game_3/gamecoin_packet'),
+                'block': resp.child_value('game_3/gamecoin_block'),
+                'blaster_energy': resp.child_value('game_3/blaster_energy'),
+                'items': items,
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_play_e(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'play_e')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s8('mode', 0))
+        game.add_child(Node.s16('track_num', 3))
+        game.add_child(Node.s32('s_coin', 0))
+        game.add_child(Node.s32('s_paseli', 0))
+        game.add_child(Node.s16('blaster_count', 0))
+        game.add_child(Node.s16('blaster_cartridge', 0))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u16('drop_frame', 396))
+        game.add_child(Node.u16('drop_frame_max', 396))
+        game.add_child(Node.u16('drop_count', 1))
+        game.add_child(Node.string('etc', 'StoryID:0,StoryPrg:0,PrgPrm:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load_m')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/new")
+
+        scores = []
+        for child in resp.child('game_3/new').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_id')
+            chart = child.child_value('music_type')
+            clear_type = child.child_value('clear_type')
+            score = child.child_value('score')
+            grade = child.child_value('score_grade')
+
+            scores.append({
+                'id': musicid,
+                'chart': chart,
+                'clear_type': clear_type,
+                'score': score,
+                'grade': grade,
+            })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_m')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.u32('music_id', score['id']))
+        game.add_child(Node.u32('music_type', score['chart']))
+        game.add_child(Node.u32('score', score['score']))
+        game.add_child(Node.u32('clear_type', score['clear_type']))
+        game.add_child(Node.u32('score_grade', score['grade']))
+        game.add_child(Node.u32('max_chain', 0))
+        game.add_child(Node.u32('critical', 0))
+        game.add_child(Node.u32('near', 0))
+        game.add_child(Node.u32('error', 0))
+        game.add_child(Node.u32('effective_rate', 100))
+        game.add_child(Node.u32('btn_rate', 0))
+        game.add_child(Node.u32('long_rate', 0))
+        game.add_child(Node.u32('vol_rate', 0))
+        game.add_child(Node.u8('mode', 0))
+        game.add_child(Node.u8('gauge_type', 0))
+        game.add_child(Node.u16('online_num', 0))
+        game.add_child(Node.u16('local_num', 0))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_common()
+        self.verify_game_shop(location)
+        self.verify_game_exception(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Museca doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        self.verify_game_frozen(ref_id, 0)
+        self.verify_game_play_e(location, ref_id)
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['blaster_energy'] != 0:
+                raise Exception('Profile has nonzero blaster energy associated with it!')
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, blaster_energy=42)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 42:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 4,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 4,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 4,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/museca/museca1plus.py b/bemani/client/museca/museca1plus.py
new file mode 100644
index 0000000..a7c979d
--- /dev/null
+++ b/bemani/client/museca/museca1plus.py
@@ -0,0 +1,609 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class Museca1PlusClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '2.4.0'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'hiscore')
+        game.add_child(Node.string('locid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/hitchart/info/id")
+        self.assert_path(resp, "response/game_3/hitchart/info/cnt")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/id")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/type")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/name")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/seq")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/score")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/id")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/type")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/name")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/seq")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/score")
+        self.assert_path(resp, "response/game_3/clear_rate/d/id")
+        self.assert_path(resp, "response/game_3/clear_rate/d/type")
+        self.assert_path(resp, "response/game_3/clear_rate/d/cr")
+
+    def verify_game_exception(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'exception')
+        game.add_child(Node.string('text', ''))
+        game.add_child(Node.string('lid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/@status")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', False))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+        game.add_child(Node.bool('newpc', False))
+        game.add_child(Node.s32('s_paseli', 206))
+        game.add_child(Node.s32('monitor', 1))
+        game.add_child(Node.string('romnumber', '-'))
+        game.add_child(Node.string('etc', 'TaxMode:1,BasicRate:100/1,FirstFree:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/nxt_time")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('name', self.NAME))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'frozen')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/result")
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, blaster_energy: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u16('appeal_id', 1001))
+        game.add_child(Node.u16('comment_id', 0))
+        game.add_child(Node.s32('music_id', 29))
+        game.add_child(Node.u8('music_type', 1))
+        game.add_child(Node.u8('sort_type', 1))
+        game.add_child(Node.u8('narrow_down', 0))
+        game.add_child(Node.u8('gauge_option', 0))
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        item = Node.void('item')
+        game.add_child(item)
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 1))
+        info.add_child(Node.u32('type', 5))
+        info.add_child(Node.u32('param', 333333376))
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 1))
+        info.add_child(Node.u32('type', 7))
+        info.add_child(Node.u32('param', 1))
+        info.add_child(Node.s32('diff_param', 1))
+        game.add_child(Node.s32_array('hidden_param', [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        game.add_child(Node.s16('skill_name_id', -1))
+        game.add_child(Node.s32('earned_blaster_energy', blaster_energy))
+        game.add_child(Node.u32('blaster_count', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'common')
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/music_limited")
+        self.assert_path(resp, "response/game_3/event")
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('cardid', cardid))
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game_3/result")
+            if resp.child_value('game_3/result') != 1:
+                raise Exception("Invalid result for new profile!")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game_3/name")
+            self.assert_path(resp, "response/game_3/code")
+            self.assert_path(resp, "response/game_3/gamecoin_packet")
+            self.assert_path(resp, "response/game_3/gamecoin_block")
+            self.assert_path(resp, "response/game_3/skill_name_id")
+            self.assert_path(resp, "response/game_3/hidden_param")
+            self.assert_path(resp, "response/game_3/blaster_energy")
+            self.assert_path(resp, "response/game_3/blaster_count")
+            self.assert_path(resp, "response/game_3/play_count")
+            self.assert_path(resp, "response/game_3/daily_count")
+            self.assert_path(resp, "response/game_3/play_chain")
+            self.assert_path(resp, "response/game_3/ryusei_festa/ryusei_festa_trigger")
+            self.assert_path(resp, "response/game_3/item")
+
+            items: Dict[int, Dict[int, int]] = {}
+            for child in resp.child('game_3/item').children:
+                if child.name != 'info':
+                    continue
+
+                itype = child.child_value('type')
+                iid = child.child_value('id')
+                param = child.child_value('param')
+
+                if itype not in items:
+                    items[itype] = {}
+                items[itype][iid] = param
+
+            return {
+                'name': resp.child_value('game_3/name'),
+                'packet': resp.child_value('game_3/gamecoin_packet'),
+                'block': resp.child_value('game_3/gamecoin_block'),
+                'blaster_energy': resp.child_value('game_3/blaster_energy'),
+                'items': items,
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_play_e(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'play_e')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s8('mode', 0))
+        game.add_child(Node.s16('track_num', 3))
+        game.add_child(Node.s32('s_coin', 0))
+        game.add_child(Node.s32('s_paseli', 0))
+        game.add_child(Node.s16('blaster_count', 0))
+        game.add_child(Node.s16('blaster_cartridge', 0))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u16('drop_frame', 396))
+        game.add_child(Node.u16('drop_frame_max', 396))
+        game.add_child(Node.u16('drop_count', 1))
+        game.add_child(Node.string('etc', 'StoryID:0,StoryPrg:0,PrgPrm:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_lounge(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'lounge')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/interval")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load_m')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/new")
+
+        scores = []
+        for child in resp.child('game_3/new').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_id')
+            chart = child.child_value('music_type')
+            clear_type = child.child_value('clear_type')
+            score = child.child_value('score')
+            grade = child.child_value('score_grade')
+
+            scores.append({
+                'id': musicid,
+                'chart': chart,
+                'clear_type': clear_type,
+                'score': score,
+                'grade': grade,
+            })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_m')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.u32('music_id', score['id']))
+        game.add_child(Node.u32('music_type', score['chart']))
+        game.add_child(Node.u32('score', score['score']))
+        game.add_child(Node.u32('clear_type', score['clear_type']))
+        game.add_child(Node.u32('score_grade', score['grade']))
+        game.add_child(Node.u32('max_chain', 0))
+        game.add_child(Node.u32('critical', 0))
+        game.add_child(Node.u32('near', 0))
+        game.add_child(Node.u32('error', 0))
+        game.add_child(Node.u32('effective_rate', 100))
+        game.add_child(Node.u32('btn_rate', 0))
+        game.add_child(Node.u32('long_rate', 0))
+        game.add_child(Node.u32('vol_rate', 0))
+        game.add_child(Node.u8('mode', 0))
+        game.add_child(Node.u8('gauge_type', 0))
+        game.add_child(Node.u16('online_num', 0))
+        game.add_child(Node.u16('local_num', 0))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_common()
+        self.verify_game_shop(location)
+        self.verify_game_exception(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Museca doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        self.verify_game_frozen(ref_id, 0)
+        self.verify_game_play_e(location, ref_id)
+
+        # Verify lobby functionality
+        self.verify_game_lounge()
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['blaster_energy'] != 0:
+                raise Exception('Profile has nonzero blaster energy associated with it!')
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, blaster_energy=42)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 42:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 4,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 4,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 4,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/popn/__init__.py b/bemani/client/popn/__init__.py
new file mode 100644
index 0000000..4465ec6
--- /dev/null
+++ b/bemani/client/popn/__init__.py
@@ -0,0 +1,6 @@
+from bemani.client.popn.tunestreet import PopnMusicTuneStreetClient
+from bemani.client.popn.fantasia import PopnMusicFantasiaClient
+from bemani.client.popn.sunnypark import PopnMusicSunnyParkClient
+from bemani.client.popn.lapistoria import PopnMusicLapistoriaClient
+from bemani.client.popn.eclale import PopnMusicEclaleClient
+from bemani.client.popn.usaneko import PopnMusicUsaNekoClient
diff --git a/bemani/client/popn/eclale.py b/bemani/client/popn/eclale.py
new file mode 100644
index 0000000..fe7b15d
--- /dev/null
+++ b/bemani/client/popn/eclale.py
@@ -0,0 +1,596 @@
+import random
+import time
+from typing import Any, Dict, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class PopnMusicEclaleClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb23_boot(self, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        pcb23 = Node.void('pcb23')
+        call.add_child(pcb23)
+        pcb23.set_attribute('method', 'boot')
+        pcb23.add_child(Node.string('loc_id', loc))
+        pcb23.add_child(Node.u8('loc_type', 0))
+        pcb23.add_child(Node.string('loc_name', ''))
+        pcb23.add_child(Node.string('country', 'US'))
+        pcb23.add_child(Node.string('region', '.'))
+        pcb23.add_child(Node.s16('pref', 51))
+        pcb23.add_child(Node.string('customer', ''))
+        pcb23.add_child(Node.string('company', ''))
+        pcb23.add_child(Node.ipv4('gip', '127.0.0.1'))
+        pcb23.add_child(Node.u16('gp', 10011))
+        pcb23.add_child(Node.string('rom_number', 'M39-JB-G01'))
+        pcb23.add_child(Node.u64('c_drive', 10028228608))
+        pcb23.add_child(Node.u64('d_drive', 47945170944))
+        pcb23.add_child(Node.u64('e_drive', 10394677248))
+        pcb23.add_child(Node.string('etc', ''))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb23/@status")
+
+    def __verify_common(self, root: str, resp: Node) -> None:
+        self.assert_path(resp, "response/{}/phase/event_id".format(root))
+        self.assert_path(resp, "response/{}/phase/phase".format(root))
+        self.assert_path(resp, "response/{}/area/area_id".format(root))
+        self.assert_path(resp, "response/{}/area/end_date".format(root))
+        self.assert_path(resp, "response/{}/area/medal_id".format(root))
+        self.assert_path(resp, "response/{}/area/is_limit".format(root))
+
+    def verify_info23_common(self, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        info23 = Node.void('info23')
+        call.add_child(info23)
+        info23.set_attribute('loc_id', loc)
+        info23.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.__verify_common('info23', resp)
+
+    def verify_lobby22_getlist(self, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        lobby22 = Node.void('lobby22')
+        call.add_child(lobby22)
+        lobby22.set_attribute('method', 'getList')
+        lobby22.add_child(Node.string('location_id', loc))
+        lobby22.add_child(Node.u8('net_version', 53))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby22/@status")
+
+    def __verify_profile(self, resp: Node) -> None:
+        self.assert_path(resp, "response/player23/account/name")
+        self.assert_path(resp, "response/player23/account/g_pm_id")
+        self.assert_path(resp, "response/player23/account/tutorial")
+        self.assert_path(resp, "response/player23/account/area_id")
+        self.assert_path(resp, "response/player23/account/lumina")
+        self.assert_path(resp, "response/player23/account/read_news")
+        self.assert_path(resp, "response/player23/account/welcom_pack")
+        self.assert_path(resp, "response/player23/account/medal_set")
+        self.assert_path(resp, "response/player23/account/nice")
+        self.assert_path(resp, "response/player23/account/favorite_chara")
+        self.assert_path(resp, "response/player23/account/special_area")
+        self.assert_path(resp, "response/player23/account/chocolate_charalist")
+        self.assert_path(resp, "response/player23/account/teacher_setting")
+        self.assert_path(resp, "response/player23/account/staff")
+        self.assert_path(resp, "response/player23/account/item_type")
+        self.assert_path(resp, "response/player23/account/item_id")
+        self.assert_path(resp, "response/player23/account/is_conv")
+        self.assert_path(resp, "response/player23/account/meteor_flg")
+        self.assert_path(resp, "response/player23/account/license_data")
+        self.assert_path(resp, "response/player23/account/my_best")
+        self.assert_path(resp, "response/player23/account/latest_music")
+        self.assert_path(resp, "response/player23/account/active_fr_num")
+        self.assert_path(resp, "response/player23/account/total_play_cnt")
+        self.assert_path(resp, "response/player23/account/today_play_cnt")
+        self.assert_path(resp, "response/player23/account/consecutive_days")
+        self.assert_path(resp, "response/player23/account/total_days")
+        self.assert_path(resp, "response/player23/account/interval_day")
+        self.assert_path(resp, "response/player23/netvs")
+        self.assert_path(resp, "response/player23/config")
+        self.assert_path(resp, "response/player23/option")
+        self.assert_path(resp, "response/player23/info/ep")
+        self.assert_path(resp, "response/player23/custom_cate")
+        self.assert_path(resp, "response/player23/customize")
+        self.assert_path(resp, "response/player23/event/enemy_medal")
+        self.assert_path(resp, "response/player23/event/hp")
+        self.assert_path(resp, "response/player23/stamp/stamp_id")
+        self.assert_path(resp, "response/player23/stamp/cnt")
+
+    def verify_player23_read(self, ref_id: str, msg_type: str) -> Dict[str, Dict[int, Dict[str, int]]]:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('method', 'read')
+
+        player23.add_child(Node.string('ref_id', ref_id))
+        player23.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/player23/result")
+            status = resp.child_value('player23/result')
+            if status != 2:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+            return {
+                'medals': {},
+                'items': {},
+                'characters': {},
+                'lumina': {},
+            }
+        elif msg_type == 'query':
+            # Verify that the response is correct
+            self.__verify_profile(resp)
+
+            self.assert_path(resp, "response/player23/result")
+            status = resp.child_value('player23/result')
+            if status != 0:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+            name = resp.child_value('player23/account/name')
+            if name != self.NAME:
+                raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+            # Medals and items
+            items: Dict[int, Dict[str, int]] = {}
+            medals: Dict[int, Dict[str, int]] = {}
+            charas: Dict[int, Dict[str, int]] = {}
+            for obj in resp.child('player23').children:
+                if obj.name == 'medal':
+                    medals[obj.child_value('medal_id')] = {
+                        'level': obj.child_value('level'),
+                        'exp': obj.child_value('exp'),
+                    }
+                elif obj.name == 'item':
+                    items[obj.child_value('id')] = {
+                        'type': obj.child_value('type'),
+                        'param': obj.child_value('param'),
+                    }
+                elif obj.name == 'chara_param':
+                    charas[obj.child_value('chara_id')] = {
+                        'friendship': obj.child_value('friendship'),
+                    }
+
+            return {
+                'medals': medals,
+                'items': items,
+                'characters': charas,
+                'lumina': {0: {'lumina': resp.child_value('player23/account/lumina')}},
+            }
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_player23_read_score(self, ref_id: str) -> Dict[str, Dict[int, Dict[int, int]]]:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('method', 'read_score')
+
+        player23.add_child(Node.string('ref_id', ref_id))
+        player23.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify defaults
+        self.assert_path(resp, "response/player23/@status")
+
+        # Grab scores
+        scores: Dict[int, Dict[int, int]] = {}
+        medals: Dict[int, Dict[int, int]] = {}
+        for child in resp.child('player23').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_num')
+            chart = child.child_value('sheet_num')
+            score = child.child_value('score')
+            medal = child.child_value('clear_type')
+
+            if musicid not in scores:
+                scores[musicid] = {}
+            if musicid not in medals:
+                medals[musicid] = {}
+
+            scores[musicid][chart] = score
+            medals[musicid][chart] = medal
+
+        return {
+            'scores': scores,
+            'medals': medals,
+        }
+
+    def verify_player23_start(self, ref_id: str, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('loc_id', loc)
+        player23.set_attribute('ref_id', ref_id)
+        player23.set_attribute('method', 'start')
+        player23.set_attribute('start_type', '0')
+        pcb_card = Node.void('pcb_card')
+        player23.add_child(pcb_card)
+        pcb_card.add_child(Node.s8('card_enable', 0))
+        pcb_card.add_child(Node.s8('card_soldout', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.__verify_common('player23', resp)
+
+    def verify_player23_logout(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('ref_id', ref_id)
+        player23.set_attribute('method', 'logout')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player23/@status")
+
+    def verify_player23_write(
+        self,
+        ref_id: str,
+        medal: Optional[Dict[str, int]]=None,
+        item: Optional[Dict[str, int]]=None,
+        character: Optional[Dict[str, int]]=None,
+    ) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('method', 'write')
+        player23.add_child(Node.string('ref_id', ref_id))
+
+        # Add required children
+        config = Node.void('config')
+        player23.add_child(config)
+        config.add_child(Node.s16('chara', 1543))
+
+        if medal is not None:
+            medalnode = Node.void('medal')
+            player23.add_child(medalnode)
+            medalnode.add_child(Node.s16('medal_id', medal['id']))
+            medalnode.add_child(Node.s16('level', medal['level']))
+            medalnode.add_child(Node.s32('exp', medal['exp']))
+            medalnode.add_child(Node.s32('set_count', 0))
+            medalnode.add_child(Node.s32('get_count', 0))
+
+        if item is not None:
+            itemnode = Node.void('item')
+            player23.add_child(itemnode)
+            itemnode.add_child(Node.u8('type', item['type']))
+            itemnode.add_child(Node.u16('id', item['id']))
+            itemnode.add_child(Node.u16('param', item['param']))
+            itemnode.add_child(Node.bool('is_new', False))
+
+        if character is not None:
+            chara_param = Node.void('chara_param')
+            player23.add_child(chara_param)
+            chara_param.add_child(Node.u16('chara_id', character['id']))
+            chara_param.add_child(Node.u16('friendship', character['friendship']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player23/@status")
+
+    def verify_player23_buy(self, ref_id: str, item: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('method', 'buy')
+        player23.add_child(Node.s32('play_id', 0))
+        player23.add_child(Node.string('ref_id', ref_id))
+        player23.add_child(Node.u16('id', item['id']))
+        player23.add_child(Node.u8('type', item['type']))
+        player23.add_child(Node.u16('param', item['param']))
+        player23.add_child(Node.s32('lumina', item['lumina']))
+        player23.add_child(Node.u16('price', item['price']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player23/@status")
+
+    def verify_player23_write_music(self, ref_id: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('method', 'write_music')
+        player23.add_child(Node.string('ref_id', ref_id))
+        player23.add_child(Node.string('data_id', ref_id))
+        player23.add_child(Node.string('name', self.NAME))
+        player23.add_child(Node.u8('stage', 0))
+        player23.add_child(Node.s16('music_num', score['id']))
+        player23.add_child(Node.u8('sheet_num', score['chart']))
+        player23.add_child(Node.u8('clearmedal', score['medal']))
+        player23.add_child(Node.s32('score', score['score']))
+        player23.add_child(Node.s16('combo', 0))
+        player23.add_child(Node.s16('cool', 0))
+        player23.add_child(Node.s16('great', 0))
+        player23.add_child(Node.s16('good', 0))
+        player23.add_child(Node.s16('bad', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player23/@status")
+
+    def verify_player23_new(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player23 = Node.void('player23')
+        call.add_child(player23)
+        player23.set_attribute('method', 'new')
+
+        player23.add_child(Node.string('ref_id', ref_id))
+        player23.add_child(Node.string('name', self.NAME))
+        player23.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes
+        self.__verify_profile(resp)
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_pcb23_boot(location)
+        self.verify_info23_common(location)
+        self.verify_lobby22_getlist(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_player23_read(ref_id, msg_type='new')
+            self.verify_player23_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify proper handling of basic stuff
+        self.verify_player23_read(ref_id, msg_type='query')
+        self.verify_player23_start(ref_id, location)
+        self.verify_player23_write(ref_id)
+        self.verify_player23_logout(ref_id)
+
+        # Verify unlocks/story mode work
+        unlocks = self.verify_player23_read(ref_id, msg_type='query')
+        for item in unlocks['items']:
+            raise Exception('Got nonzero items count on a new card!')
+        for med in unlocks['medals']:
+            raise Exception('Got nonzero medals count on a new card!')
+        for char in unlocks['characters']:
+            raise Exception('Got nonzero characters count on a new card!')
+        if unlocks['lumina'][0]['lumina'] != 300:
+            raise Exception('Got wrong default value for lumina on a new card!')
+
+        self.verify_player23_write(ref_id, medal={'id': 1, 'level': 3, 'exp': 42})
+        unlocks = self.verify_player23_read(ref_id, msg_type='query')
+        if 1 not in unlocks['medals']:
+            raise Exception('Expecting to see medal ID 1 in medals!')
+        if unlocks['medals'][1]['level'] != 3:
+            raise Exception('Expecting to see medal ID 1 to have level 3 in medals!')
+        if unlocks['medals'][1]['exp'] != 42:
+            raise Exception('Expecting to see medal ID 1 to have exp 42 in medals!')
+
+        self.verify_player23_write(ref_id, item={'id': 4, 'type': 2, 'param': 69})
+        unlocks = self.verify_player23_read(ref_id, msg_type='query')
+        if 4 not in unlocks['items']:
+            raise Exception('Expecting to see item ID 4 in items!')
+        if unlocks['items'][4]['type'] != 2:
+            raise Exception('Expecting to see item ID 4 to have type 2 in items!')
+        if unlocks['items'][4]['param'] != 69:
+            raise Exception('Expecting to see item ID 4 to have param 69 in items!')
+
+        self.verify_player23_write(ref_id, character={'id': 5, 'friendship': 420})
+        unlocks = self.verify_player23_read(ref_id, msg_type='query')
+        if 5 not in unlocks['characters']:
+            raise Exception('Expecting to see chara ID 5 in characters!')
+        if unlocks['characters'][5]['friendship'] != 420:
+            raise Exception('Expecting to see chara ID 5 to have type 2 in characters!')
+
+        # Verify purchases work
+        self.verify_player23_buy(ref_id, item={'id': 6, 'type': 7, 'param': 8, 'lumina': 400, 'price': 250})
+        unlocks = self.verify_player23_read(ref_id, msg_type='query')
+        if 6 not in unlocks['items']:
+            raise Exception('Expecting to see item ID 6 in items!')
+        if unlocks['items'][6]['type'] != 7:
+            raise Exception('Expecting to see item ID 6 to have type 7 in items!')
+        if unlocks['items'][6]['param'] != 8:
+            raise Exception('Expecting to see item ID 6 to have param 8 in items!')
+        if unlocks['lumina'][0]['lumina'] != 150:
+            raise Exception('Got wrong value for lumina {} after purchase!'.format(unlocks['lumina'][0]['lumina']))
+
+        if cardid is None:
+            # Verify score handling
+            scores = self.verify_player23_read_score(ref_id)
+            for medal in scores['medals']:
+                raise Exception('Got nonzero medals count on a new card!')
+            for score in scores['scores']:
+                raise Exception('Got nonzero scores count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 76543,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 6,
+                            'score': 99999,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 741,
+                            'chart': 3,
+                            'medal': 2,
+                            'score': 45000,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 742,
+                            'chart': 1,
+                            'medal': 2,
+                            'score': 1,
+                        },
+                    ]
+                    # Random score to add in
+                    songid = random.randint(907, 950)
+                    chartid = random.randint(0, 3)
+                    score = random.randint(0, 100000)
+                    medal = random.randint(1, 11)
+                    dummyscores.append({
+                        'id': songid,
+                        'chart': chartid,
+                        'medal': medal,
+                        'score': score,
+                    })
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 98765,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 3,
+                            'score': 12345,
+                            'expected_score': 99999,
+                            'expected_medal': 6,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_player23_write_music(ref_id, dummyscore)
+                scores = self.verify_player23_read_score(ref_id)
+                for expected in dummyscores:
+                    newscore = scores['scores'][expected['id']][expected['chart']]
+                    newmedal = scores['medals'][expected['id']][expected['chart']]
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_medal' in expected:
+                        expected_medal = expected['expected_medal']
+                    else:
+                        expected_medal = expected['medal']
+
+                    if newscore != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], newscore,
+                        ))
+                    if newmedal != expected_medal:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            expected_medal, expected['id'], expected['chart'], newmedal,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/popn/fantasia.py b/bemani/client/popn/fantasia.py
new file mode 100644
index 0000000..7601276
--- /dev/null
+++ b/bemani/client/popn/fantasia.py
@@ -0,0 +1,446 @@
+import random
+import time
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class PopnMusicFantasiaClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_game_active(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'active')
+
+        # Add what Pop'n 20 would add after full unlock
+        game.set_attribute('method', 'active')
+        game.add_child(Node.s8('event', 0))
+        game.add_child(Node.s8('card_use', 0))
+        game.add_child(Node.string('name', ''))
+        game.add_child(Node.string('location_id', 'JP-1'))
+        game.add_child(Node.string('shop_name_facility', '.'))
+        game.add_child(Node.s8('pref', 50))
+        game.add_child(Node.string('shop_addr', '127.0.0.1  10000'))
+        game.add_child(Node.string('shop_name', ''))
+        game.add_child(Node.string('eacoin_price', '200,260,200,200'))
+        game.add_child(Node.s8('eacoin_available', 1))
+        game.add_child(Node.s8('dipswitch', 0))
+        game.add_child(Node.u8('max_stage', 1))
+        game.add_child(Node.u8('difficult', 4))
+        game.add_child(Node.s8('free_play', 1))
+        game.add_child(Node.s8('event_mode', 0))
+        game.add_child(Node.s8('popn_card', 0))
+        game.add_child(Node.s16('close_time', -1))
+        game.add_child(Node.s32('game_phase', 2))
+        game.add_child(Node.s32('net_phase', 0))
+        game.add_child(Node.s32('event_phase', 0))
+        game.add_child(Node.s32('card_phase', 3))
+        game.add_child(Node.s32('ir_phase', 0))
+        game.add_child(Node.u8('coin_to_credit', 1))
+        game.add_child(Node.u8('credit_to_start', 2))
+        game.add_child(Node.s32('sound_attract', 100))
+        game.add_child(Node.s8('bookkeeping', 0))
+        game.add_child(Node.s8('set_clock', 0))
+        game.add_child(Node.s32('local_clock_sec', 80011))
+        game.add_child(Node.s32('revision_sec', 0))
+        game.add_child(Node.string('crash_log', ''))
+
+        # Swap with server
+        resp = self.exchange('pnm20/game', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@status")
+
+    def verify_game_get(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('location_id', 'JP-1')
+        game.set_attribute('method', 'get')
+        game.add_child(Node.s8('card_enable', 0))
+        game.add_child(Node.s8('card_soldout', 1))
+
+        # Swap with server
+        resp = self.exchange('pnm20/game', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+        for name in [
+            'game_phase',
+            'ir_phase',
+            'event_phase',
+            'netvs_phase',
+            'illust_phase',
+            'psp_phase',
+            'other_phase',
+            'jubeat_phase',
+            'public_phase',
+            'kac_phase',
+            'local_matching',
+            'n_matching_sec',
+            'l_matching_sec',
+            'is_check_cpu',
+            'week_no',
+        ]:
+            node = resp.child('game').child(name)
+
+            if node is None:
+                raise Exception('Missing node \'{}\' in response!'.format(name))
+            if node.data_type != 's32':
+                raise Exception('Node \'{}\' has wrong data type!'.format(name))
+
+        sel_ranking = resp.child('game').child('sel_ranking')
+        up_ranking = resp.child('game').child('up_ranking')
+        ng_illust = resp.child('game').child('ng_illust')
+
+        for nodepair in [
+            ('sel_ranking', sel_ranking, 's16'),
+            ('up_ranking', up_ranking, 's16'),
+            ('ng_illust', ng_illust, 's32'),
+        ]:
+            name = nodepair[0]
+            node = nodepair[1]
+            dtype = nodepair[2]
+
+            if node is None:
+                raise Exception('Missing node \'{}\' in response!'.format(name))
+            if node.data_type != dtype:
+                raise Exception('Node \'{}\' has wrong data type!'.format(name))
+            if not node.is_array:
+                raise Exception('Node \'{}\' is not array!'.format(name))
+            if len(node.value) != 10:
+                raise Exception('Node \'{}\' is wrong array length!'.format(name))
+
+    def verify_playerdata_get(self, ref_id: str, msg_type: str) -> Optional[Dict[str, Any]]:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'get')
+        if msg_type == 'new':
+            playerdata.set_attribute('model', self.config['old_profile_model'].split(':')[0])
+
+        playerdata.add_child(Node.string('ref_id', ref_id))
+        playerdata.add_child(Node.string('shop_name', ''))
+        playerdata.add_child(Node.s8('pref', 50))
+        playerdata.add_child(Node.s32('navigate', 1))
+
+        # Swap with server
+        resp = self.exchange('pnm20/playerdata', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/playerdata/@status")
+
+            status = int(resp.child('playerdata').attribute('status'))
+            if status != 109:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+            # No score data
+            return None
+        elif msg_type == 'query':
+            # Verify that the response is correct
+            self.assert_path(resp, "response/playerdata/base/g_pm_id")
+            self.assert_path(resp, "response/playerdata/base/name")
+            self.assert_path(resp, "response/playerdata/base/my_best")
+            self.assert_path(resp, "response/playerdata/base/latest_music")
+            self.assert_path(resp, "response/playerdata/base/clear_medal")
+            self.assert_path(resp, "response/playerdata/base/clear_medal_sub")
+            self.assert_path(resp, "response/playerdata/player_card")
+            self.assert_path(resp, "response/playerdata/player_card_ex")
+            self.assert_path(resp, "response/playerdata/hiscore")
+            self.assert_path(resp, "response/playerdata/netvs")
+            self.assert_path(resp, "response/playerdata/sp_data")
+            self.assert_path(resp, "response/playerdata/reflec_data")
+            self.assert_path(resp, "response/playerdata/navigate")
+
+            name = resp.child('playerdata').child('base').child('name').value
+            if name != self.NAME:
+                raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+            # Extract and return score data
+            self.assert_path(resp, "response/playerdata/base/clear_medal")
+
+            def transform_medals(medal: int) -> Tuple[int, int, int, int]:
+                return (
+                    (medal >> 0) & 0xF,
+                    (medal >> 4) & 0xF,
+                    (medal >> 8) & 0xF,
+                    (medal >> 12) & 0xF,
+                )
+
+            medals = [transform_medals(medal) for medal in resp.child('playerdata').child('base').child('clear_medal').value]
+
+            hiscore = resp.child('playerdata').child('hiscore').value
+            hiscores = []
+            for i in range(0, len(hiscore) * 8, 17):
+                byte_offset = int(i / 8)
+                bit_offset = int(i % 8)
+
+                value = hiscore[byte_offset]
+                value = value + (hiscore[byte_offset + 1] << 8)
+                value = value + (hiscore[byte_offset + 2] << 16)
+
+                value = value >> bit_offset
+                hiscores.append(value & 0x1FFFF)
+
+            scores = [(hiscores[x], hiscores[x + 1], hiscores[x + 2], hiscores[x + 3]) for x in range(0, len(hiscores), 4)]
+
+            return {'medals': medals, 'scores': scores}
+
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_playerdata_set(self, ref_id: str, scores: List[Dict[str, Any]]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'set')
+        playerdata.set_attribute('ref_id', ref_id)
+        playerdata.set_attribute('shop_name', '')
+
+        # Add required children
+        playerdata.add_child(Node.s16('chara', 1543))
+
+        # Add requested scores
+        for score in scores:
+            stage = Node.void('stage')
+            playerdata.add_child(stage)
+            stage.add_child(Node.s16('no', score['id']))
+            stage.add_child(Node.u8('sheet', {
+                0: 2,
+                1: 0,
+                2: 1,
+                3: 3,
+            }[score['chart']]))
+            stage.add_child(Node.u16('n_data', (score['medal'] << (4 * score['chart']))))
+            stage.add_child(Node.u8('e_data', 0))
+            stage.add_child(Node.s32('score', score['score']))
+            stage.add_child(Node.u8('ojama_1', 0))
+            stage.add_child(Node.u8('ojama_2', 0))
+
+        # Swap with server
+        resp = self.exchange('pnm20/playerdata', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/playerdata/name")
+
+        name = resp.child('playerdata').child('name').value
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+    def verify_playerdata_new(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'new')
+
+        playerdata.add_child(Node.string('ref_id', ref_id))
+        playerdata.add_child(Node.string('name', self.NAME))
+        playerdata.add_child(Node.string('shop_name', ''))
+        playerdata.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('pnm20/playerdata', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/playerdata/base/g_pm_id")
+        self.assert_path(resp, "response/playerdata/base/name")
+        self.assert_path(resp, "response/playerdata/base/my_best")
+        self.assert_path(resp, "response/playerdata/base/latest_music")
+        self.assert_path(resp, "response/playerdata/base/clear_medal")
+        self.assert_path(resp, "response/playerdata/base/clear_medal_sub")
+        self.assert_path(resp, "response/playerdata/player_card")
+        self.assert_path(resp, "response/playerdata/player_card_ex")
+        self.assert_path(resp, "response/playerdata/hiscore")
+        self.assert_path(resp, "response/playerdata/netvs")
+        self.assert_path(resp, "response/playerdata/sp_data")
+        self.assert_path(resp, "response/playerdata/reflec_data")
+        self.assert_path(resp, "response/playerdata/navigate")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_game_active()
+        self.verify_game_get()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_playerdata_get(ref_id, msg_type='new')
+            self.verify_playerdata_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            scores = self.verify_playerdata_get(ref_id, msg_type='query')
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            for medal in scores['medals']:
+                for i in range(4):
+                    if medal[i] != 0:
+                        raise Exception('Got nonzero medals count on a new card!')
+            for score in scores['scores']:
+                for i in range(4):
+                    if score[i] != 0:
+                        raise Exception('Got nonzero scores count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 76543,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 6,
+                            'score': 99999,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 741,
+                            'chart': 3,
+                            'medal': 2,
+                            'score': 45000,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 742,
+                            'chart': 1,
+                            'medal': 2,
+                            'score': 1,
+                        },
+                    ]
+                    # Random score to add in
+                    songid = random.randint(907, 950)
+                    chartid = random.randint(0, 3)
+                    score = random.randint(0, 100000)
+                    medal = random.choice([1, 2, 3, 5, 6, 7, 9, 10, 11, 15])
+                    dummyscores.append({
+                        'id': songid,
+                        'chart': chartid,
+                        'medal': medal,
+                        'score': score,
+                    })
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 98765,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 3,
+                            'score': 12345,
+                            'expected_score': 99999,
+                            'expected_medal': 6,
+                        },
+                    ]
+
+                self.verify_playerdata_set(ref_id, dummyscores)
+                scores = self.verify_playerdata_get(ref_id, msg_type='query')
+                for score in dummyscores:
+                    newscore = scores['scores'][score['id']][score['chart']]
+                    newmedal = scores['medals'][score['id']][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+                    if 'expected_medal' in score:
+                        expected_medal = score['expected_medal']
+                    else:
+                        expected_medal = score['medal']
+
+                    if newscore != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore,
+                        ))
+                    if newmedal != expected_medal:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            expected_medal, score['id'], score['chart'], newmedal,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/popn/lapistoria.py b/bemani/client/popn/lapistoria.py
new file mode 100644
index 0000000..0c9e1f8
--- /dev/null
+++ b/bemani/client/popn/lapistoria.py
@@ -0,0 +1,360 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class PopnMusicLapistoriaClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb22_boot(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        pcb22 = Node.void('pcb22')
+        call.add_child(pcb22)
+        pcb22.set_attribute('method', 'boot')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb22/@status")
+
+    def verify_info22_common(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        info22 = Node.void('info22')
+        call.add_child(info22)
+        info22.set_attribute('loc_id', 'JP-1')
+        info22.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info22")
+
+        for name in [
+            'phase',
+            'story',
+        ]:
+            node = resp.child('info22').child(name)
+
+            if node is None:
+                raise Exception('Missing node \'{}\' in response!'.format(name))
+            if node.data_type != 'void':
+                raise Exception('Node \'{}\' has wrong data type!'.format(name))
+
+    def verify_player22_read(self, ref_id: str, msg_type: str) -> Optional[Dict[str, Any]]:
+        call = self.call_node()
+
+        # Construct node
+        player22 = Node.void('player22')
+        call.add_child(player22)
+        player22.set_attribute('method', 'read')
+
+        player22.add_child(Node.string('ref_id', value=ref_id))
+        player22.add_child(Node.string('shop_name', ''))
+        player22.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/player22/@status")
+
+            status = int(resp.child('player22').attribute('status'))
+            if status != 109:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+            # No score data
+            return None
+        elif msg_type == 'query':
+            # Verify that the response is correct
+            self.assert_path(resp, "response/player22/account/name")
+            self.assert_path(resp, "response/player22/account/g_pm_id")
+            self.assert_path(resp, "response/player22/account/my_best")
+            self.assert_path(resp, "response/player22/account/latest_music")
+            self.assert_path(resp, "response/player22/netvs")
+            self.assert_path(resp, "response/player22/config")
+            self.assert_path(resp, "response/player22/option")
+            self.assert_path(resp, "response/player22/info")
+            self.assert_path(resp, "response/player22/custom_cate")
+            self.assert_path(resp, "response/player22/customize")
+
+            name = resp.child('player22').child('account').child('name').value
+            if name != self.NAME:
+                raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+            # Extract and return score data
+            medals: Dict[int, List[int]] = {}
+            scores: Dict[int, List[int]] = {}
+            for child in resp.child('player22').children:
+                if child.name == 'music':
+                    songid = child.child_value('music_num')
+                    chart = child.child_value('sheet_num')
+                    medal = child.child_value('clear_type')
+                    points = child.child_value('score')
+
+                    if songid not in medals:
+                        medals[songid] = [0, 0, 0, 0]
+                    medals[songid][chart] = medal
+                    if songid not in scores:
+                        scores[songid] = [0, 0, 0, 0]
+                    scores[songid][chart] = points
+
+            return {'medals': medals, 'scores': scores}
+
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_player22_write(self, ref_id: str, scores: List[Dict[str, Any]]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player22 = Node.void('player22')
+        call.add_child(player22)
+        player22.set_attribute('method', 'write')
+        player22.add_child(Node.string('ref_id', value=ref_id))
+
+        # Add required children
+        config = Node.void('config')
+        player22.add_child(config)
+        config.add_child(Node.s16('chara', value=1543))
+
+        # Add requested scores
+        for score in scores:
+            stage = Node.void('stage')
+            player22.add_child(stage)
+            stage.add_child(Node.s16('no', score['id']))
+            stage.add_child(Node.u8('sheet', score['chart']))
+            stage.add_child(Node.u16('clearmedal', score['medal']))
+            stage.add_child(Node.s32('nscore', score['score']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player22/@status")
+
+    def verify_player22_write_music(self, ref_id: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player22 = Node.void('player22')
+        call.add_child(player22)
+        player22.set_attribute('method', 'write_music')
+        player22.add_child(Node.string('ref_id', ref_id))
+        player22.add_child(Node.string('name', self.NAME))
+        player22.add_child(Node.u8('stage', 0))
+        player22.add_child(Node.s16('music_num', score['id']))
+        player22.add_child(Node.u8('sheet_num', score['chart']))
+        player22.add_child(Node.u8('clearmedal', score['medal']))
+        player22.add_child(Node.s32('score', score['score']))
+        player22.add_child(Node.s16('combo', 0))
+        player22.add_child(Node.s16('cool', 0))
+        player22.add_child(Node.s16('great', 0))
+        player22.add_child(Node.s16('good', 0))
+        player22.add_child(Node.s16('bad', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player22/@status")
+
+    def verify_player22_new(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player22 = Node.void('player22')
+        call.add_child(player22)
+        player22.set_attribute('method', 'new')
+
+        player22.add_child(Node.string('ref_id', ref_id))
+        player22.add_child(Node.string('name', self.NAME))
+        player22.add_child(Node.string('shop_name', ''))
+        player22.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/player22/account")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_pcb22_boot()
+        self.verify_info22_common()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_player22_read(ref_id, msg_type='new')
+            self.verify_player22_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            scores = self.verify_player22_read(ref_id, msg_type='query')
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            for medal in scores['medals']:
+                for i in range(4):
+                    if medal[i] != 0:
+                        raise Exception('Got nonzero medals count on a new card!')
+            for score in scores['scores']:
+                for i in range(4):
+                    if score[i] != 0:
+                        raise Exception('Got nonzero scores count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 76543,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 6,
+                            'score': 99999,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 741,
+                            'chart': 3,
+                            'medal': 2,
+                            'score': 45000,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 742,
+                            'chart': 1,
+                            'medal': 2,
+                            'score': 1,
+                        },
+                    ]
+                    # Random score to add in
+                    songid = random.randint(907, 950)
+                    chartid = random.randint(0, 3)
+                    score = random.randint(0, 100000)
+                    medal = random.randint(1, 11)
+                    dummyscores.append({
+                        'id': songid,
+                        'chart': chartid,
+                        'medal': medal,
+                        'score': score,
+                    })
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 98765,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 3,
+                            'score': 12345,
+                            'expected_score': 99999,
+                            'expected_medal': 6,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_player22_write_music(ref_id, dummyscore)
+                self.verify_player22_write(ref_id, dummyscores)
+                scores = self.verify_player22_read(ref_id, msg_type='query')
+                for score in dummyscores:
+                    newscore = scores['scores'][score['id']][score['chart']]
+                    newmedal = scores['medals'][score['id']][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+                    if 'expected_medal' in score:
+                        expected_medal = score['expected_medal']
+                    else:
+                        expected_medal = score['medal']
+
+                    if newscore != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore,
+                        ))
+                    if newmedal != expected_medal:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            expected_medal, score['id'], score['chart'], newmedal,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/popn/sunnypark.py b/bemani/client/popn/sunnypark.py
new file mode 100644
index 0000000..785115c
--- /dev/null
+++ b/bemani/client/popn/sunnypark.py
@@ -0,0 +1,395 @@
+import random
+import time
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class PopnMusicSunnyParkClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_game_active(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'active')
+
+        # Add minimum amount of stuff so server accepts
+        game.add_child(Node.s8('event', 0))
+
+        # Swap with server
+        resp = self.exchange('pnm20/game', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@status")
+
+    def verify_game_get(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('location_id', 'JP-1')
+        game.set_attribute('method', 'get')
+        game.add_child(Node.s8('event', 0))
+
+        # Swap with server
+        resp = self.exchange('pnm20/game', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+        for name in [
+            'ir_phase',
+            'music_open_phase',
+            'collabo_phase',
+            'personal_event_phase',
+            'shop_event_phase',
+            'netvs_phase',
+            'card_phase',
+            'other_phase',
+            'local_matching_enable',
+            'n_matching_sec',
+            'l_matching_sec',
+            'is_check_cpu',
+            'week_no',
+        ]:
+            node = resp.child('game').child(name)
+
+            if node is None:
+                raise Exception('Missing node \'{}\' in response!'.format(name))
+            if node.data_type != 's32':
+                raise Exception('Node \'{}\' has wrong data type!'.format(name))
+
+        sel_ranking = resp.child('game').child('sel_ranking')
+        up_ranking = resp.child('game').child('up_ranking')
+
+        for nodepair in [('sel_ranking', sel_ranking), ('up_ranking', up_ranking)]:
+            name = nodepair[0]
+            node = nodepair[1]
+
+            if node is None:
+                raise Exception('Missing node \'{}\' in response!'.format(name))
+            if node.data_type != 's16':
+                raise Exception('Node \'{}\' has wrong data type!'.format(name))
+            if not node.is_array:
+                raise Exception('Node \'{}\' is not array!'.format(name))
+            if len(node.value) != 5:
+                raise Exception('Node \'{}\' is wrong array length!'.format(name))
+
+    def verify_playerdata_get(self, ref_id: str, msg_type: str) -> Optional[Dict[str, Any]]:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'get')
+        if msg_type == 'new':
+            playerdata.set_attribute('model', self.config['old_profile_model'].split(':')[0])
+
+        playerdata.add_child(Node.string('ref_id', ref_id))
+        playerdata.add_child(Node.string('shop_name', ''))
+        playerdata.add_child(Node.s8('pref', 51))
+        if msg_type == 'new':
+            playerdata.add_child(Node.s32('ir_num', 0))
+        elif msg_type == 'query':
+            playerdata.add_child(Node.s32('gakuen', 2))
+            playerdata.add_child(Node.s32('zoo', 1))
+            playerdata.add_child(Node.s32('floor_infection', 1))
+            playerdata.add_child(Node.s32('triple_journey', 1))
+            playerdata.add_child(Node.s32('baseball', 1))
+
+        # Swap with server
+        resp = self.exchange('pnm20/playerdata', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/playerdata/@status")
+
+            status = int(resp.child('playerdata').attribute('status'))
+            if status != 109:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+            # No score data
+            return None
+        elif msg_type == 'query':
+            # Verify that the response is correct
+            self.assert_path(resp, "response/playerdata/base/name")
+            self.assert_path(resp, "response/playerdata/base/g_pm_id")
+            self.assert_path(resp, "response/playerdata/base/my_best")
+            self.assert_path(resp, "response/playerdata/base/latest_music")
+            self.assert_path(resp, "response/playerdata/avatar")
+            self.assert_path(resp, "response/playerdata/avatar_add")
+            self.assert_path(resp, "response/playerdata/netvs")
+            self.assert_path(resp, "response/playerdata/sp_data")
+            self.assert_path(resp, "response/playerdata/hiscore")
+
+            name = resp.child('playerdata').child('base').child('name').value
+            if name != self.NAME:
+                raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+            # Extract and return score data
+            self.assert_path(resp, "response/playerdata/base/clear_medal")
+
+            def transform_medals(medal: int) -> Tuple[int, int, int, int]:
+                return (
+                    (medal >> 0) & 0xF,
+                    (medal >> 4) & 0xF,
+                    (medal >> 8) & 0xF,
+                    (medal >> 12) & 0xF,
+                )
+
+            medals = [transform_medals(medal) for medal in resp.child('playerdata').child('base').child('clear_medal').value]
+
+            hiscore = resp.child('playerdata').child('hiscore').value
+            hiscores = []
+            for i in range(0, len(hiscore) * 8, 17):
+                byte_offset = int(i / 8)
+                bit_offset = int(i % 8)
+
+                value = hiscore[byte_offset]
+                value = value + (hiscore[byte_offset + 1] << 8)
+                value = value + (hiscore[byte_offset + 2] << 16)
+
+                value = value >> bit_offset
+                hiscores.append(value & 0x1FFFF)
+
+            scores = [(hiscores[x], hiscores[x + 1], hiscores[x + 2], hiscores[x + 3]) for x in range(0, len(hiscores), 4)]
+
+            return {'medals': medals, 'scores': scores}
+
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_playerdata_set(self, ref_id: str, scores: List[Dict[str, Any]]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'set')
+        playerdata.set_attribute('ref_id', ref_id)
+        playerdata.set_attribute('shop_name', '')
+
+        # Add required children
+        playerdata.add_child(Node.s16('chara', 1543))
+
+        # Add requested scores
+        for score in scores:
+            stage = Node.void('stage')
+            playerdata.add_child(stage)
+            stage.add_child(Node.s16('no', score['id']))
+            stage.add_child(Node.u8('sheet', score['chart']))
+            stage.add_child(Node.u16('n_data', (score['medal'] << (4 * score['chart']))))
+            stage.add_child(Node.s32('score', score['score']))
+
+        # Swap with server
+        resp = self.exchange('pnm20/playerdata', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/playerdata/name")
+
+        name = resp.child('playerdata').child('name').value
+        if name != self.NAME:
+            raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+    def verify_playerdata_new(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'new')
+
+        playerdata.add_child(Node.string('ref_id', ref_id))
+        playerdata.add_child(Node.string('name', self.NAME))
+        playerdata.add_child(Node.string('shop_name', ''))
+        playerdata.add_child(Node.s8('pref', 51))
+        playerdata.add_child(Node.s8('gakuen', 2))
+        playerdata.add_child(Node.s8('zoo', 1))
+        playerdata.add_child(Node.s8('floor_infection', 1))
+        playerdata.add_child(Node.s8('triple_journey', 1))
+        playerdata.add_child(Node.s8('baseball', 1))
+
+        # Swap with server
+        resp = self.exchange('pnm20/playerdata', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/playerdata/base")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_game_active()
+        self.verify_game_get()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_playerdata_get(ref_id, msg_type='new')
+            self.verify_playerdata_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            scores = self.verify_playerdata_get(ref_id, msg_type='query')
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            for medal in scores['medals']:
+                for i in range(4):
+                    if medal[i] != 0:
+                        raise Exception('Got nonzero medals count on a new card!')
+            for score in scores['scores']:
+                for i in range(4):
+                    if score[i] != 0:
+                        raise Exception('Got nonzero scores count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 76543,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 6,
+                            'score': 99999,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 741,
+                            'chart': 3,
+                            'medal': 2,
+                            'score': 45000,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 742,
+                            'chart': 1,
+                            'medal': 2,
+                            'score': 1,
+                        },
+                    ]
+                    # Random score to add in
+                    songid = random.randint(907, 950)
+                    chartid = random.randint(0, 3)
+                    score = random.randint(0, 100000)
+                    medal = random.choice([1, 2, 3, 5, 6, 7, 9, 10, 11, 15])
+                    dummyscores.append({
+                        'id': songid,
+                        'chart': chartid,
+                        'medal': medal,
+                        'score': score,
+                    })
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 98765,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 3,
+                            'score': 12345,
+                            'expected_score': 99999,
+                            'expected_medal': 6,
+                        },
+                    ]
+
+                self.verify_playerdata_set(ref_id, dummyscores)
+                scores = self.verify_playerdata_get(ref_id, msg_type='query')
+                for score in dummyscores:
+                    newscore = scores['scores'][score['id']][score['chart']]
+                    newmedal = scores['medals'][score['id']][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+                    if 'expected_medal' in score:
+                        expected_medal = score['expected_medal']
+                    else:
+                        expected_medal = score['medal']
+
+                    if newscore != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore,
+                        ))
+                    if newmedal != expected_medal:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            expected_medal, score['id'], score['chart'], newmedal,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/popn/tunestreet.py b/bemani/client/popn/tunestreet.py
new file mode 100644
index 0000000..bb3b180
--- /dev/null
+++ b/bemani/client/popn/tunestreet.py
@@ -0,0 +1,383 @@
+import random
+import time
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class PopnMusicTuneStreetClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_game_active(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'active')
+
+        # Add what Pop'n 19 would add after full unlock
+        game.set_attribute('eacoin_price', '200,260,200,200,10')
+        game.set_attribute('event', '0')
+        game.set_attribute('shop_name_facility', '.')
+        game.set_attribute('name', '')
+        game.set_attribute('location_id', 'JP-1')
+        game.set_attribute('shop_addr', '127.0.0.1  10000')
+        game.set_attribute('card_use', '0')
+        game.set_attribute('testmode', '0,1,1,4,0,-1,2,1,2,100,0,0,80513,0,92510336')
+        game.set_attribute('eacoin_available', '1')
+        game.set_attribute('pref', '0')
+        game.set_attribute('shop_name', '')
+
+        # Swap with server
+        resp = self.exchange('pnm/game', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@status")
+
+    def verify_game_get(self) -> None:
+        call = self.call_node()
+
+        # Construct node
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'get')
+
+        # Swap with server
+        resp = self.exchange('pnm/game', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+        for name in [
+            'game_phase',
+            'psp_phase',
+        ]:
+            if name not in resp.child('game').attributes:
+                raise Exception('Missing attribute \'{}\' in response!'.format(name))
+
+    def verify_playerdata_get(self, ref_id: str, msg_type: str) -> Optional[Dict[str, Any]]:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'get')
+        playerdata.set_attribute('pref', '50')
+        playerdata.set_attribute('shop_name', '')
+        playerdata.set_attribute('ref_id', ref_id)
+
+        if msg_type == 'new':
+            playerdata.set_attribute('model', self.config['old_profile_model'].split(':')[0])
+
+        # Swap with server
+        resp = self.exchange('pnm/playerdata', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/playerdata/@status")
+
+            status = int(resp.child('playerdata').attribute('status'))
+            if status != 109:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+            # No score data
+            return None
+        elif msg_type == 'query':
+            # Verify that the response is correct
+            self.assert_path(resp, "response/playerdata/b")
+            self.assert_path(resp, "response/playerdata/hiscore")
+            self.assert_path(resp, "response/playerdata/town")
+
+            name = resp.child('playerdata').child('b').value[0:12].decode('SHIFT_JIS').replace("\x00", "")
+            if name != self.NAME:
+                raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+            medals = resp.child('playerdata').child('b').value[108:]
+            medals = [(medals[x] + (medals[x + 1] << 8)) for x in range(0, len(medals), 2)]
+
+            # Extract and return score data
+            def transform_medals(medal: int) -> Tuple[int, int, int, int]:
+                return (
+                    (medal >> 0) & 0x3,
+                    (medal >> 2) & 0x3,
+                    (medal >> 4) & 0x3,
+                    (medal >> 6) & 0x3,
+                )
+
+            medals = [transform_medals(medal) for medal in medals]
+
+            hiscore = resp.child('playerdata').child('hiscore').value
+            hiscores = []
+            for i in range(0, len(hiscore) * 8, 17):
+                byte_offset = int(i / 8)
+                bit_offset = int(i % 8)
+
+                try:
+                    value = hiscore[byte_offset]
+                    value = value + (hiscore[byte_offset + 1] << 8)
+                    value = value + (hiscore[byte_offset + 2] << 16)
+
+                    value = value >> bit_offset
+                    hiscores.append(value & 0x1FFFF)
+                except IndexError:
+                    # We indexed poorly above, so we ran into an odd value
+                    pass
+
+            scores = [
+                (
+                    hiscores[x + 1],
+                    hiscores[x + 2],
+                    hiscores[x + 0],
+                    hiscores[x + 3],
+                ) for x in range(0, len(hiscores), 7)
+            ]
+
+            return {'medals': medals, 'scores': scores}
+
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_playerdata_set(self, ref_id: str, scores: List[Dict[str, Any]]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'set')
+        playerdata.set_attribute('last_play_flag', '0')
+        playerdata.set_attribute('play_mode', '3')
+        playerdata.set_attribute('music_num', '550')
+        playerdata.set_attribute('category_num', '14')
+        playerdata.set_attribute('norma_point', '0')
+        playerdata.set_attribute('medal_and_friend', '0')
+        playerdata.set_attribute('option', '131072')
+        playerdata.set_attribute('color_3p_flg', '0,0')
+        playerdata.set_attribute('sheet_num', '1')
+        playerdata.set_attribute('skin_sd_bgm', '0')
+        playerdata.set_attribute('read_news_no_max', '0')
+        playerdata.set_attribute('shop_name', '')
+        playerdata.set_attribute('skin_sd_se', '0')
+        playerdata.set_attribute('start_type', '2')
+        playerdata.set_attribute('skin_tex_note', '0')
+        playerdata.set_attribute('ref_id', ref_id)
+        playerdata.set_attribute('chara_num', '12')
+        playerdata.set_attribute('jubeat_collabo', '0')
+        playerdata.set_attribute('pref', '50')
+        playerdata.set_attribute('skin_tex_cmn', '0')
+
+        # Add requested scores
+        for score in scores:
+            music = Node.void('music')
+            playerdata.add_child(music)
+            music.set_attribute('norma_r', '0')
+            music.set_attribute('data', str({
+                0: ((score['medal'] & 0x3) << 0) | 0x0800,
+                1: ((score['medal'] & 0x3) << 2) | 0x1000,
+                2: ((score['medal'] & 0x3) << 4) | 0x2000,
+                3: ((score['medal'] & 0x3) << 6) | 0x4000,
+            }[score['chart']]))
+            music.set_attribute('select_count', '1')
+            music.set_attribute('music_num', str(score['id']))
+            music.set_attribute('norma_l', '0')
+            music.set_attribute('score', str(score['score']))
+            music.set_attribute('sheet_num', str(score['chart']))
+
+        # Swap with server
+        self.exchange('pnm/playerdata', call)
+
+    def verify_playerdata_new(self, card_id: str, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        playerdata = Node.void('playerdata')
+        call.add_child(playerdata)
+        playerdata.set_attribute('method', 'new')
+        playerdata.set_attribute('ref_id', ref_id)
+        playerdata.set_attribute('card_id', card_id)
+        playerdata.set_attribute('name', self.NAME)
+        playerdata.set_attribute('shop_name', '')
+        playerdata.set_attribute('pref', '50')
+
+        # Swap with server
+        resp = self.exchange('pnm/playerdata', call)
+
+        # Verify nodes that cause crashes if they don't exist
+        self.assert_path(resp, "response/playerdata/b")
+        self.assert_path(resp, "response/playerdata/hiscore")
+        self.assert_path(resp, "response/playerdata/town")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_game_active()
+        self.verify_game_get()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_playerdata_get(ref_id, msg_type='new')
+            self.verify_playerdata_new(card, ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        if cardid is None:
+            # Verify score handling
+            scores = self.verify_playerdata_get(ref_id, msg_type='query')
+            if scores is None:
+                raise Exception('Expected to get scores back, didn\'t get anything!')
+            for medal in scores['medals']:
+                for i in range(4):
+                    if medal[i] != 0:
+                        raise Exception('Got nonzero medals count on a new card!')
+            for score in scores['scores']:
+                for i in range(4):
+                    if score[i] != 0:
+                        raise Exception('Got nonzero scores count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 2,
+                            'score': 76543,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 3,
+                            'score': 99999,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 741,
+                            'chart': 3,
+                            'medal': 1,
+                            'score': 45000,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 742,
+                            'chart': 1,
+                            'medal': 0,
+                            'score': 1,
+                        },
+                    ]
+                    # Random score to add in
+                    songid = random.randint(907, 950)
+                    chartid = random.randint(0, 3)
+                    score = random.randint(0, 100000)
+                    medal = random.choice([0, 1, 2, 3])
+                    dummyscores.append({
+                        'id': songid,
+                        'chart': chartid,
+                        'medal': medal,
+                        'score': score,
+                    })
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 3,
+                            'score': 98765,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 2,
+                            'score': 12345,
+                            'expected_score': 99999,
+                            'expected_medal': 3,
+                        },
+                    ]
+
+                self.verify_playerdata_set(ref_id, dummyscores)
+                scores = self.verify_playerdata_get(ref_id, msg_type='query')
+                for score in dummyscores:
+                    newscore = scores['scores'][score['id']][score['chart']]
+                    newmedal = scores['medals'][score['id']][score['chart']]
+
+                    if 'expected_score' in score:
+                        expected_score = score['expected_score']
+                    else:
+                        expected_score = score['score']
+                    if 'expected_medal' in score:
+                        expected_medal = score['expected_medal']
+                    else:
+                        expected_medal = score['medal']
+
+                    if newscore != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, score['id'], score['chart'], newscore,
+                        ))
+                    if newmedal != expected_medal:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            expected_medal, score['id'], score['chart'], newmedal,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/popn/usaneko.py b/bemani/client/popn/usaneko.py
new file mode 100644
index 0000000..0734282
--- /dev/null
+++ b/bemani/client/popn/usaneko.py
@@ -0,0 +1,675 @@
+import random
+import time
+from typing import Any, Dict, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class PopnMusicUsaNekoClient(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb24_boot(self, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        pcb24 = Node.void('pcb24')
+        call.add_child(pcb24)
+        pcb24.set_attribute('method', 'boot')
+        pcb24.add_child(Node.string('loc_id', loc))
+        pcb24.add_child(Node.u8('loc_type', 0))
+        pcb24.add_child(Node.string('loc_name', ''))
+        pcb24.add_child(Node.string('country', 'US'))
+        pcb24.add_child(Node.string('region', '.'))
+        pcb24.add_child(Node.s16('pref', 51))
+        pcb24.add_child(Node.string('customer', ''))
+        pcb24.add_child(Node.string('company', ''))
+        pcb24.add_child(Node.ipv4('gip', '127.0.0.1'))
+        pcb24.add_child(Node.u16('gp', 10011))
+        pcb24.add_child(Node.string('rom_number', 'M39-JB-G01'))
+        pcb24.add_child(Node.u64('c_drive', 10028228608))
+        pcb24.add_child(Node.u64('d_drive', 47945170944))
+        pcb24.add_child(Node.u64('e_drive', 10394677248))
+        pcb24.add_child(Node.string('etc', ''))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb24/@status")
+
+    def __verify_common(self, root: str, resp: Node) -> None:
+        self.assert_path(resp, "response/{}/phase/event_id".format(root))
+        self.assert_path(resp, "response/{}/phase/phase".format(root))
+        self.assert_path(resp, "response/{}/area/area_id".format(root))
+        self.assert_path(resp, "response/{}/area/end_date".format(root))
+        self.assert_path(resp, "response/{}/area/medal_id".format(root))
+        self.assert_path(resp, "response/{}/area/is_limit".format(root))
+        self.assert_path(resp, "response/{}/choco/choco_id".format(root))
+        self.assert_path(resp, "response/{}/choco/param".format(root))
+        self.assert_path(resp, "response/{}/goods/item_id".format(root))
+        self.assert_path(resp, "response/{}/goods/item_type".format(root))
+        self.assert_path(resp, "response/{}/goods/price".format(root))
+        self.assert_path(resp, "response/{}/goods/goods_type".format(root))
+
+    def verify_info24_common(self, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        info24 = Node.void('info24')
+        call.add_child(info24)
+        info24.set_attribute('loc_id', loc)
+        info24.set_attribute('method', 'common')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.__verify_common('info24', resp)
+
+    def verify_lobby24_getlist(self, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        lobby24 = Node.void('lobby24')
+        call.add_child(lobby24)
+        lobby24.set_attribute('method', 'getList')
+        lobby24.add_child(Node.string('location_id', loc))
+        lobby24.add_child(Node.u8('net_version', 63))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby24/@status")
+
+    def __verify_profile(self, resp: Node) -> None:
+        self.assert_path(resp, "response/player24/account/name")
+        self.assert_path(resp, "response/player24/account/g_pm_id")
+        self.assert_path(resp, "response/player24/account/tutorial")
+        self.assert_path(resp, "response/player24/account/area_id")
+        self.assert_path(resp, "response/player24/account/use_navi")
+        self.assert_path(resp, "response/player24/account/read_news")
+        self.assert_path(resp, "response/player24/account/nice")
+        self.assert_path(resp, "response/player24/account/favorite_chara")
+        self.assert_path(resp, "response/player24/account/special_area")
+        self.assert_path(resp, "response/player24/account/chocolate_charalist")
+        self.assert_path(resp, "response/player24/account/chocolate_sp_chara")
+        self.assert_path(resp, "response/player24/account/chocolate_pass_cnt")
+        self.assert_path(resp, "response/player24/account/chocolate_hon_cnt")
+        self.assert_path(resp, "response/player24/account/teacher_setting")
+        self.assert_path(resp, "response/player24/account/welcom_pack")
+        self.assert_path(resp, "response/player24/account/ranking_node")
+        self.assert_path(resp, "response/player24/account/chara_ranking_kind_id")
+        self.assert_path(resp, "response/player24/account/navi_evolution_flg")
+        self.assert_path(resp, "response/player24/account/ranking_news_last_no")
+        self.assert_path(resp, "response/player24/account/power_point")
+        self.assert_path(resp, "response/player24/account/player_point")
+        self.assert_path(resp, "response/player24/account/power_point_list")
+        self.assert_path(resp, "response/player24/account/staff")
+        self.assert_path(resp, "response/player24/account/item_type")
+        self.assert_path(resp, "response/player24/account/item_id")
+        self.assert_path(resp, "response/player24/account/is_conv")
+        self.assert_path(resp, "response/player24/account/license_data")
+        self.assert_path(resp, "response/player24/account/my_best")
+        self.assert_path(resp, "response/player24/account/latest_music")
+        self.assert_path(resp, "response/player24/account/total_play_cnt")
+        self.assert_path(resp, "response/player24/account/today_play_cnt")
+        self.assert_path(resp, "response/player24/account/consecutive_days")
+        self.assert_path(resp, "response/player24/account/total_days")
+        self.assert_path(resp, "response/player24/account/interval_day")
+        self.assert_path(resp, "response/player24/account/active_fr_num")
+        self.assert_path(resp, "response/player24/eaappli/relation")
+        self.assert_path(resp, "response/player24/info/ep")
+        self.assert_path(resp, "response/player24/config")
+        self.assert_path(resp, "response/player24/option")
+        self.assert_path(resp, "response/player24/custom_cate")
+        self.assert_path(resp, "response/player24/navi_data")
+        self.assert_path(resp, "response/player24/mission/mission_id")
+        self.assert_path(resp, "response/player24/mission/gauge_point")
+        self.assert_path(resp, "response/player24/mission/mission_comp")
+        self.assert_path(resp, "response/player24/netvs")
+        self.assert_path(resp, "response/player24/customize")
+        self.assert_path(resp, "response/player24/stamp/stamp_id")
+        self.assert_path(resp, "response/player24/stamp/cnt")
+
+    def verify_player24_read(self, ref_id: str, msg_type: str) -> Dict[str, Dict[int, Dict[str, int]]]:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'read')
+
+        player24.add_child(Node.string('ref_id', ref_id))
+        player24.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        if msg_type == 'new':
+            # Verify that response is correct
+            self.assert_path(resp, "response/player24/result")
+            status = resp.child_value('player24/result')
+            if status != 2:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+
+            return {
+                'items': {},
+                'characters': {},
+                'points': {},
+            }
+        elif msg_type == 'query':
+            # Verify that the response is correct
+            self.__verify_profile(resp)
+
+            self.assert_path(resp, "response/player24/result")
+            status = resp.child_value('player24/result')
+            if status != 0:
+                raise Exception('Reference ID \'{}\' returned invalid status \'{}\''.format(ref_id, status))
+            name = resp.child_value('player24/account/name')
+            if name != self.NAME:
+                raise Exception('Invalid name \'{}\' returned for Ref ID \'{}\''.format(name, ref_id))
+
+            # Medals and items
+            items: Dict[int, Dict[str, int]] = {}
+            charas: Dict[int, Dict[str, int]] = {}
+            courses: Dict[int, Dict[str, int]] = {}
+            for obj in resp.child('player24').children:
+                if obj.name == 'item':
+                    items[obj.child_value('id')] = {
+                        'type': obj.child_value('type'),
+                        'param': obj.child_value('param'),
+                    }
+                elif obj.name == 'chara_param':
+                    charas[obj.child_value('chara_id')] = {
+                        'friendship': obj.child_value('friendship'),
+                    }
+                elif obj.name == 'course_data':
+                    courses[obj.child_value('course_id')] = {
+                        'clear_type': obj.child_value('clear_type'),
+                        'clear_rank': obj.child_value('clear_rank'),
+                        'total_score': obj.child_value('total_score'),
+                        'count': obj.child_value('update_count'),
+                        'sheet_num': obj.child_value('sheet_num'),
+                    }
+
+            return {
+                'items': items,
+                'characters': charas,
+                'courses': courses,
+                'points': {0: {'points': resp.child_value('player24/account/player_point')}},
+            }
+        else:
+            raise Exception('Unrecognized message type \'{}\''.format(msg_type))
+
+    def verify_player24_read_score(self, ref_id: str) -> Dict[str, Dict[int, Dict[int, int]]]:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'read_score')
+
+        player24.add_child(Node.string('ref_id', ref_id))
+        player24.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify defaults
+        self.assert_path(resp, "response/player24/@status")
+
+        # Grab scores
+        scores: Dict[int, Dict[int, int]] = {}
+        medals: Dict[int, Dict[int, int]] = {}
+        ranks: Dict[int, Dict[int, int]] = {}
+        for child in resp.child('player24').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_num')
+            chart = child.child_value('sheet_num')
+            score = child.child_value('score')
+            medal = child.child_value('clear_type')
+            rank = child.child_value('clear_rank')
+
+            if musicid not in scores:
+                scores[musicid] = {}
+            if musicid not in medals:
+                medals[musicid] = {}
+            if musicid not in ranks:
+                ranks[musicid] = {}
+
+            scores[musicid][chart] = score
+            medals[musicid][chart] = medal
+            ranks[musicid][chart] = rank
+
+        return {
+            'scores': scores,
+            'medals': medals,
+            'ranks': ranks,
+        }
+
+    def verify_player24_start(self, ref_id: str, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('loc_id', loc)
+        player24.set_attribute('ref_id', ref_id)
+        player24.set_attribute('method', 'start')
+        player24.set_attribute('start_type', '0')
+        pcb_card = Node.void('pcb_card')
+        player24.add_child(pcb_card)
+        pcb_card.add_child(Node.s8('card_enable', 1))
+        pcb_card.add_child(Node.s8('card_soldout', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.__verify_common('player24', resp)
+
+    def verify_player24_update_ranking(self, ref_id: str, loc: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'update_ranking')
+        player24.add_child(Node.s16('pref', 51))
+        player24.add_child(Node.string('location_id', loc))
+        player24.add_child(Node.string('ref_id', ref_id))
+        player24.add_child(Node.string('name', self.NAME))
+        player24.add_child(Node.s16('chara_num', 1))
+        player24.add_child(Node.s16('course_id', 12345))
+        player24.add_child(Node.s32('total_score', 86000))
+        player24.add_child(Node.s16('music_num', 1375))
+        player24.add_child(Node.u8('sheet_num', 2))
+        player24.add_child(Node.u8('clear_type', 7))
+        player24.add_child(Node.u8('clear_rank', 5))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player24/all_ranking/name")
+        self.assert_path(resp, "response/player24/all_ranking/chara_num")
+        self.assert_path(resp, "response/player24/all_ranking/total_score")
+        self.assert_path(resp, "response/player24/all_ranking/clear_type")
+        self.assert_path(resp, "response/player24/all_ranking/clear_rank")
+        self.assert_path(resp, "response/player24/all_ranking/player_count")
+        self.assert_path(resp, "response/player24/all_ranking/player_rank")
+
+    def verify_player24_logout(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('ref_id', ref_id)
+        player24.set_attribute('method', 'logout')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player24/@status")
+
+    def verify_player24_write(
+        self,
+        ref_id: str,
+        item: Optional[Dict[str, int]]=None,
+        character: Optional[Dict[str, int]]=None,
+    ) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'write')
+        player24.add_child(Node.string('ref_id', ref_id))
+
+        # Add required children
+        config = Node.void('config')
+        player24.add_child(config)
+        config.add_child(Node.s16('chara', 1543))
+
+        if item is not None:
+            itemnode = Node.void('item')
+            player24.add_child(itemnode)
+            itemnode.add_child(Node.u8('type', item['type']))
+            itemnode.add_child(Node.u16('id', item['id']))
+            itemnode.add_child(Node.u16('param', item['param']))
+            itemnode.add_child(Node.bool('is_new', False))
+            itemnode.add_child(Node.u64('get_time', 0))
+
+        if character is not None:
+            chara_param = Node.void('chara_param')
+            player24.add_child(chara_param)
+            chara_param.add_child(Node.u16('chara_id', character['id']))
+            chara_param.add_child(Node.u16('friendship', character['friendship']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player24/@status")
+
+    def verify_player24_buy(self, ref_id: str, item: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'buy')
+        player24.add_child(Node.s32('play_id', 0))
+        player24.add_child(Node.string('ref_id', ref_id))
+        player24.add_child(Node.u16('id', item['id']))
+        player24.add_child(Node.u8('type', item['type']))
+        player24.add_child(Node.u16('param', item['param']))
+        player24.add_child(Node.s32('lumina', item['points']))
+        player24.add_child(Node.u16('price', item['price']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player24/@status")
+
+    def verify_player24_write_music(self, ref_id: str, score: Dict[str, Any]) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'write_music')
+        player24.add_child(Node.string('ref_id', ref_id))
+        player24.add_child(Node.string('data_id', ref_id))
+        player24.add_child(Node.string('name', self.NAME))
+        player24.add_child(Node.u8('stage', 0))
+        player24.add_child(Node.s16('music_num', score['id']))
+        player24.add_child(Node.u8('sheet_num', score['chart']))
+        player24.add_child(Node.u8('clear_type', score['medal']))
+        player24.add_child(Node.s32('score', score['score']))
+        player24.add_child(Node.s16('combo', 0))
+        player24.add_child(Node.s16('cool', 0))
+        player24.add_child(Node.s16('great', 0))
+        player24.add_child(Node.s16('good', 0))
+        player24.add_child(Node.s16('bad', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+        self.assert_path(resp, "response/player24/@status")
+
+    def verify_player24_new(self, ref_id: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        player24 = Node.void('player24')
+        call.add_child(player24)
+        player24.set_attribute('method', 'new')
+
+        player24.add_child(Node.string('ref_id', ref_id))
+        player24.add_child(Node.string('name', self.NAME))
+        player24.add_child(Node.s8('pref', 51))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify nodes
+        self.__verify_profile(resp)
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_pcb24_boot(location)
+        self.verify_info24_common(location)
+        self.verify_lobby24_getlist(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            self.verify_player24_read(ref_id, msg_type='new')
+            self.verify_player24_new(ref_id)
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify proper handling of basic stuff
+        self.verify_player24_read(ref_id, msg_type='query')
+        self.verify_player24_start(ref_id, location)
+        self.verify_player24_write(ref_id)
+        self.verify_player24_logout(ref_id)
+
+        if cardid is None:
+            # Verify unlocks/story mode work
+            unlocks = self.verify_player24_read(ref_id, msg_type='query')
+            for item in unlocks['items']:
+                if item in [1592, 1608]:
+                    # Song unlocks after one play
+                    continue
+                raise Exception('Got nonzero items count on a new card!')
+            for char in unlocks['characters']:
+                raise Exception('Got nonzero characters count on a new card!')
+            for course in unlocks['courses']:
+                raise Exception('Got nonzero course count on a new card!')
+            if unlocks['points'][0]['points'] != 300:
+                raise Exception('Got wrong default value for points on a new card!')
+
+            self.verify_player24_write(ref_id, item={'id': 4, 'type': 2, 'param': 69})
+            unlocks = self.verify_player24_read(ref_id, msg_type='query')
+            if 4 not in unlocks['items']:
+                raise Exception('Expecting to see item ID 4 in items!')
+            if unlocks['items'][4]['type'] != 2:
+                raise Exception('Expecting to see item ID 4 to have type 2 in items!')
+            if unlocks['items'][4]['param'] != 69:
+                raise Exception('Expecting to see item ID 4 to have param 69 in items!')
+
+            self.verify_player24_write(ref_id, character={'id': 5, 'friendship': 420})
+            unlocks = self.verify_player24_read(ref_id, msg_type='query')
+            if 5 not in unlocks['characters']:
+                raise Exception('Expecting to see chara ID 5 in characters!')
+            if unlocks['characters'][5]['friendship'] != 420:
+                raise Exception('Expecting to see chara ID 5 to have type 2 in characters!')
+
+            # Verify purchases work
+            self.verify_player24_buy(ref_id, item={'id': 6, 'type': 3, 'param': 8, 'points': 400, 'price': 250})
+            unlocks = self.verify_player24_read(ref_id, msg_type='query')
+            if 6 not in unlocks['items']:
+                raise Exception('Expecting to see item ID 6 in items!')
+            if unlocks['items'][6]['type'] != 3:
+                raise Exception('Expecting to see item ID 6 to have type 3 in items!')
+            if unlocks['items'][6]['param'] != 8:
+                raise Exception('Expecting to see item ID 6 to have param 8 in items!')
+            if unlocks['points'][0]['points'] != 150:
+                raise Exception('Got wrong value for points {} after purchase!'.format(unlocks['points'][0]['points']))
+
+            # Verify course handling
+            self.verify_player24_update_ranking(ref_id, location)
+            unlocks = self.verify_player24_read(ref_id, msg_type='query')
+            if 12345 not in unlocks['courses']:
+                raise Exception('Expecting to see course ID 12345 in courses!')
+            if unlocks['courses'][12345]['clear_type'] != 7:
+                raise Exception('Expecting to see item ID 12345 to have clear_type 7 in courses!')
+            if unlocks['courses'][12345]['clear_rank'] != 5:
+                raise Exception('Expecting to see item ID 12345 to have clear_rank 5 in courses!')
+            if unlocks['courses'][12345]['total_score'] != 86000:
+                raise Exception('Expecting to see item ID 12345 to have total_score 86000 in courses!')
+            if unlocks['courses'][12345]['count'] != 1:
+                raise Exception('Expecting to see item ID 12345 to have count 1 in courses!')
+            if unlocks['courses'][12345]['sheet_num'] != 2:
+                raise Exception('Expecting to see item ID 12345 to have sheet_num 2 in courses!')
+
+            # Verify score handling
+            scores = self.verify_player24_read_score(ref_id)
+            for medal in scores['medals']:
+                raise Exception('Got nonzero medals count on a new card!')
+            for score in scores['scores']:
+                raise Exception('Got nonzero scores count on a new card!')
+
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 5,
+                            'score': 76543,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 6,
+                            'score': 99999,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 741,
+                            'chart': 3,
+                            'medal': 2,
+                            'score': 45000,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 742,
+                            'chart': 1,
+                            'medal': 2,
+                            'score': 1,
+                        },
+                    ]
+                    # Random score to add in
+                    songid = random.randint(907, 950)
+                    chartid = random.randint(0, 3)
+                    score = random.randint(0, 100000)
+                    medal = random.randint(1, 11)
+                    dummyscores.append({
+                        'id': songid,
+                        'chart': chartid,
+                        'medal': medal,
+                        'score': score,
+                    })
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 987,
+                            'chart': 2,
+                            'medal': 6,
+                            'score': 98765,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 987,
+                            'chart': 0,
+                            'medal': 3,
+                            'score': 12345,
+                            'expected_score': 99999,
+                            'expected_medal': 6,
+                        },
+                    ]
+
+                for dummyscore in dummyscores:
+                    self.verify_player24_write_music(ref_id, dummyscore)
+                scores = self.verify_player24_read_score(ref_id)
+                for expected in dummyscores:
+                    newscore = scores['scores'][expected['id']][expected['chart']]
+                    newmedal = scores['medals'][expected['id']][expected['chart']]
+                    newrank = scores['ranks'][expected['id']][expected['chart']]
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_medal' in expected:
+                        expected_medal = expected['expected_medal']
+                    else:
+                        expected_medal = expected['medal']
+
+                    if newscore < 50000:
+                        expected_rank = 1
+                    elif newscore < 62000:
+                        expected_rank = 2
+                    elif newscore < 72000:
+                        expected_rank = 3
+                    elif newscore < 82000:
+                        expected_rank = 4
+                    elif newscore < 90000:
+                        expected_rank = 5
+                    elif newscore < 95000:
+                        expected_rank = 6
+                    elif newscore < 98000:
+                        expected_rank = 7
+                    else:
+                        expected_rank = 8
+
+                    if newscore != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], newscore,
+                        ))
+                    if newmedal != expected_medal:
+                        raise Exception('Expected a medal of \'{}\' for song \'{}\' chart \'{}\' but got medal \'{}\''.format(
+                            expected_medal, expected['id'], expected['chart'], newmedal,
+                        ))
+                    if newrank != expected_rank:
+                        raise Exception('Expected a rank of \'{}\' for song \'{}\' chart \'{}\' but got rank \'{}\''.format(
+                            expected_rank, expected['id'], expected['chart'], newrank,
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/protocol.py b/bemani/client/protocol.py
new file mode 100644
index 0000000..0424861
--- /dev/null
+++ b/bemani/client/protocol.py
@@ -0,0 +1,81 @@
+import requests
+
+from bemani.client.common import random_hex_string
+from bemani.protocol import EAmuseProtocol, Node
+
+
+class ClientProtocol:
+    def __init__(self, address: str, port: int, encryption: bool, compression: bool, verbose: bool) -> None:
+        self.__address = address
+        self.__port = port
+        self.__encryption = encryption
+        self.__compression = compression
+        self.__verbose = verbose
+
+    def exchange(self, uri: str, tree: Node, text_encoding: str="shift-jis", packet_encoding: str="binary") -> Node:
+        headers = {}
+
+        if self.__verbose:
+            print('Outgoing request:')
+            print(tree)
+
+        # Handle encoding
+        if packet_encoding == "xml":
+            _packet_encoding = EAmuseProtocol.XML
+        elif packet_encoding == "binary":
+            _packet_encoding = EAmuseProtocol.BINARY
+        else:
+            raise Exception("Unknown packet encoding {}".format(packet_encoding))
+
+        # Handle encryption
+        if self.__encryption:
+            encryption = '1-{}-{}'.format(
+                random_hex_string(8),
+                random_hex_string(4),
+            )
+            headers['X-Eamuse-Info'] = encryption
+        else:
+            encryption = None
+
+        # Handle compression
+        if self.__compression:
+            compression = 'lz77'
+        else:
+            compression = None
+        headers['X-Compress'] = compression
+
+        # Convert it
+        proto = EAmuseProtocol()
+        req = proto.encode(
+            compression,
+            encryption,
+            tree,
+            text_encoding=text_encoding,
+            packet_encoding=_packet_encoding,
+        )
+
+        # Send the request, get the response
+        r = requests.post(
+            'http://{}:{}/{}'.format(
+                self.__address,
+                self.__port,
+                uri,
+            ),
+            headers=headers,
+            data=req,
+        )
+
+        # Get the compression and encryption
+        encryption = headers.get('X-Eamuse-Info')
+        compression = headers.get('X-Compress')
+
+        # Decode it
+        packet = proto.decode(
+            compression,
+            encryption,
+            r.content,
+        )
+        if self.__verbose:
+            print('Incoming response:')
+            print(packet)
+        return packet
diff --git a/bemani/client/reflec/__init__.py b/bemani/client/reflec/__init__.py
new file mode 100644
index 0000000..8e51d06
--- /dev/null
+++ b/bemani/client/reflec/__init__.py
@@ -0,0 +1,6 @@
+from bemani.client.reflec.reflec import ReflecBeat
+from bemani.client.reflec.limelight import ReflecBeatLimelight
+from bemani.client.reflec.colette import ReflecBeatColette
+from bemani.client.reflec.groovin import ReflecBeatGroovinUpper
+from bemani.client.reflec.volzza import ReflecBeatVolzza
+from bemani.client.reflec.volzza2 import ReflecBeatVolzza2
diff --git a/bemani/client/reflec/colette.py b/bemani/client/reflec/colette.py
new file mode 100644
index 0000000..75c90da
--- /dev/null
+++ b/bemani/client/reflec/colette.py
@@ -0,0 +1,692 @@
+import random
+import time
+from typing import Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class ReflecBeatColette(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb_boot(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        pcb.set_attribute('method', 'boot')
+        pcb.add_child(Node.string('lid', loc))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/sinfo/nm")
+        self.assert_path(resp, "response/pcb/sinfo/cl_enbl")
+        self.assert_path(resp, "response/pcb/sinfo/cl_h")
+        self.assert_path(resp, "response/pcb/sinfo/cl_m")
+
+    def verify_info_common(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'common')
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/event_ctrl")
+        self.assert_path(resp, "response/info/item_lock_ctrl")
+
+    def verify_info_ranking(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'ranking')
+        info.add_child(Node.s32('ver', 0))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/ver")
+        self.assert_path(resp, "response/info/ranking/weekly/bt")
+        self.assert_path(resp, "response/info/ranking/weekly/et")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/monthly/bt")
+        self.assert_path(resp, "response/info/ranking/monthly/et")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/total/bt")
+        self.assert_path(resp, "response/info/ranking/total/et")
+        self.assert_path(resp, "response/info/ranking/total/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/total/new/d/cnt")
+
+    def verify_player_start(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'start')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        player.add_child(Node.u16('gp', 10573))
+        player.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/plyid")
+        self.assert_path(resp, "response/player/start_time")
+        self.assert_path(resp, "response/player/event_ctrl")
+        self.assert_path(resp, "response/player/item_lock_ctrl")
+        self.assert_path(resp, "response/player/lincle_link_4")
+        self.assert_path(resp, "response/player/jbrbcollabo")
+        self.assert_path(resp, "response/player/tricolettepark")
+
+    def verify_player_delete(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'delete')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_end(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'end')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_succeed(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'succeed')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/name")
+        self.assert_path(resp, "response/player/lv")
+        self.assert_path(resp, "response/player/exp")
+        self.assert_path(resp, "response/player/grd")
+        self.assert_path(resp, "response/player/ap")
+        self.assert_path(resp, "response/player/released")
+        self.assert_path(resp, "response/player/mrecord")
+
+    def verify_player_read(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'read')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s16('ver', 5))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/pdata/account/usrid")
+        self.assert_path(resp, "response/player/pdata/account/tpc")
+        self.assert_path(resp, "response/player/pdata/account/dpc")
+        self.assert_path(resp, "response/player/pdata/account/crd")
+        self.assert_path(resp, "response/player/pdata/account/brd")
+        self.assert_path(resp, "response/player/pdata/account/tdc")
+        self.assert_path(resp, "response/player/pdata/account/intrvld")
+        self.assert_path(resp, "response/player/pdata/account/ver")
+        self.assert_path(resp, "response/player/pdata/account/pst")
+        self.assert_path(resp, "response/player/pdata/account/st")
+        self.assert_path(resp, "response/player/pdata/base/name")
+        self.assert_path(resp, "response/player/pdata/base/exp")
+        self.assert_path(resp, "response/player/pdata/base/lv")
+        self.assert_path(resp, "response/player/pdata/base/mg")
+        self.assert_path(resp, "response/player/pdata/base/ap")
+        self.assert_path(resp, "response/player/pdata/base/tid")
+        self.assert_path(resp, "response/player/pdata/base/tname")
+        self.assert_path(resp, "response/player/pdata/base/cmnt")
+        self.assert_path(resp, "response/player/pdata/base/uattr")
+        self.assert_path(resp, "response/player/pdata/base/hidden_param")
+        self.assert_path(resp, "response/player/pdata/base/tbs")
+        self.assert_path(resp, "response/player/pdata/base/tbs_r")
+        self.assert_path(resp, "response/player/pdata/rival")
+        self.assert_path(resp, "response/player/pdata/fav_music_slot")
+        self.assert_path(resp, "response/player/pdata/custom")
+        self.assert_path(resp, "response/player/pdata/config")
+        self.assert_path(resp, "response/player/pdata/stamp")
+        self.assert_path(resp, "response/player/pdata/released")
+        self.assert_path(resp, "response/player/pdata/record")
+
+        if resp.child_value('player/pdata/base/name') != self.NAME:
+            raise Exception('Invalid name {} returned on profile read!'.format(resp.child_value('player/pdata/base/name')))
+
+        scores = []
+        for child in resp.child('player/pdata/record').children:
+            if child.name != 'rec':
+                continue
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ntgrd'),
+                'clear_type': child.child_value('ct'),
+                'achievement_rate': child.child_value('ar'),
+                'score': child.child_value('scr'),
+                'combo': child.child_value('cmb'),
+                'miss_count': child.child_value('ms'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_write(self, refid: str, loc: str, scores: List[Dict[str, int]]) -> int:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'write')
+        pdata = Node.void('pdata')
+        player.add_child(pdata)
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', 0))
+        account.add_child(Node.s32('plyid', 0))
+        account.add_child(Node.s32('tpc', 1))
+        account.add_child(Node.s32('dpc', 1))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', 1))
+        account.add_child(Node.string('rid', refid))
+        account.add_child(Node.string('lid', loc))
+        account.add_child(Node.u8('mode', 0))
+        account.add_child(Node.s16('ver', 5))
+        account.add_child(Node.bool('pp', True))
+        account.add_child(Node.bool('ps', True))
+        account.add_child(Node.s16('pay', 0))
+        account.add_child(Node.s16('pay_pc', 0))
+        account.add_child(Node.u64('st', int(time.time() * 1000)))
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', self.NAME))
+        base.add_child(Node.s32('exp', 0))
+        base.add_child(Node.s32('lv', 1))
+        base.add_child(Node.s32('mg', -1))
+        base.add_child(Node.s32('ap', -1))
+        base.add_child(Node.s32_array('hidden_param', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        base.add_child(Node.bool('is_tut', True))
+        stglog = Node.void('stglog')
+        pdata.add_child(stglog)
+        index = 0
+        for score in scores:
+            log = Node.void('log')
+            stglog.add_child(log)
+            log.add_child(Node.s8('stg', index))
+            log.add_child(Node.s16('mid', score['id']))
+            log.add_child(Node.s8('ng', score['chart']))
+            log.add_child(Node.s8('col', 0))
+            log.add_child(Node.s8('mt', 7))
+            log.add_child(Node.s8('rt', 0))
+            log.add_child(Node.s8('ct', score['clear_type']))
+            log.add_child(Node.s16('grd', 0))
+            log.add_child(Node.s16('ar', score['achievement_rate']))
+            log.add_child(Node.s16('sc', score['score']))
+            log.add_child(Node.s16('jt_jst', 0))
+            log.add_child(Node.s16('jt_grt', 0))
+            log.add_child(Node.s16('jt_gd', 0))
+            log.add_child(Node.s16('jt_ms', score['miss_count']))
+            log.add_child(Node.s16('jt_jr', 0))
+            log.add_child(Node.s16('cmb', score['combo']))
+            log.add_child(Node.s16('exp', 0))
+            log.add_child(Node.s32('r_uid', 0))
+            log.add_child(Node.s32('r_plyid', 0))
+            log.add_child(Node.s8('r_stg', 0))
+            log.add_child(Node.s8('r_ct', -1))
+            log.add_child(Node.s16('r_sc', 0))
+            log.add_child(Node.s16('r_grd', 0))
+            log.add_child(Node.s16('r_ar', 0))
+            log.add_child(Node.s8('r_cpuid', -1))
+            log.add_child(Node.s32('time', int(time.time())))
+            log.add_child(Node.s8('decide', 0))
+            index = index + 1
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/uid")
+        return resp.child_value('player/uid')
+
+    def verify_lobby_read(self, location: str, extid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'read')
+        lobby.add_child(Node.s32('uid', extid))
+        lobby.add_child(Node.u8('m_grade', 255))
+        lobby.add_child(Node.string('lid', location))
+        lobby.add_child(Node.s32('max', 128))
+        lobby.add_child(Node.s32_array('friend', []))
+        lobby.add_child(Node.u8('var', 5))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+
+    def verify_lobby_entry(self, location: str, extid: int) -> int:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'entry')
+        e = Node.void('e')
+        lobby.add_child(e)
+        e.add_child(Node.s32('eid', 0))
+        e.add_child(Node.u16('mid', 79))
+        e.add_child(Node.u8('ng', 0))
+        e.add_child(Node.s32('uid', extid))
+        e.add_child(Node.s32('uattr', 0))
+        e.add_child(Node.string('pn', self.NAME))
+        e.add_child(Node.s16('mg', 255))
+        e.add_child(Node.s32('mopt', 0))
+        e.add_child(Node.s32('tid', 0))
+        e.add_child(Node.string('tn', ''))
+        e.add_child(Node.s32('topt', 0))
+        e.add_child(Node.string('lid', location))
+        e.add_child(Node.string('sn', ''))
+        e.add_child(Node.u8('pref', 51))
+        e.add_child(Node.s8('stg', 4))
+        e.add_child(Node.s8('pside', 0))
+        e.add_child(Node.s16('eatime', 30))
+        e.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        e.add_child(Node.u16('gp', 10007))
+        e.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        e.add_child(Node.u8('ver', 5))
+        lobby.add_child(Node.s32_array('friend', []))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+        self.assert_path(resp, "response/lobby/eid")
+        self.assert_path(resp, "response/lobby/e/eid")
+        self.assert_path(resp, "response/lobby/e/mid")
+        self.assert_path(resp, "response/lobby/e/ng")
+        self.assert_path(resp, "response/lobby/e/uid")
+        self.assert_path(resp, "response/lobby/e/uattr")
+        self.assert_path(resp, "response/lobby/e/pn")
+        self.assert_path(resp, "response/lobby/e/mg")
+        self.assert_path(resp, "response/lobby/e/mopt")
+        self.assert_path(resp, "response/lobby/e/tid")
+        self.assert_path(resp, "response/lobby/e/tn")
+        self.assert_path(resp, "response/lobby/e/topt")
+        self.assert_path(resp, "response/lobby/e/lid")
+        self.assert_path(resp, "response/lobby/e/sn")
+        self.assert_path(resp, "response/lobby/e/pref")
+        self.assert_path(resp, "response/lobby/e/stg")
+        self.assert_path(resp, "response/lobby/e/pside")
+        self.assert_path(resp, "response/lobby/e/eatime")
+        self.assert_path(resp, "response/lobby/e/ga")
+        self.assert_path(resp, "response/lobby/e/gp")
+        self.assert_path(resp, "response/lobby/e/la")
+        self.assert_path(resp, "response/lobby/e/ver")
+        return resp.child_value('lobby/eid')
+
+    def verify_lobby_delete(self, eid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'delete')
+        lobby.add_child(Node.s32('eid', eid))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby")
+
+    def verify_pzlcmt_read(self, extid: int) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'pzlcmt_read')
+        info.add_child(Node.s32('uid', extid))
+        info.add_child(Node.s32('tid', 0))
+        info.add_child(Node.s32('time', 0))
+        info.add_child(Node.s32('limit', 30))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/comment/time")
+        self.assert_path(resp, "response/info/c/uid")
+        self.assert_path(resp, "response/info/c/name")
+        self.assert_path(resp, "response/info/c/icon")
+        self.assert_path(resp, "response/info/c/bln")
+        self.assert_path(resp, "response/info/c/tid")
+        self.assert_path(resp, "response/info/c/t_name")
+        self.assert_path(resp, "response/info/c/pref")
+        self.assert_path(resp, "response/info/c/time")
+        self.assert_path(resp, "response/info/c/comment")
+        self.assert_path(resp, "response/info/c/is_tweet")
+
+        # Verify we posted our comment earlier
+        found = False
+        for child in resp.child('info').children:
+            if child.name != 'c':
+                continue
+            if child.child_value('uid') == extid:
+                name = child.child_value('name')
+                comment = child.child_value('comment')
+                if name != self.NAME:
+                    raise Exception('Invalid name \'{}\' returned for comment!'.format(name))
+                if comment != 'アメ〜〜！':
+                    raise Exception('Invalid comment \'{}\' returned for comment!'.format(comment))
+                found = True
+
+        if not found:
+            raise Exception('Comment we posted was not found!')
+
+    def verify_pzlcmt_write(self, extid: int) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'pzlcmt_write')
+        info.add_child(Node.s32('uid', extid))
+        info.add_child(Node.string('name', self.NAME))
+        info.add_child(Node.s16('icon', 0))
+        info.add_child(Node.s8('bln', 0))
+        info.add_child(Node.s32('tid', 0))
+        info.add_child(Node.string('t_name', ''))
+        info.add_child(Node.s8('pref', 51))
+        info.add_child(Node.s32('time', int(time.time())))
+        info.add_child(Node.string('comment', 'アメ〜〜！'))
+        info.add_child(Node.bool('is_tweet', True))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info")
+
+    def verify_jbrbcollabo_save(self, refid: str) -> None:
+        call = self.call_node()
+
+        jbrbcollabo = Node.void('jbrbcollabo')
+        jbrbcollabo.set_attribute('method', 'save')
+        jbrbcollabo.add_child(Node.string('ref_id', refid))
+        jbrbcollabo.add_child(Node.u16('cre_count', 0))
+        call.add_child(jbrbcollabo)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/jbrbcollabo")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_pcb_boot(location)
+        self.verify_info_common()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Always get a player start, regardless of new profile or not
+            self.verify_player_start(ref_id)
+            self.verify_player_delete(ref_id)
+            self.verify_player_succeed(ref_id)
+            extid = self.verify_player_write(
+                ref_id,
+                location,
+                [{
+                    'id': 0,
+                    'chart': 0,
+                    'clear_type': -1,
+                    'achievement_rate': 0,
+                    'score': 0,
+                    'combo': 0,
+                    'miss_count': 0,
+                }]
+            )
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify lobby functionality
+        self.verify_lobby_read(location, extid)
+        eid = self.verify_lobby_entry(location, extid)
+        self.verify_lobby_delete(eid)
+
+        # Verify puzzle comment read and write
+        self.verify_pzlcmt_write(extid)
+        self.verify_pzlcmt_read(extid)
+
+        # Verify Jubeat/ReflecBeat collabo save
+        self.verify_jbrbcollabo_save(ref_id)
+
+        if cardid is None:
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 2,
+                            'achievement_rate': 7543,
+                            'score': 432,
+                            'combo': 123,
+                            'miss_count': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 4,
+                            'achievement_rate': 9876,
+                            'score': 543,
+                            'combo': 543,
+                            'miss_count': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 3,
+                            'chart': 2,
+                            'clear_type': 2,
+                            'achievement_rate': 1234,
+                            'score': 123,
+                            'combo': 42,
+                            'miss_count': 54,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'clear_type': 2,
+                            'achievement_rate': 1024,
+                            'score': 50,
+                            'combo': 12,
+                            'miss_count': 90,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 3,
+                            'achievement_rate': 8765,
+                            'score': 469,
+                            'combo': 468,
+                            'miss_count': 1,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 2,
+                            'achievement_rate': 8765,
+                            'score': 432,
+                            'combo': 321,
+                            'miss_count': 15,
+                            'expected_score': 543,
+                            'expected_clear_type': 4,
+                            'expected_achievement_rate': 9876,
+                            'expected_combo': 543,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+                self.verify_player_write(ref_id, location, dummyscores)
+
+                scores = self.verify_player_read(ref_id, location)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_achievement_rate' in expected:
+                        expected_achievement_rate = expected['expected_achievement_rate']
+                    else:
+                        expected_achievement_rate = expected['achievement_rate']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+                    if 'expected_combo' in expected:
+                        expected_combo = expected['expected_combo']
+                    else:
+                        expected_combo = expected['combo']
+                    if 'expected_miss_count' in expected:
+                        expected_miss_count = expected['expected_miss_count']
+                    else:
+                        expected_miss_count = expected['miss_count']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['achievement_rate'] != expected_achievement_rate:
+                        raise Exception('Expected an achievement rate of \'{}\' for song \'{}\' chart \'{}\' but got achievement rate \'{}\''.format(
+                            expected_achievement_rate, expected['id'], expected['chart'], actual['achievement_rate'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+                    if actual['combo'] != expected_combo:
+                        raise Exception('Expected a combo of \'{}\' for song \'{}\' chart \'{}\' but got combo \'{}\''.format(
+                            expected_combo, expected['id'], expected['chart'], actual['combo'],
+                        ))
+                    if actual['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, expected['id'], expected['chart'], actual['miss_count'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify ending game
+        self.verify_player_end(ref_id)
+
+        # Verify high score tables
+        self.verify_info_ranking()
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/reflec/groovin.py b/bemani/client/reflec/groovin.py
new file mode 100644
index 0000000..05115d4
--- /dev/null
+++ b/bemani/client/reflec/groovin.py
@@ -0,0 +1,915 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class ReflecBeatGroovinUpper(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb_rb4boot(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        pcb.set_attribute('method', 'rb4boot')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.string('rno', 'Unknown'))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/sinfo/nm")
+        self.assert_path(resp, "response/pcb/sinfo/cl_enbl")
+        self.assert_path(resp, "response/pcb/sinfo/cl_h")
+        self.assert_path(resp, "response/pcb/sinfo/cl_m")
+        self.assert_path(resp, "response/pcb/sinfo/shop_flag")
+
+    def verify_pcb_rb4error(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        call.add_child(pcb)
+        pcb.set_attribute('method', 'rb4error')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.string('code', 'exception'))
+        pcb.add_child(Node.string('msg', 'exceptionstring'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/@status")
+
+    def verify_info_rb4common(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        call.add_child(info)
+        info.set_attribute('method', 'rb4common')
+        info.add_child(Node.string('lid', loc))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/event_ctrl")
+        self.assert_path(resp, "response/info/item_lock_ctrl")
+        self.assert_path(resp, "response/info/shop_score/today")
+        self.assert_path(resp, "response/info/shop_score/yesterday")
+
+    def verify_info_rb4shop_score_ranking(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        call.add_child(info)
+        info.set_attribute('method', 'rb4shop_score_ranking')
+        # Arbitrarily chosen based on the song IDs we send in the
+        # score section below.
+        info.add_child(Node.s16('min', 1))
+        info.add_child(Node.s16('max', 3))
+        info.add_child(Node.string('lid', loc))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/shop_score/time")
+        self.assert_path(resp, "response/info/shop_score/data/rank")
+        self.assert_path(resp, "response/info/shop_score/data/music_id")
+        self.assert_path(resp, "response/info/shop_score/data/note_grade")
+        self.assert_path(resp, "response/info/shop_score/data/clear_type")
+        self.assert_path(resp, "response/info/shop_score/data/user_id")
+        self.assert_path(resp, "response/info/shop_score/data/icon_id")
+        self.assert_path(resp, "response/info/shop_score/data/score")
+        self.assert_path(resp, "response/info/shop_score/data/time")
+        self.assert_path(resp, "response/info/shop_score/data/name")
+
+    def verify_info_rb4ranking(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'rb4ranking')
+        info.add_child(Node.s32('ver', 0))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/ver")
+        self.assert_path(resp, "response/info/ranking/weekly/bt")
+        self.assert_path(resp, "response/info/ranking/weekly/et")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/monthly/bt")
+        self.assert_path(resp, "response/info/ranking/monthly/et")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/total/bt")
+        self.assert_path(resp, "response/info/ranking/total/et")
+        self.assert_path(resp, "response/info/ranking/total/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/total/new/d/cnt")
+
+    def verify_player_rb4start(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb4start')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        player.add_child(Node.u16('gp', 10573))
+        player.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        player.add_child(Node.u8_array('pnid', [39, 16, 0, 0, 0, 23, 62, 60, 39, 127, 0, 0, 1, 23, 62, 60]))
+
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/plyid")
+        self.assert_path(resp, "response/player/start_time")
+        self.assert_path(resp, "response/player/event_ctrl")
+        self.assert_path(resp, "response/player/item_lock_ctrl")
+
+    def verify_player_rb4end(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb4end')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_rb4total_bestallrank_read(self) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb4total_bestallrank_read')
+        player.add_child(Node.s32('uid', 0))
+        player.add_child(Node.s32_array('score', [897, 897, 0, 0, 0, 284]))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/score/rank")
+        self.assert_path(resp, "response/player/score/score")
+        self.assert_path(resp, "response/player/score/allrank")
+
+    def verify_player_rb4selectscore(self, extid: int) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb4selectscore')
+        player.add_child(Node.s32('uid', extid))
+        player.add_child(Node.s32('music_id', 1))
+        player.add_child(Node.s32('note_grade', 0))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/@status")
+
+        # Verify that we got a score if the extid is nonzero
+        if extid != 0:
+            self.assert_path(resp, "response/player/player_select_score/user_id")
+            self.assert_path(resp, "response/player/player_select_score/name")
+            self.assert_path(resp, "response/player/player_select_score/m_score")
+            self.assert_path(resp, "response/player/player_select_score/m_scoreTime")
+            self.assert_path(resp, "response/player/player_select_score/m_iconID")
+
+            if resp.child_value('player/player_select_score/name') != self.NAME:
+                raise Exception(
+                    'Invalid name {} returned on score read!'.format(resp.child_value('player/player_select_score/name'))
+                )
+            if resp.child_value('player/player_select_score/user_id') != extid:
+                raise Exception(
+                    'Invalid name {} returned on score read!'.format(resp.child_value('player/player_select_score/user_id'))
+                )
+
+    def verify_player_rb4succeed(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb4succeed')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/name")
+        self.assert_path(resp, "response/player/lv")
+        self.assert_path(resp, "response/player/exp")
+        self.assert_path(resp, "response/player/grd")
+        self.assert_path(resp, "response/player/ap")
+        self.assert_path(resp, "response/player/money")
+        self.assert_path(resp, "response/player/released")
+        self.assert_path(resp, "response/player/mrecord")
+
+    def verify_player_rb4read(self, refid: str, cardid: str, location: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb4read')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s16('ver', 1))
+        player.add_child(Node.string('card_id', cardid))
+        player.add_child(Node.s16('card_type', 1))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/pdata/account/usrid")
+        self.assert_path(resp, "response/player/pdata/account/tpc")
+        self.assert_path(resp, "response/player/pdata/account/dpc")
+        self.assert_path(resp, "response/player/pdata/account/crd")
+        self.assert_path(resp, "response/player/pdata/account/brd")
+        self.assert_path(resp, "response/player/pdata/account/tdc")
+        self.assert_path(resp, "response/player/pdata/account/intrvld")
+        self.assert_path(resp, "response/player/pdata/account/ver")
+        self.assert_path(resp, "response/player/pdata/account/pst")
+        self.assert_path(resp, "response/player/pdata/account/st")
+        self.assert_path(resp, "response/player/pdata/account/debutVer")
+        self.assert_path(resp, "response/player/pdata/base/name")
+        self.assert_path(resp, "response/player/pdata/base/exp")
+        self.assert_path(resp, "response/player/pdata/base/lv")
+        self.assert_path(resp, "response/player/pdata/base/mg")
+        self.assert_path(resp, "response/player/pdata/base/ap")
+        self.assert_path(resp, "response/player/pdata/base/cmnt")
+        self.assert_path(resp, "response/player/pdata/base/uattr")
+        self.assert_path(resp, "response/player/pdata/base/money")
+        self.assert_path(resp, "response/player/pdata/base/tbs")
+        self.assert_path(resp, "response/player/pdata/base/tbs_r")
+        self.assert_path(resp, "response/player/pdata/base/tbgs")
+        self.assert_path(resp, "response/player/pdata/base/tbgs_r")
+        self.assert_path(resp, "response/player/pdata/base/tbms")
+        self.assert_path(resp, "response/player/pdata/base/tbms_r")
+        self.assert_path(resp, "response/player/pdata/base/qe_win")
+        self.assert_path(resp, "response/player/pdata/base/qe_legend")
+        self.assert_path(resp, "response/player/pdata/base/qe2_win")
+        self.assert_path(resp, "response/player/pdata/base/qe2_legend")
+        self.assert_path(resp, "response/player/pdata/base/qe3_win")
+        self.assert_path(resp, "response/player/pdata/base/qe3_legend")
+        self.assert_path(resp, "response/player/pdata/base/mlog")
+        self.assert_path(resp, "response/player/pdata/base/class")
+        self.assert_path(resp, "response/player/pdata/base/class_ar")
+        self.assert_path(resp, "response/player/pdata/base/getrfl")
+        self.assert_path(resp, "response/player/pdata/base/upper_pt")
+        self.assert_path(resp, "response/player/pdata/rival")
+        self.assert_path(resp, "response/player/pdata/stamp")
+        self.assert_path(resp, "response/player/pdata/config")
+        self.assert_path(resp, "response/player/pdata/custom")
+        self.assert_path(resp, "response/player/pdata/released")
+        self.assert_path(resp, "response/player/pdata/announce")
+        self.assert_path(resp, "response/player/pdata/dojo")
+        self.assert_path(resp, "response/player/pdata/player_param")
+        self.assert_path(resp, "response/player/pdata/shop_score")
+        self.assert_path(resp, "response/player/pdata/quest")
+        self.assert_path(resp, "response/player/pdata/derby/is_open")
+        self.assert_path(resp, "response/player/pdata/codebreaking")
+        self.assert_path(resp, "response/player/pdata/iidx_linkage")
+        self.assert_path(resp, "response/player/pdata/pue")
+
+        if resp.child_value('player/pdata/base/name') != self.NAME:
+            raise Exception('Invalid name {} returned on profile read!'.format(resp.child_value('player/pdata/base/name')))
+
+    def verify_player_rb4readscore(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb4readscore')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s16('ver', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        scores = []
+        for child in resp.child('player/pdata/record').children:
+            if child.name != 'rec':
+                continue
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ntgrd'),
+                'clear_type': child.child_value('ct'),
+                'combo_type': child.child_value('param'),
+                'achievement_rate': child.child_value('ar'),
+                'score': child.child_value('scr'),
+                'miss_count': child.child_value('ms'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_rb4readepisode(self, extid: int) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb4readepisode')
+        player.add_child(Node.s32('user_id', extid))
+        player.add_child(Node.s32('limit', 20))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        episodes = []
+        for child in resp.child('player/pdata/episode').children:
+            if child.name != 'info':
+                continue
+
+            if child.child_value('user_id') != extid:
+                raise Exception('Invalid user ID returned {}'.format(child.child_value('user_id')))
+
+            episode = {
+                'id': child.child_value('type'),
+                'user': child.child_value('user_id'),
+                'values': [
+                    child.child_value('value0'),
+                    child.child_value('value1'),
+                ],
+                'text': child.child_value('text'),
+                'time': child.child_value('time'),
+            }
+            episodes.append(episode)
+        return episodes
+
+    def verify_player_rb4write(
+        self,
+        refid: str,
+        loc: str,
+        scores: List[Dict[str, int]]=[],
+        episodes: List[Dict[str, Any]]=[],
+    ) -> int:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb4write')
+        pdata = Node.void('pdata')
+        player.add_child(pdata)
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', 0))
+        account.add_child(Node.s32('plyid', 0))
+        account.add_child(Node.s32('tpc', 1))
+        account.add_child(Node.s32('dpc', 1))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', 1))
+        account.add_child(Node.string('rid', refid))
+        account.add_child(Node.string('lid', loc))
+        account.add_child(Node.u8('wmode', 0))
+        account.add_child(Node.u8('gmode', 0))
+        account.add_child(Node.s16('ver', 1))
+        account.add_child(Node.bool('pp', False))
+        account.add_child(Node.bool('ps', False))
+        account.add_child(Node.s16('pay', 0))
+        account.add_child(Node.s16('pay_pc', 0))
+        account.add_child(Node.u64('st', int(time.time() * 1000)))
+        account.add_child(Node.u8('debutVer', 3))
+        account.add_child(Node.s32('upper_pt', 0))
+        account.add_child(Node.s32('upper_op', -1))
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', self.NAME))
+        base.add_child(Node.s32('exp', 0))
+        base.add_child(Node.s32('lv', 1))
+        base.add_child(Node.s32('mg', -1))
+        base.add_child(Node.s32('ap', -1))
+        base.add_child(Node.s32('money', 0))
+        base.add_child(Node.bool('is_tut', False))
+        base.add_child(Node.s32('class', -1))
+        base.add_child(Node.s32('class_ar', 0))
+        base.add_child(Node.s32('upper_pt', 0))
+        stglog = Node.void('stglog')
+        pdata.add_child(stglog)
+
+        index = 0
+        for score in scores:
+            log = Node.void('log')
+            stglog.add_child(log)
+            log.add_child(Node.s8('stg', index))
+            log.add_child(Node.s16('mid', score['id']))
+            log.add_child(Node.s8('ng', score['chart']))
+            log.add_child(Node.s8('col', 1))
+            log.add_child(Node.s8('mt', 0))
+            log.add_child(Node.s8('rt', 0))
+            log.add_child(Node.s8('ct', score['clear_type']))
+            log.add_child(Node.s16('param', score['combo_type']))
+            log.add_child(Node.s16('grd', 0))
+            log.add_child(Node.s16('ar', score['achievement_rate']))
+            log.add_child(Node.s16('sc', score['score']))
+            log.add_child(Node.s16('jt_jst', 0))
+            log.add_child(Node.s16('jt_grt', 0))
+            log.add_child(Node.s16('jt_gd', 0))
+            log.add_child(Node.s16('jt_ms', score['miss_count']))
+            log.add_child(Node.s16('jt_jr', 0))
+            log.add_child(Node.s32('r_uid', 0))
+            log.add_child(Node.s32('r_plyid', 0))
+            log.add_child(Node.s8('r_stg', 0))
+            log.add_child(Node.s8('r_ct', -1))
+            log.add_child(Node.s16('r_sc', 0))
+            log.add_child(Node.s16('r_grd', 0))
+            log.add_child(Node.s16('r_ar', 0))
+            log.add_child(Node.s8('r_cpuid', -1))
+            log.add_child(Node.s32('time', int(time.time())))
+            log.add_child(Node.s8('decide', 0))
+            log.add_child(Node.s8('hazard', 0))
+            index = index + 1
+
+        episode = Node.void('episode')
+        pdata.add_child(episode)
+        for ep in episodes:
+            info = Node.void('info')
+            episode.add_child(info)
+            info.add_child(Node.s32('user_id', ep['user']))
+            info.add_child(Node.u8('type', ep['id']))
+            info.add_child(Node.u16('value0', ep['values'][0]))
+            info.add_child(Node.u16('value1', ep['values'][1]))
+            info.add_child(Node.string('text', ep['text']))
+            info.add_child(Node.s32('time', ep['time']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/uid")
+        return resp.child_value('player/uid')
+
+    def verify_lobby_rb4read(self, location: str, extid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb4read')
+        lobby.add_child(Node.s32('uid', extid))
+        lobby.add_child(Node.s32('plyid', 0))
+        lobby.add_child(Node.u8('m_grade', 255))
+        lobby.add_child(Node.string('lid', location))
+        lobby.add_child(Node.s32('max', 128))
+        lobby.add_child(Node.s32_array('friend', []))
+        lobby.add_child(Node.u8('var', 2))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+
+    def verify_lobby_rb4entry(self, location: str, extid: int) -> int:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb4entry')
+        e = Node.void('e')
+        lobby.add_child(e)
+        e.add_child(Node.s32('eid', 0))
+        e.add_child(Node.u16('mid', 79))
+        e.add_child(Node.u8('ng', 0))
+        e.add_child(Node.s32('uid', extid))
+        e.add_child(Node.s32('uattr', 0))
+        e.add_child(Node.string('pn', self.NAME))
+        e.add_child(Node.s32('plyid', 0))
+        e.add_child(Node.s16('mg', 255))
+        e.add_child(Node.s32('mopt', 0))
+        e.add_child(Node.string('lid', location))
+        e.add_child(Node.string('sn', ''))
+        e.add_child(Node.u8('pref', 51))
+        e.add_child(Node.s8('stg', 4))
+        e.add_child(Node.s8('pside', 0))
+        e.add_child(Node.s16('eatime', 30))
+        e.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        e.add_child(Node.u16('gp', 10007))
+        e.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        e.add_child(Node.u8('ver', 2))
+        e.add_child(Node.s8('tension', 0))
+        lobby.add_child(Node.s32_array('friend', []))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+        self.assert_path(resp, "response/lobby/eid")
+        self.assert_path(resp, "response/lobby/e/eid")
+        self.assert_path(resp, "response/lobby/e/mid")
+        self.assert_path(resp, "response/lobby/e/ng")
+        self.assert_path(resp, "response/lobby/e/uid")
+        self.assert_path(resp, "response/lobby/e/uattr")
+        self.assert_path(resp, "response/lobby/e/pn")
+        self.assert_path(resp, "response/lobby/e/plyid")
+        self.assert_path(resp, "response/lobby/e/mg")
+        self.assert_path(resp, "response/lobby/e/mopt")
+        self.assert_path(resp, "response/lobby/e/lid")
+        self.assert_path(resp, "response/lobby/e/sn")
+        self.assert_path(resp, "response/lobby/e/pref")
+        self.assert_path(resp, "response/lobby/e/stg")
+        self.assert_path(resp, "response/lobby/e/pside")
+        self.assert_path(resp, "response/lobby/e/eatime")
+        self.assert_path(resp, "response/lobby/e/ga")
+        self.assert_path(resp, "response/lobby/e/gp")
+        self.assert_path(resp, "response/lobby/e/la")
+        self.assert_path(resp, "response/lobby/e/ver")
+        self.assert_path(resp, "response/lobby/e/tension")
+        return resp.child_value('lobby/eid')
+
+    def verify_lobby_rb4delete(self, eid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb4delete')
+        lobby.add_child(Node.s32('eid', eid))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby")
+
+    def verify_rb4pzlcmt_read(self, loc: str, extid: int) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'rb4pzlcmt_read')
+        info.add_child(Node.s32('uid', extid))
+        info.add_child(Node.string('lid', loc))
+        info.add_child(Node.s32('time', 0))
+        info.add_child(Node.s32('limit', 30))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/comment/time")
+        self.assert_path(resp, "response/info/c/uid")
+        self.assert_path(resp, "response/info/c/name")
+        self.assert_path(resp, "response/info/c/icon")
+        self.assert_path(resp, "response/info/c/bln")
+        self.assert_path(resp, "response/info/c/lid")
+        self.assert_path(resp, "response/info/c/pref")
+        self.assert_path(resp, "response/info/c/time")
+        self.assert_path(resp, "response/info/c/comment")
+        self.assert_path(resp, "response/info/c/is_tweet")
+
+        # Verify we posted our comment earlier
+        found = False
+        for child in resp.child('info').children:
+            if child.name != 'c':
+                continue
+            if child.child_value('uid') == extid:
+                name = child.child_value('name')
+                comment = child.child_value('comment')
+                if name != self.NAME:
+                    raise Exception('Invalid name \'{}\' returned for comment!'.format(name))
+                if comment != 'アメ〜〜！':
+                    raise Exception('Invalid comment \'{}\' returned for comment!'.format(comment))
+                found = True
+
+        if not found:
+            raise Exception('Comment we posted was not found!')
+
+    def verify_rb4pzlcmt_write(self, loc: str, extid: int) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'rb4pzlcmt_write')
+        info.add_child(Node.s32('uid', extid))
+        info.add_child(Node.string('name', self.NAME))
+        info.add_child(Node.s16('icon', 0))
+        info.add_child(Node.s8('bln', 0))
+        info.add_child(Node.string('lid', loc))
+        info.add_child(Node.s8('pref', 51))
+        info.add_child(Node.s32('time', int(time.time())))
+        info.add_child(Node.string('comment', 'アメ〜〜！'))
+        info.add_child(Node.bool('is_tweet', False))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/@status")
+
+    def verify_player_rbsvLinkageSave(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rbsvLinkageSave')
+        player.add_child(Node.string('rid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/before_pk_value")
+        self.assert_path(resp, "response/player/after_pk_value")
+        self.assert_path(resp, "response/player/before_bn_value")
+        self.assert_path(resp, "response/player/after_bn_value")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_dlstatus_progress()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_info_rb4common(location)
+        self.verify_pcb_rb4error(location)
+        self.verify_pcb_rb4boot(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+            # Always get a player start, regardless of new profile or not
+            self.verify_player_rb4start(ref_id)
+            self.verify_player_rb4succeed(ref_id)
+            extid = self.verify_player_rb4write(
+                ref_id,
+                location,
+                [],
+            )
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify lobby functionality
+        self.verify_lobby_rb4read(location, extid)
+        eid = self.verify_lobby_rb4entry(location, extid)
+        self.verify_lobby_rb4delete(eid)
+
+        # Verify puzzle comment read and write
+        self.verify_rb4pzlcmt_write(location, extid)
+        self.verify_rb4pzlcmt_read(location, extid)
+
+        # Verify Sound Voltex/ReflecBeat collabo save
+        self.verify_player_rbsvLinkageSave(ref_id)
+
+        # Verify user episode functionalty
+        episodes = self.verify_player_rb4readepisode(extid)
+        if len(episodes) > 0:
+            raise Exception('Existing episodes returned on new card?')
+        dummyepisodes = sorted(
+            [
+                {
+                    'id': 1,
+                    'user': extid,
+                    'values': [5, 10],
+                    'text': 'test1',
+                    'time': 12345,
+                },
+                {
+                    'id': 2,
+                    'user': extid,
+                    'values': [6, 11],
+                    'text': 'test2',
+                    'time': 54321,
+                },
+            ],
+            key=lambda ep: ep['id'],
+        )
+        self.verify_player_rb4write(ref_id, location, episodes=dummyepisodes)
+        episodes = sorted(
+            self.verify_player_rb4readepisode(extid),
+            key=lambda ep: ep['id'],
+        )
+        if len(episodes) != len(dummyepisodes):
+            raise Exception('Unexpected number of episodes returned!')
+        for i in range(len(dummyepisodes)):
+            for key in dummyepisodes[i]:
+                if dummyepisodes[i][key] != episodes[i][key]:
+                    raise Exception('Invalid value {} returned for episode {} key {}'.format(
+                        episodes[i][key],
+                        dummyepisodes[i]['id'],
+                        key,
+                    ))
+
+        # Verify we start with empty scores
+        scores = self.verify_player_rb4readscore(ref_id, location)
+        if len(scores) > 0:
+            raise Exception('Existing scores returned on new card?')
+
+        if cardid is None:
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 7543,
+                            'score': 432,
+                            'miss_count': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 1,
+                            'achievement_rate': 9876,
+                            'score': 543,
+                            'miss_count': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 3,
+                            'chart': 2,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 1234,
+                            'score': 123,
+                            'miss_count': 54,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 1024,
+                            'score': 50,
+                            'miss_count': 90,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 8765,
+                            'score': 469,
+                            'miss_count': 1,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 8765,
+                            'score': 432,
+                            'miss_count': 15,
+                            'expected_score': 543,
+                            'expected_clear_type': 9,
+                            'expected_combo_type': 1,
+                            'expected_achievement_rate': 9876,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+                self.verify_player_rb4write(ref_id, location, scores=dummyscores)
+
+                self.verify_player_rb4read(ref_id, card, location)
+                scores = self.verify_player_rb4readscore(ref_id, location)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_achievement_rate' in expected:
+                        expected_achievement_rate = expected['expected_achievement_rate']
+                    else:
+                        expected_achievement_rate = expected['achievement_rate']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+                    if 'expected_combo_type' in expected:
+                        expected_combo_type = expected['expected_combo_type']
+                    else:
+                        expected_combo_type = expected['combo_type']
+                    if 'expected_miss_count' in expected:
+                        expected_miss_count = expected['expected_miss_count']
+                    else:
+                        expected_miss_count = expected['miss_count']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['achievement_rate'] != expected_achievement_rate:
+                        raise Exception('Expected an achievement rate of \'{}\' for song \'{}\' chart \'{}\' but got achievement rate \'{}\''.format(
+                            expected_achievement_rate, expected['id'], expected['chart'], actual['achievement_rate'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+                    if actual['combo_type'] != expected_combo_type:
+                        raise Exception('Expected a combo_type of \'{}\' for song \'{}\' chart \'{}\' but got combo_type \'{}\''.format(
+                            expected_combo_type, expected['id'], expected['chart'], actual['combo_type'],
+                        ))
+                    if actual['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, expected['id'], expected['chart'], actual['miss_count'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify ending game
+        self.verify_player_rb4end(ref_id)
+
+        # Verify empty and non-empty select score
+        self.verify_player_rb4selectscore(0)
+        self.verify_player_rb4selectscore(extid)
+
+        # Verify high score tables and shop rank
+        self.verify_info_rb4ranking()
+        self.verify_info_rb4shop_score_ranking(location)
+        self.verify_player_rb4total_bestallrank_read()
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/reflec/limelight.py b/bemani/client/reflec/limelight.py
new file mode 100644
index 0000000..b3de48e
--- /dev/null
+++ b/bemani/client/reflec/limelight.py
@@ -0,0 +1,916 @@
+import random
+import time
+from typing import Dict, List, Optional
+
+from bemani.common import Time
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class ReflecBeatLimelight(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_log_pcb_status(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('log')
+        pcb.set_attribute('method', 'pcb_status')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.s32('cnt', 0))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/log/@status")
+
+    def verify_pcbinfo_get(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcbinfo')
+        pcb.set_attribute('method', 'get')
+        pcb.add_child(Node.string('lid', loc))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcbinfo/info/name")
+        self.assert_path(resp, "response/pcbinfo/info/pref")
+        self.assert_path(resp, "response/pcbinfo/info/close")
+        self.assert_path(resp, "response/pcbinfo/info/hour")
+        self.assert_path(resp, "response/pcbinfo/info/min")
+
+    def verify_sysinfo_get(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('sysinfo')
+        info.set_attribute('method', 'get')
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/sysinfo/trd")
+
+    def verify_ranking_read(self) -> None:
+        call = self.call_node()
+
+        ranking = Node.void('ranking')
+        ranking.set_attribute('method', 'read')
+        call.add_child(ranking)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/ranking/lic_10/time")
+        self.assert_path(resp, "response/ranking/org_10/time")
+
+    def verify_player_start(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'start')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.s32('ver', 0))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/is_suc")
+        self.assert_path(resp, "response/player/unlock_music")
+        self.assert_path(resp, "response/player/unlock_item")
+        self.assert_path(resp, "response/player/item_lock_ctrl")
+        self.assert_path(resp, "response/player/lincle_link_4/qpro")
+        self.assert_path(resp, "response/player/lincle_link_4/glass")
+        self.assert_path(resp, "response/player/lincle_link_4/treasure")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_0")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_1")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_2")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_3")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_4")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_5")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0_6")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_0")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_1")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_2")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_3")
+        self.assert_path(resp, "response/player/lincle_link_4/for_iidx_4")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_0")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_1")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_2")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_3")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_4")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_5")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0_6")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_0")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_1")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_2")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_3")
+        self.assert_path(resp, "response/player/lincle_link_4/for_rb_4")
+        self.assert_path(resp, "response/player/lincle_link_4/qproflg")
+        self.assert_path(resp, "response/player/lincle_link_4/glassflg")
+        self.assert_path(resp, "response/player/lincle_link_4/complete")
+
+    def verify_player_delete(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'delete')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/@status")
+
+    def verify_player_end(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'end')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.s32('status', 4))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_read(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'read')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s32('ver', 2))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/pdata/base/uid")
+        self.assert_path(resp, "response/player/pdata/base/name")
+        self.assert_path(resp, "response/player/pdata/base/icon_id")
+        self.assert_path(resp, "response/player/pdata/base/lv")
+        self.assert_path(resp, "response/player/pdata/base/exp")
+        self.assert_path(resp, "response/player/pdata/base/mg")
+        self.assert_path(resp, "response/player/pdata/base/ap")
+        self.assert_path(resp, "response/player/pdata/base/pc")
+        self.assert_path(resp, "response/player/pdata/base/uattr")
+        self.assert_path(resp, "response/player/pdata/con/day")
+        self.assert_path(resp, "response/player/pdata/con/cnt")
+        self.assert_path(resp, "response/player/pdata/con/total_cnt")
+        self.assert_path(resp, "response/player/pdata/con/last")
+        self.assert_path(resp, "response/player/pdata/con/now")
+        self.assert_path(resp, "response/player/pdata/team/id")
+        self.assert_path(resp, "response/player/pdata/team/name")
+        self.assert_path(resp, "response/player/pdata/custom/s_gls")
+        self.assert_path(resp, "response/player/pdata/custom/bgm_m")
+        self.assert_path(resp, "response/player/pdata/custom/st_f")
+        self.assert_path(resp, "response/player/pdata/custom/st_bg")
+        self.assert_path(resp, "response/player/pdata/custom/st_bg_b")
+        self.assert_path(resp, "response/player/pdata/custom/eff_e")
+        self.assert_path(resp, "response/player/pdata/custom/se_s")
+        self.assert_path(resp, "response/player/pdata/custom/se_s_v")
+        self.assert_path(resp, "response/player/pdata/custom/last_music_id")
+        self.assert_path(resp, "response/player/pdata/custom/last_note_grade")
+        self.assert_path(resp, "response/player/pdata/custom/sort_type")
+        self.assert_path(resp, "response/player/pdata/custom/narrowdown_type")
+        self.assert_path(resp, "response/player/pdata/custom/is_begginer")
+        self.assert_path(resp, "response/player/pdata/custom/is_tut")
+        self.assert_path(resp, "response/player/pdata/custom/symbol_chat_0")
+        self.assert_path(resp, "response/player/pdata/custom/symbol_chat_1")
+        self.assert_path(resp, "response/player/pdata/custom/gauge_style")
+        self.assert_path(resp, "response/player/pdata/custom/obj_shade")
+        self.assert_path(resp, "response/player/pdata/custom/obj_size")
+        self.assert_path(resp, "response/player/pdata/custom/byword")
+        self.assert_path(resp, "response/player/pdata/custom/is_auto_byword")
+        self.assert_path(resp, "response/player/pdata/custom/is_tweet")
+        self.assert_path(resp, "response/player/pdata/custom/is_link_twitter")
+        self.assert_path(resp, "response/player/pdata/custom/mrec_type")
+        self.assert_path(resp, "response/player/pdata/custom/card_disp_type")
+        self.assert_path(resp, "response/player/pdata/custom/tab_sel")
+        self.assert_path(resp, "response/player/pdata/custom/hidden_param")
+        self.assert_path(resp, "response/player/pdata/released")
+        self.assert_path(resp, "response/player/pdata/record")
+        self.assert_path(resp, "response/player/pdata/cmnt")
+        self.assert_path(resp, "response/player/pdata/rival")
+        self.assert_path(resp, "response/player/pdata/glass")
+        self.assert_path(resp, "response/player/pdata/fav_music_slot")
+        self.assert_path(resp, "response/player/pdata/narrow_down/adv_param")
+
+        if resp.child_value('player/pdata/base/name') != self.NAME:
+            raise Exception('Invalid name {} returned on profile read!'.format(resp.child_value('player/pdata/base/name')))
+
+        scores = []
+        for child in resp.child('player/pdata/record').children:
+            if child.name != 'rec':
+                continue
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ng'),
+                'clear_type': child.child_value('mrec_0/ct'),
+                'achievement_rate': child.child_value('mrec_0/ar'),
+                'score': child.child_value('mrec_0/bs'),
+                'combo': child.child_value('mrec_0/mc'),
+                'miss_count': child.child_value('mrec_0/bmc'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_write(self, refid: str, extid: int, loc: str, records: List[Dict[str, int]], scores: List[Dict[str, int]]) -> int:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'write')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', loc))
+        player.add_child(Node.u64('begin_time', Time.now() * 1000))
+        player.add_child(Node.u64('end_time', Time.now() * 1000))
+        pdata = Node.void('pdata')
+        player.add_child(pdata)
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.s32('uid', extid))
+        base.add_child(Node.string('name', self.NAME))
+        base.add_child(Node.s16('icon_id', 0))
+        base.add_child(Node.s16('lv', 1))
+        base.add_child(Node.s32('exp', 0))
+        base.add_child(Node.s16('mg', 0))
+        base.add_child(Node.s16('ap', 0))
+        base.add_child(Node.s32('pc', 0))
+        base.add_child(Node.s32('uattr', 0))
+        con = Node.void('con')
+        pdata.add_child(con)
+        con.add_child(Node.s32('day', 0))
+        con.add_child(Node.s32('cnt', 0))
+        con.add_child(Node.s32('total_cnt', 0))
+        con.add_child(Node.s32('last', 0))
+        con.add_child(Node.s32('now', 0))
+        custom = Node.void('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('s_gls', 0))
+        custom.add_child(Node.u8('bgm_m', 0))
+        custom.add_child(Node.u8('st_f', 0))
+        custom.add_child(Node.u8('st_bg', 0))
+        custom.add_child(Node.u8('st_bg_b', 100))
+        custom.add_child(Node.u8('eff_e', 0))
+        custom.add_child(Node.u8('se_s', 0))
+        custom.add_child(Node.u8('se_s_v', 100))
+        custom.add_child(Node.s16('last_music_id', 85))
+        custom.add_child(Node.u8('last_note_grade', 0))
+        custom.add_child(Node.u8('sort_type', 0))
+        custom.add_child(Node.u8('narrowdown_type', 0))
+        custom.add_child(Node.bool('is_begginer', False))
+        custom.add_child(Node.bool('is_tut', False))
+        custom.add_child(Node.s16_array('symbol_chat_0', [0, 1, 2, 3, 4, 5]))
+        custom.add_child(Node.s16_array('symbol_chat_1', [0, 1, 2, 3, 4, 5]))
+        custom.add_child(Node.u8('gauge_style', 0))
+        custom.add_child(Node.u8('obj_shade', 0))
+        custom.add_child(Node.u8('obj_size', 0))
+        custom.add_child(Node.s16_array('byword', [0, 0]))
+        custom.add_child(Node.bool_array('is_auto_byword', [True, True]))
+        custom.add_child(Node.bool('is_tweet', False))
+        custom.add_child(Node.bool('is_link_twitter', False))
+        custom.add_child(Node.s16('mrec_type', 0))
+        custom.add_child(Node.s16('card_disp_type', 0))
+        custom.add_child(Node.s16('tab_sel', 0))
+        custom.add_child(Node.s32_array('hidden_param', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]))
+        pdata.add_child(Node.void('released'))
+        pdata.add_child(Node.void('rival'))
+        pdata.add_child(Node.void('glass'))
+        pdata.add_child(Node.void('fav_music_slot'))
+        lincle_link_4 = Node.void('lincle_link_4')
+        pdata.add_child(lincle_link_4)
+        lincle_link_4.add_child(Node.u32('qpro_add', 0))
+        lincle_link_4.add_child(Node.u32('glass_add', 0))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_0', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_1', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_2', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_3', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_4', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_5', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0_6', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_0', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_1', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_2', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_3', False))
+        lincle_link_4.add_child(Node.bool('for_iidx_4', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_0', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_1', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_2', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_3', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_4', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_5', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0_6', False))
+        lincle_link_4.add_child(Node.bool('for_rb_0', False))
+        lincle_link_4.add_child(Node.bool('for_rb_1', False))
+        lincle_link_4.add_child(Node.bool('for_rb_2', False))
+        lincle_link_4.add_child(Node.bool('for_rb_3', False))
+        lincle_link_4.add_child(Node.bool('for_rb_4', False))
+
+        # First, filter down to only records that are also in the battle log
+        def key(thing: Dict[str, int]) -> str:
+            return '{}-{}'.format(thing['id'], thing['chart'])
+
+        updates = [key(score) for score in scores]
+        sortedrecords = {key(record): record for record in records if key(record) in updates}
+
+        # Now, see what records need updating and update them
+        for score in scores:
+            if key(score) in sortedrecords:
+                # Had a record, need to merge
+                record = sortedrecords[key(score)]
+            else:
+                # First time playing
+                record = {
+                    'clear_type': 0,
+                    'achievement_rate': 0,
+                    'score': 0,
+                    'combo': 0,
+                    'miss_count': 999999999,
+                }
+
+            sortedrecords[key(score)] = {
+                'id': score['id'],
+                'chart': score['chart'],
+                'clear_type': max(record['clear_type'], score['clear_type']),
+                'achievement_rate': max(record['achievement_rate'], score['achievement_rate']),
+                'score': max(record['score'], score['score']),
+                'combo': max(record['combo'], score['combo']),
+                'miss_count': min(record['miss_count'], score['miss_count']),
+            }
+
+        # Finally, send the records and battle logs
+        recordnode = Node.void('record')
+        pdata.add_child(recordnode)
+        blog = Node.void('blog')
+        pdata.add_child(blog)
+
+        for (_, record) in sortedrecords.items():
+            rec = Node.void('rec')
+            recordnode.add_child(rec)
+            rec.add_child(Node.u16('mid', record['id']))
+            rec.add_child(Node.u8('ng', record['chart']))
+            rec.add_child(Node.s32('point', 2))
+            rec.add_child(Node.s32('played_time', Time.now()))
+            mrec_0 = Node.void('mrec_0')
+            rec.add_child(mrec_0)
+            mrec_0.add_child(Node.s32('win', 1))
+            mrec_0.add_child(Node.s32('lose', 0))
+            mrec_0.add_child(Node.s32('draw', 0))
+            mrec_0.add_child(Node.u8('ct', record['clear_type']))
+            mrec_0.add_child(Node.s16('ar', record['achievement_rate']))
+            mrec_0.add_child(Node.s32('bs', record['score']))
+            mrec_0.add_child(Node.s16('mc', record['combo']))
+            mrec_0.add_child(Node.s16('bmc', record['miss_count']))
+            mrec_1 = Node.void('mrec_1')
+            rec.add_child(mrec_1)
+            mrec_1.add_child(Node.s32('win', 0))
+            mrec_1.add_child(Node.s32('lose', 0))
+            mrec_1.add_child(Node.s32('draw', 0))
+            mrec_1.add_child(Node.u8('ct', 0))
+            mrec_1.add_child(Node.s16('ar', 0))
+            mrec_1.add_child(Node.s32('bs', 0))
+            mrec_1.add_child(Node.s16('mc', 0))
+            mrec_1.add_child(Node.s16('bmc', -1))
+
+        scoreid = 0
+        for score in scores:
+            log = Node.void('log')
+            blog.add_child(log)
+            log.add_child(Node.u8('id', scoreid))
+            log.add_child(Node.u16('mid', score['id']))
+            log.add_child(Node.u8('ng', score['chart']))
+            log.add_child(Node.u8('mt', 0))
+            log.add_child(Node.u8('rt', 0))
+            log.add_child(Node.s32('ruid', 0))
+            myself = Node.void('myself')
+            log.add_child(myself)
+            myself.add_child(Node.s16('mg', 0))
+            myself.add_child(Node.s16('ap', 0))
+            myself.add_child(Node.u8('ct', score['clear_type']))
+            myself.add_child(Node.s32('s', score['score']))
+            myself.add_child(Node.s16('ar', score['achievement_rate']))
+            rival = Node.void('rival')
+            log.add_child(rival)
+            rival.add_child(Node.s16('mg', 0))
+            rival.add_child(Node.s16('ap', 0))
+            rival.add_child(Node.u8('ct', 2))
+            rival.add_child(Node.s32('s', 177))
+            rival.add_child(Node.s16('ar', 500))
+            log.add_child(Node.s32('time', Time.now()))
+            scoreid = scoreid + 1
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/uid")
+        self.assert_path(resp, "response/player/time")
+        return resp.child_value('player/uid')
+
+    def verify_log_play(self, extid: int, loc: str, scores: List[Dict[str, int]]) -> None:
+        call = self.call_node()
+
+        log = Node.void('log')
+        call.add_child(log)
+        log.set_attribute('method', 'play')
+        log.add_child(Node.s32('uid', extid))
+        log.add_child(Node.string('lid', loc))
+        play = Node.void('play')
+        log.add_child(play)
+        play.add_child(Node.s16('stage', len(scores)))
+        play.add_child(Node.s32('sec', 700))
+
+        scoreid = 0
+        for score in scores:
+            rec = Node.void('rec')
+            log.add_child(rec)
+            rec.add_child(Node.s16('idx', scoreid))
+            rec.add_child(Node.s16('mid', score['id']))
+            rec.add_child(Node.s16('grade', score['chart']))
+            rec.add_child(Node.s16('color', 0))
+            rec.add_child(Node.s16('match', 0))
+            rec.add_child(Node.s16('res', 0))
+            rec.add_child(Node.s32('score', score['score']))
+            rec.add_child(Node.s16('mc', score['combo']))
+            rec.add_child(Node.s16('jt_jr', 0))
+            rec.add_child(Node.s16('jt_ju', 0))
+            rec.add_child(Node.s16('jt_gr', 0))
+            rec.add_child(Node.s16('jt_gd', 0))
+            rec.add_child(Node.s16('jt_ms', score['miss_count']))
+            rec.add_child(Node.s32('sec', 200))
+            scoreid = scoreid + 1
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/log/@status")
+
+    def verify_lobby_read(self, location: str, extid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'read')
+        lobby.add_child(Node.s32('uid', extid))
+        lobby.add_child(Node.u8('m_grade', 255))
+        lobby.add_child(Node.string('lid', location))
+        lobby.add_child(Node.s32('max', 128))
+        lobby.add_child(Node.s32_array('friend', []))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+
+    def verify_lobby_entry(self, location: str, extid: int) -> int:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'entry')
+        e = Node.void('e')
+        lobby.add_child(e)
+        e.add_child(Node.s32('eid', 0))
+        e.add_child(Node.u16('mid', 79))
+        e.add_child(Node.u8('ng', 0))
+        e.add_child(Node.s32('uid', extid))
+        e.add_child(Node.s32('uattr', 0))
+        e.add_child(Node.string('pn', self.NAME))
+        e.add_child(Node.s16('mg', 0))
+        e.add_child(Node.s32('mopt', 0))
+        e.add_child(Node.s32('tid', 0))
+        e.add_child(Node.string('tn', ''))
+        e.add_child(Node.s32('topt', 0))
+        e.add_child(Node.string('lid', location))
+        e.add_child(Node.string('sn', ''))
+        e.add_child(Node.u8('pref', 51))
+        e.add_child(Node.s8('stg', 0))
+        e.add_child(Node.s8('pside', 0))
+        e.add_child(Node.s16('eatime', 30))
+        e.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        e.add_child(Node.u16('gp', 10007))
+        e.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        lobby.add_child(Node.s32_array('friend', []))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/eid")
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+        self.assert_path(resp, "response/lobby/e/eid")
+        self.assert_path(resp, "response/lobby/e/mid")
+        self.assert_path(resp, "response/lobby/e/ng")
+        self.assert_path(resp, "response/lobby/e/uid")
+        self.assert_path(resp, "response/lobby/e/pn")
+        self.assert_path(resp, "response/lobby/e/uattr")
+        self.assert_path(resp, "response/lobby/e/mopt")
+        self.assert_path(resp, "response/lobby/e/mg")
+        self.assert_path(resp, "response/lobby/e/tid")
+        self.assert_path(resp, "response/lobby/e/tn")
+        self.assert_path(resp, "response/lobby/e/topt")
+        self.assert_path(resp, "response/lobby/e/lid")
+        self.assert_path(resp, "response/lobby/e/sn")
+        self.assert_path(resp, "response/lobby/e/pref")
+        self.assert_path(resp, "response/lobby/e/stg")
+        self.assert_path(resp, "response/lobby/e/pside")
+        self.assert_path(resp, "response/lobby/e/eatime")
+        self.assert_path(resp, "response/lobby/e/ga")
+        self.assert_path(resp, "response/lobby/e/gp")
+        self.assert_path(resp, "response/lobby/e/la")
+        return resp.child_value('lobby/eid')
+
+    def verify_lobby_delete(self, eid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'delete')
+        lobby.add_child(Node.s32('eid', eid))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby")
+
+    def verify_event_w_update_status(self, loc: str, extid: int) -> None:
+        call = self.call_node()
+
+        event_w = Node.void('event_w')
+        call.add_child(event_w)
+        event_w.set_attribute('method', 'update_status')
+        event_w.add_child(Node.s32('uid', extid))
+        event_w.add_child(Node.string('p_name', self.NAME))
+        event_w.add_child(Node.s32('exp', 0))
+        event_w.add_child(Node.s32('customize', 0))
+        event_w.add_child(Node.s32('tid', 0))
+        event_w.add_child(Node.string('t_name', ''))
+        event_w.add_child(Node.string('lid', loc))
+        event_w.add_child(Node.string('s_name', ''))
+        event_w.add_child(Node.s8('pref', 51))
+        event_w.add_child(Node.s32('time', Time.now()))
+        event_w.add_child(Node.s8('status', 1))
+        event_w.add_child(Node.s8('stage', 0))
+        event_w.add_child(Node.s32('mid', -1))
+        event_w.add_child(Node.s8('ng', -1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/event_w/@status")
+
+    def verify_event_w_add_comment(self, loc: str, extid: int) -> None:
+        call = self.call_node()
+
+        event_w = Node.void('event_w')
+        call.add_child(event_w)
+        event_w.set_attribute('method', 'add_comment')
+        event_w.add_child(Node.s32('uid', extid))
+        event_w.add_child(Node.string('p_name', self.NAME))
+        event_w.add_child(Node.s32('exp', 0))
+        event_w.add_child(Node.s32('customize', 0))
+        event_w.add_child(Node.s32('tid', 0))
+        event_w.add_child(Node.string('t_name', ''))
+        event_w.add_child(Node.string('lid', loc))
+        event_w.add_child(Node.string('s_name', ''))
+        event_w.add_child(Node.s8('pref', 51))
+        event_w.add_child(Node.s32('time', Time.now()))
+        event_w.add_child(Node.string('comment', 'アメ〜〜！'))
+        event_w.add_child(Node.bool('is_tweet', False))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/event_w/@status")
+
+    def verify_event_r_get_all(self, extid: int) -> None:
+        call = self.call_node()
+
+        event_r = Node.void('event_r')
+        call.add_child(event_r)
+        event_r.set_attribute('method', 'get_all')
+        event_r.add_child(Node.s32('uid', extid))
+        event_r.add_child(Node.s32('time', 0))
+        event_r.add_child(Node.s32('limit', 30))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct. We should have at least one
+        # comment (the one we just wrote) and one status (because we just
+        # called update_status).
+        self.assert_path(resp, "response/event_r/time")
+        self.assert_path(resp, "response/event_r/status/s/uid")
+        self.assert_path(resp, "response/event_r/status/s/p_name")
+        self.assert_path(resp, "response/event_r/status/s/exp")
+        self.assert_path(resp, "response/event_r/status/s/customize")
+        self.assert_path(resp, "response/event_r/status/s/tid")
+        self.assert_path(resp, "response/event_r/status/s/t_name")
+        self.assert_path(resp, "response/event_r/status/s/lid")
+        self.assert_path(resp, "response/event_r/status/s/s_name")
+        self.assert_path(resp, "response/event_r/status/s/pref")
+        self.assert_path(resp, "response/event_r/status/s/time")
+        self.assert_path(resp, "response/event_r/status/s/status")
+        self.assert_path(resp, "response/event_r/status/s/stage")
+        self.assert_path(resp, "response/event_r/status/s/mid")
+        self.assert_path(resp, "response/event_r/status/s/ng")
+        self.assert_path(resp, "response/event_r/comment/c/uid")
+        self.assert_path(resp, "response/event_r/comment/c/p_name")
+        self.assert_path(resp, "response/event_r/comment/c/exp")
+        self.assert_path(resp, "response/event_r/comment/c/customize")
+        self.assert_path(resp, "response/event_r/comment/c/tid")
+        self.assert_path(resp, "response/event_r/comment/c/t_name")
+        self.assert_path(resp, "response/event_r/comment/c/lid")
+        self.assert_path(resp, "response/event_r/comment/c/s_name")
+        self.assert_path(resp, "response/event_r/comment/c/pref")
+        self.assert_path(resp, "response/event_r/comment/c/time")
+        self.assert_path(resp, "response/event_r/comment/c/comment")
+        self.assert_path(resp, "response/event_r/comment/c/is_tweet")
+
+        # Verify we posted our comment earlier
+        found = False
+        for child in resp.child('event_r/comment').children:
+            if child.name != 'c':
+                continue
+            if child.child_value('uid') == extid:
+                name = child.child_value('p_name')
+                comment = child.child_value('comment')
+                if name != self.NAME:
+                    raise Exception('Invalid name \'{}\' returned for comment!'.format(name))
+                if comment != 'アメ〜〜！':
+                    raise Exception('Invalid comment \'{}\' returned for comment!'.format(comment))
+                found = True
+
+        if not found:
+            raise Exception('Comment we posted was not found!')
+
+        # Verify our status came through
+        found = False
+        for child in resp.child('event_r/status').children:
+            if child.name != 's':
+                continue
+            if child.child_value('uid') == extid:
+                name = child.child_value('p_name')
+                if name != self.NAME:
+                    raise Exception('Invalid name \'{}\' returned for status!'.format(name))
+                found = True
+
+        if not found:
+            raise Exception('Status was not found!')
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+
+        self.verify_log_pcb_status(location)
+        self.verify_pcbinfo_get(location)
+
+        self.verify_sysinfo_get()
+        self.verify_ranking_read()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Always get a player start, regardless of new profile or not
+            self.verify_player_start(ref_id)
+            self.verify_player_delete(ref_id)
+            extid = self.verify_player_write(
+                ref_id,
+                0,
+                location,
+                [],
+                [],
+            )
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify lobby functionality
+        self.verify_lobby_read(location, extid)
+        eid = self.verify_lobby_entry(location, extid)
+        self.verify_lobby_delete(eid)
+
+        # Verify status updates and puzzle comments
+        self.verify_event_w_update_status(location, extid)
+        self.verify_event_w_add_comment(location, extid)
+        self.verify_event_r_get_all(extid)
+
+        # Limelight is weird and sends only the top record for each song you played,
+        # and then a separate battle log. So, emulating that is kinda hard.
+        scores: List[Dict[str, int]] = []
+        if cardid is None:
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 2,
+                            'achievement_rate': 7543,
+                            'score': 432,
+                            'combo': 123,
+                            'miss_count': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 3,
+                            'achievement_rate': 9876,
+                            'score': 543,
+                            'combo': 543,
+                            'miss_count': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 3,
+                            'chart': 2,
+                            'clear_type': 2,
+                            'achievement_rate': 1234,
+                            'score': 123,
+                            'combo': 42,
+                            'miss_count': 54,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'clear_type': 2,
+                            'achievement_rate': 1024,
+                            'score': 50,
+                            'combo': 12,
+                            'miss_count': 90,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 3,
+                            'achievement_rate': 8765,
+                            'score': 469,
+                            'combo': 468,
+                            'miss_count': 1,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 2,
+                            'achievement_rate': 8765,
+                            'score': 432,
+                            'combo': 321,
+                            'miss_count': 15,
+                            'expected_score': 543,
+                            'expected_clear_type': 3,
+                            'expected_achievement_rate': 9876,
+                            'expected_combo': 543,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+                self.verify_player_write(ref_id, extid, location, scores, dummyscores)
+                self.verify_log_play(extid, location, dummyscores)
+
+                scores = self.verify_player_read(ref_id, location)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_achievement_rate' in expected:
+                        expected_achievement_rate = expected['expected_achievement_rate']
+                    else:
+                        expected_achievement_rate = expected['achievement_rate']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+                    if 'expected_combo' in expected:
+                        expected_combo = expected['expected_combo']
+                    else:
+                        expected_combo = expected['combo']
+                    if 'expected_miss_count' in expected:
+                        expected_miss_count = expected['expected_miss_count']
+                    else:
+                        expected_miss_count = expected['miss_count']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['achievement_rate'] != expected_achievement_rate:
+                        raise Exception('Expected an achievement rate of \'{}\' for song \'{}\' chart \'{}\' but got achievement rate \'{}\''.format(
+                            expected_achievement_rate, expected['id'], expected['chart'], actual['achievement_rate'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+                    if actual['combo'] != expected_combo:
+                        raise Exception('Expected a combo of \'{}\' for song \'{}\' chart \'{}\' but got combo \'{}\''.format(
+                            expected_combo, expected['id'], expected['chart'], actual['combo'],
+                        ))
+                    if actual['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, expected['id'], expected['chart'], actual['miss_count'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify ending game
+        self.verify_player_end(ref_id)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/reflec/reflec.py b/bemani/client/reflec/reflec.py
new file mode 100644
index 0000000..ce78e38
--- /dev/null
+++ b/bemani/client/reflec/reflec.py
@@ -0,0 +1,641 @@
+import random
+import time
+from typing import Dict, List, Optional
+
+from bemani.common import Time
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class ReflecBeat(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_log_pcb_status(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('log')
+        pcb.set_attribute('method', 'pcb_status')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.u8('type', 0))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/log/@status")
+
+    def verify_pcbinfo_get(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcbinfo')
+        pcb.set_attribute('method', 'get')
+        pcb.add_child(Node.string('lid', loc))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcbinfo/info/name")
+        self.assert_path(resp, "response/pcbinfo/info/pref")
+        self.assert_path(resp, "response/pcbinfo/info/close")
+        self.assert_path(resp, "response/pcbinfo/info/hour")
+        self.assert_path(resp, "response/pcbinfo/info/min")
+
+    def verify_sysinfo_get(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('sysinfo')
+        info.set_attribute('method', 'get')
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/sysinfo/trd")
+
+    def verify_sysinfo_fan(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('sysinfo')
+        info.set_attribute('method', 'fan')
+        info.add_child(Node.u8('pref', 0))
+        info.add_child(Node.string('lid', loc))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/sysinfo/pref")
+        self.assert_path(resp, "response/sysinfo/lid")
+
+    def verify_player_start(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'start')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.s32('ver', 3))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/is_suc")
+
+    def verify_player_delete(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'delete')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/@status")
+
+    def verify_player_end(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'end')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_read(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'read')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s32('ver', 3))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/pdata/base/uid")
+        self.assert_path(resp, "response/player/pdata/base/name")
+        self.assert_path(resp, "response/player/pdata/base/lv")
+        self.assert_path(resp, "response/player/pdata/base/exp")
+        self.assert_path(resp, "response/player/pdata/base/mg")
+        self.assert_path(resp, "response/player/pdata/base/ap")
+        self.assert_path(resp, "response/player/pdata/base/flag")
+        self.assert_path(resp, "response/player/pdata/con/day")
+        self.assert_path(resp, "response/player/pdata/con/cnt")
+        self.assert_path(resp, "response/player/pdata/con/last")
+        self.assert_path(resp, "response/player/pdata/con/now")
+        self.assert_path(resp, "response/player/pdata/team/id")
+        self.assert_path(resp, "response/player/pdata/team/name")
+        self.assert_path(resp, "response/player/pdata/custom/bgm_m")
+        self.assert_path(resp, "response/player/pdata/custom/st_f")
+        self.assert_path(resp, "response/player/pdata/custom/st_bg")
+        self.assert_path(resp, "response/player/pdata/custom/st_bg_b")
+        self.assert_path(resp, "response/player/pdata/custom/eff_e")
+        self.assert_path(resp, "response/player/pdata/custom/se_s")
+        self.assert_path(resp, "response/player/pdata/custom/se_s_v")
+        self.assert_path(resp, "response/player/pdata/released")
+        self.assert_path(resp, "response/player/pdata/record")
+        self.assert_path(resp, "response/player/pdata/blog")
+        self.assert_path(resp, "response/player/pdata/cmnt")
+
+        if resp.child_value('player/pdata/base/name') != self.NAME:
+            raise Exception('Invalid name {} returned on profile read!'.format(resp.child_value('player/pdata/base/name')))
+
+        scores = []
+        for child in resp.child('player/pdata/record').children:
+            if child.name != 'rec':
+                continue
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ng'),
+                'clear_type': child.child_value('ct'),
+                'achievement_rate': child.child_value('ar'),
+                'score': child.child_value('bs'),
+                'combo': child.child_value('mc'),
+                'miss_count': child.child_value('bmc'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_write(self, refid: str, extid: int, loc: str, records: List[Dict[str, int]], scores: List[Dict[str, int]]) -> int:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'write')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', loc))
+        pdata = Node.void('pdata')
+        player.add_child(pdata)
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.s32('uid', extid))
+        base.add_child(Node.string('name', self.NAME))
+        base.add_child(Node.s16('lv', 1))
+        base.add_child(Node.s32('exp', 0))
+        base.add_child(Node.s16('mg', 0))
+        base.add_child(Node.s16('ap', 0))
+        base.add_child(Node.s32('flag', 0))
+        con = Node.void('con')
+        pdata.add_child(con)
+        con.add_child(Node.s32('day', 0))
+        con.add_child(Node.s32('cnt', 0))
+        con.add_child(Node.s32('last', 0))
+        con.add_child(Node.s32('now', 0))
+        custom = Node.void('custom')
+        pdata.add_child(custom)
+        custom.add_child(Node.u8('bgm_m', 0))
+        custom.add_child(Node.u8('st_f', 0))
+        custom.add_child(Node.u8('st_bg', 0))
+        custom.add_child(Node.u8('st_bg_b', 100))
+        custom.add_child(Node.u8('eff_e', 0))
+        custom.add_child(Node.u8('se_s', 0))
+        custom.add_child(Node.u8('se_s_v', 100))
+        pdata.add_child(Node.void('released'))
+
+        # First, filter down to only records that are also in the battle log
+        def key(thing: Dict[str, int]) -> str:
+            return '{}-{}'.format(thing['id'], thing['chart'])
+
+        updates = [key(score) for score in scores]
+        sortedrecords = {key(record): record for record in records if key(record) in updates}
+
+        # Now, see what records need updating and update them
+        for score in scores:
+            if key(score) in sortedrecords:
+                # Had a record, need to merge
+                record = sortedrecords[key(score)]
+            else:
+                # First time playing
+                record = {
+                    'clear_type': 0,
+                    'achievement_rate': 0,
+                    'score': 0,
+                    'combo': 0,
+                    'miss_count': 999999999,
+                }
+
+            sortedrecords[key(score)] = {
+                'id': score['id'],
+                'chart': score['chart'],
+                'clear_type': max(record['clear_type'], score['clear_type']),
+                'achievement_rate': max(record['achievement_rate'], score['achievement_rate']),
+                'score': max(record['score'], score['score']),
+                'combo': max(record['combo'], score['combo']),
+                'miss_count': min(record['miss_count'], score['miss_count']),
+            }
+
+        # Finally, send the records and battle logs
+        recordnode = Node.void('record')
+        pdata.add_child(recordnode)
+        blog = Node.void('blog')
+        pdata.add_child(blog)
+
+        for (_, record) in sortedrecords.items():
+            rec = Node.void('rec')
+            recordnode.add_child(rec)
+            rec.add_child(Node.u16('mid', record['id']))
+            rec.add_child(Node.u8('ng', record['chart']))
+            rec.add_child(Node.s32('win', 1))
+            rec.add_child(Node.s32('lose', 0))
+            rec.add_child(Node.s32('draw', 0))
+            rec.add_child(Node.u8('ct', record['clear_type']))
+            rec.add_child(Node.s16('ar', record['achievement_rate']))
+            rec.add_child(Node.s16('bs', record['score']))
+            rec.add_child(Node.s16('mc', record['combo']))
+            rec.add_child(Node.s16('bmc', record['miss_count']))
+
+        scoreid = 0
+        for score in scores:
+            log = Node.void('log')
+            blog.add_child(log)
+            log.add_child(Node.u8('id', scoreid))
+            log.add_child(Node.u16('mid', score['id']))
+            log.add_child(Node.u8('ng', score['chart']))
+            log.add_child(Node.u8('mt', 0))
+            log.add_child(Node.u8('rt', 0))
+            log.add_child(Node.s32('ruid', 0))
+            myself = Node.void('myself')
+            log.add_child(myself)
+            myself.add_child(Node.s16('mg', 0))
+            myself.add_child(Node.s16('ap', 0))
+            myself.add_child(Node.u8('ct', score['clear_type']))
+            myself.add_child(Node.s16('s', score['score']))
+            myself.add_child(Node.s16('ar', score['achievement_rate']))
+            rival = Node.void('rival')
+            log.add_child(rival)
+            rival.add_child(Node.s16('mg', 0))
+            rival.add_child(Node.s16('ap', 0))
+            rival.add_child(Node.u8('ct', 2))
+            rival.add_child(Node.s16('s', 177))
+            rival.add_child(Node.s16('ar', 500))
+            log.add_child(Node.s32('time', Time.now()))
+            scoreid = scoreid + 1
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/uid")
+        self.assert_path(resp, "response/player/time")
+        return resp.child_value('player/uid')
+
+    def verify_log_play(self, extid: int, loc: str, scores: List[Dict[str, int]]) -> None:
+        call = self.call_node()
+
+        log = Node.void('log')
+        call.add_child(log)
+        log.set_attribute('method', 'play')
+        log.add_child(Node.s32('uid', extid))
+        log.add_child(Node.string('lid', loc))
+        play = Node.void('play')
+        log.add_child(play)
+        play.add_child(Node.s16('stage', len(scores)))
+        play.add_child(Node.s32('sec', 700))
+
+        scoreid = 0
+        for score in scores:
+            rec = Node.void('rec')
+            log.add_child(rec)
+            rec.add_child(Node.s16('idx', scoreid))
+            rec.add_child(Node.s16('mid', score['id']))
+            rec.add_child(Node.s16('grade', score['chart']))
+            rec.add_child(Node.s16('color', 0))
+            rec.add_child(Node.s16('match', 0))
+            rec.add_child(Node.s16('res', 0))
+            rec.add_child(Node.s16('score', score['score']))
+            rec.add_child(Node.s16('mc', score['combo']))
+            rec.add_child(Node.s16('jt_jr', 0))
+            rec.add_child(Node.s16('jt_ju', 0))
+            rec.add_child(Node.s16('jt_gr', 0))
+            rec.add_child(Node.s16('jt_gd', 0))
+            rec.add_child(Node.s16('jt_ms', score['miss_count']))
+            rec.add_child(Node.s32('sec', 200))
+            scoreid = scoreid + 1
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/log/@status")
+
+    def verify_lobby_read(self, location: str, extid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'read')
+        lobby.add_child(Node.s32('uid', extid))
+        lobby.add_child(Node.u8('m_grade', 255))
+        lobby.add_child(Node.string('lid', location))
+        lobby.add_child(Node.s32('max', 128))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/@status")
+
+    def verify_lobby_entry(self, location: str, extid: int) -> int:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'entry')
+        e = Node.void('e')
+        lobby.add_child(e)
+        e.add_child(Node.s32('eid', 0))
+        e.add_child(Node.u16('mid', 79))
+        e.add_child(Node.u8('ng', 0))
+        e.add_child(Node.s32('uid', extid))
+        e.add_child(Node.string('pn', self.NAME))
+        e.add_child(Node.s32('exp', 0))
+        e.add_child(Node.u8('mg', 0))
+        e.add_child(Node.s32('tid', 0))
+        e.add_child(Node.string('tn', ''))
+        e.add_child(Node.string('lid', location))
+        e.add_child(Node.string('sn', ''))
+        e.add_child(Node.u8('pref', 51))
+        e.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        e.add_child(Node.u16('gp', 10007))
+        e.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/eid")
+        self.assert_path(resp, "response/lobby/e/eid")
+        self.assert_path(resp, "response/lobby/e/mid")
+        self.assert_path(resp, "response/lobby/e/ng")
+        self.assert_path(resp, "response/lobby/e/uid")
+        self.assert_path(resp, "response/lobby/e/pn")
+        self.assert_path(resp, "response/lobby/e/exp")
+        self.assert_path(resp, "response/lobby/e/mg")
+        self.assert_path(resp, "response/lobby/e/tid")
+        self.assert_path(resp, "response/lobby/e/tn")
+        self.assert_path(resp, "response/lobby/e/lid")
+        self.assert_path(resp, "response/lobby/e/sn")
+        self.assert_path(resp, "response/lobby/e/pref")
+        self.assert_path(resp, "response/lobby/e/ga")
+        self.assert_path(resp, "response/lobby/e/gp")
+        self.assert_path(resp, "response/lobby/e/la")
+        return resp.child_value('lobby/eid')
+
+    def verify_lobby_delete(self, eid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'delete')
+        lobby.add_child(Node.s32('eid', eid))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+
+        self.verify_log_pcb_status(location)
+        self.verify_pcbinfo_get(location)
+
+        self.verify_sysinfo_get()
+        self.verify_sysinfo_fan(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # Always get a player start, regardless of new profile or not
+            self.verify_player_start(ref_id)
+            self.verify_player_delete(ref_id)
+            extid = self.verify_player_write(
+                ref_id,
+                0,
+                location,
+                [],
+                [],
+            )
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify lobby functionality
+        self.verify_lobby_read(location, extid)
+        eid = self.verify_lobby_entry(location, extid)
+        self.verify_lobby_delete(eid)
+
+        # Original reflec is weird and sends only the top record for each song you played,
+        # and then a separate battle log. So, emulating that is kinda hard.
+        scores: List[Dict[str, int]] = []
+        if cardid is None:
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 2,
+                            'achievement_rate': 7543,
+                            'score': 432,
+                            'combo': 123,
+                            'miss_count': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 3,
+                            'achievement_rate': 9876,
+                            'score': 543,
+                            'combo': 543,
+                            'miss_count': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 3,
+                            'chart': 2,
+                            'clear_type': 2,
+                            'achievement_rate': 1234,
+                            'score': 123,
+                            'combo': 42,
+                            'miss_count': 54,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'clear_type': 2,
+                            'achievement_rate': 1024,
+                            'score': 50,
+                            'combo': 12,
+                            'miss_count': 90,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'clear_type': 3,
+                            'achievement_rate': 8765,
+                            'score': 469,
+                            'combo': 468,
+                            'miss_count': 1,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'clear_type': 2,
+                            'achievement_rate': 8765,
+                            'score': 432,
+                            'combo': 321,
+                            'miss_count': 15,
+                            'expected_score': 543,
+                            'expected_clear_type': 3,
+                            'expected_achievement_rate': 9876,
+                            'expected_combo': 543,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+                self.verify_player_write(ref_id, extid, location, scores, dummyscores)
+                self.verify_log_play(extid, location, dummyscores)
+
+                scores = self.verify_player_read(ref_id, location)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_achievement_rate' in expected:
+                        expected_achievement_rate = expected['expected_achievement_rate']
+                    else:
+                        expected_achievement_rate = expected['achievement_rate']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+                    if 'expected_combo' in expected:
+                        expected_combo = expected['expected_combo']
+                    else:
+                        expected_combo = expected['combo']
+                    if 'expected_miss_count' in expected:
+                        expected_miss_count = expected['expected_miss_count']
+                    else:
+                        expected_miss_count = expected['miss_count']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['achievement_rate'] != expected_achievement_rate:
+                        raise Exception('Expected an achievement rate of \'{}\' for song \'{}\' chart \'{}\' but got achievement rate \'{}\''.format(
+                            expected_achievement_rate, expected['id'], expected['chart'], actual['achievement_rate'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+                    if actual['combo'] != expected_combo:
+                        raise Exception('Expected a combo of \'{}\' for song \'{}\' chart \'{}\' but got combo \'{}\''.format(
+                            expected_combo, expected['id'], expected['chart'], actual['combo'],
+                        ))
+                    if actual['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, expected['id'], expected['chart'], actual['miss_count'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify ending game
+        self.verify_player_end(ref_id)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/reflec/volzza.py b/bemani/client/reflec/volzza.py
new file mode 100644
index 0000000..2ff299c
--- /dev/null
+++ b/bemani/client/reflec/volzza.py
@@ -0,0 +1,772 @@
+import random
+import time
+from typing import Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class ReflecBeatVolzza(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb_rb5_pcb_boot(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        pcb.set_attribute('method', 'rb5_pcb_boot')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.string('rno', 'MBR-JA-C01'))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/sinfo/nm")
+        self.assert_path(resp, "response/pcb/sinfo/cl_enbl")
+        self.assert_path(resp, "response/pcb/sinfo/cl_h")
+        self.assert_path(resp, "response/pcb/sinfo/cl_m")
+        self.assert_path(resp, "response/pcb/sinfo/shop_flag")
+
+    def verify_pcb_rb5_pcb_error(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        call.add_child(pcb)
+        pcb.set_attribute('method', 'rb5_pcb_error')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.string('code', 'exception'))
+        pcb.add_child(Node.string('msg', 'exceptionstring'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/@status")
+
+    def verify_info_rb5_info_read(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        call.add_child(info)
+        info.set_attribute('method', 'rb5_info_read')
+        info.add_child(Node.string('lid', loc))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/event_ctrl")
+        self.assert_path(resp, "response/info/item_lock_ctrl")
+
+    def verify_info_rb5_info_read_shop_ranking(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        call.add_child(info)
+        info.set_attribute('method', 'rb5_info_read_shop_ranking')
+        # Arbitrarily chosen based on the song IDs we send in the
+        # score section below.
+        info.add_child(Node.s16('min', 1))
+        info.add_child(Node.s16('max', 10))
+        info.add_child(Node.string('lid', loc))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/shop_score/time")
+        self.assert_path(resp, "response/info/shop_score/data/rank")
+        self.assert_path(resp, "response/info/shop_score/data/music_id")
+        self.assert_path(resp, "response/info/shop_score/data/note_grade")
+        self.assert_path(resp, "response/info/shop_score/data/clear_type")
+        self.assert_path(resp, "response/info/shop_score/data/user_id")
+        self.assert_path(resp, "response/info/shop_score/data/icon_id")
+        self.assert_path(resp, "response/info/shop_score/data/score")
+        self.assert_path(resp, "response/info/shop_score/data/time")
+        self.assert_path(resp, "response/info/shop_score/data/name")
+
+    def verify_info_rb5_info_read_hit_chart(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'rb5_info_read_hit_chart')
+        info.add_child(Node.s32('ver', 0))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/ver")
+        self.assert_path(resp, "response/info/ranking/weekly/bt")
+        self.assert_path(resp, "response/info/ranking/weekly/et")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/monthly/bt")
+        self.assert_path(resp, "response/info/ranking/monthly/et")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/total/bt")
+        self.assert_path(resp, "response/info/ranking/total/et")
+        self.assert_path(resp, "response/info/ranking/total/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/total/new/d/cnt")
+
+    def verify_player_rb5_player_start(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_start')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        player.add_child(Node.u16('gp', 10573))
+        player.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        player.add_child(Node.u8_array('pnid', [39, 16, 0, 0, 0, 23, 62, 60, 39, 127, 0, 0, 1, 23, 62, 60]))
+
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/plyid")
+        self.assert_path(resp, "response/player/start_time")
+        self.assert_path(resp, "response/player/event_ctrl")
+        self.assert_path(resp, "response/player/item_lock_ctrl")
+
+    def verify_player_rb5_player_end(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_end')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_rb5_player_read_rank(self) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read_rank')
+        player.add_child(Node.s32('uid', 0))
+        player.add_child(Node.s32_array('sc', [897, 897, 0, 0, 0]))
+        player.add_child(Node.s8('mg_id', 0))
+        player.add_child(Node.s32('mg_sc', 220))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/tbs/new_rank")
+        self.assert_path(resp, "response/player/tbs/old_rank")
+        self.assert_path(resp, "response/player/mng/new_rank")
+        self.assert_path(resp, "response/player/mng/old_rank")
+
+    def verify_player_rb5_player_read_rival_score(self, extid: int) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read_rival_score')
+        player.add_child(Node.s32('uid', extid))
+        player.add_child(Node.s32('music_id', 6))
+        player.add_child(Node.s32('note_grade', 0))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/@status")
+
+        # Verify that we got a score if the extid is nonzero
+        if extid != 0:
+            self.assert_path(resp, "response/player/player_select_score/user_id")
+            self.assert_path(resp, "response/player/player_select_score/name")
+            self.assert_path(resp, "response/player/player_select_score/m_score")
+            self.assert_path(resp, "response/player/player_select_score/m_scoreTime")
+            self.assert_path(resp, "response/player/player_select_score/m_iconID")
+
+            if resp.child_value('player/player_select_score/name') != self.NAME:
+                raise Exception(
+                    'Invalid name {} returned on score read!'.format(resp.child_value('player/player_select_score/name'))
+                )
+            if resp.child_value('player/player_select_score/user_id') != extid:
+                raise Exception(
+                    'Invalid name {} returned on score read!'.format(resp.child_value('player/player_select_score/user_id'))
+                )
+
+    def verify_player_rb5_player_read_rival_ranking_data(self, extid: int) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read_rival_ranking_data')
+        player.add_child(Node.s32('uid', extid))
+        player.add_child(Node.s8('mgid', -1))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/rival_data/rl/uid")
+        self.assert_path(resp, "response/player/rival_data/rl/nm")
+        self.assert_path(resp, "response/player/rival_data/rl/ic")
+        self.assert_path(resp, "response/player/rival_data/rl/sl/mid")
+        self.assert_path(resp, "response/player/rival_data/rl/sl/m")
+        self.assert_path(resp, "response/player/rival_data/rl/sl/t")
+        if resp.child_value('player/rival_data/rl/nm') != self.NAME:
+            raise Exception(
+                'Invalid name {} returned on rival ranking read!'.format(resp.child_value('player/rival_data/rl/nm'))
+            )
+
+    def verify_player_rb5_player_succeed(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_succeed')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/name")
+        self.assert_path(resp, "response/player/grd")
+        self.assert_path(resp, "response/player/ap")
+        self.assert_path(resp, "response/player/uattr")
+
+    def verify_player_rb5_player_read(self, refid: str, cardid: str, location: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s16('ver', 0))
+        player.add_child(Node.string('card_id', cardid))
+        player.add_child(Node.s16('card_type', 1))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/pdata/account/usrid")
+        self.assert_path(resp, "response/player/pdata/account/tpc")
+        self.assert_path(resp, "response/player/pdata/account/dpc")
+        self.assert_path(resp, "response/player/pdata/account/crd")
+        self.assert_path(resp, "response/player/pdata/account/brd")
+        self.assert_path(resp, "response/player/pdata/account/tdc")
+        self.assert_path(resp, "response/player/pdata/account/intrvld")
+        self.assert_path(resp, "response/player/pdata/account/ver")
+        self.assert_path(resp, "response/player/pdata/account/pst")
+        self.assert_path(resp, "response/player/pdata/account/st")
+        self.assert_path(resp, "response/player/pdata/account/succeed")
+        self.assert_path(resp, "response/player/pdata/account/opc")
+        self.assert_path(resp, "response/player/pdata/account/lpc")
+        self.assert_path(resp, "response/player/pdata/account/cpc")
+        self.assert_path(resp, "response/player/pdata/base/name")
+        self.assert_path(resp, "response/player/pdata/base/mg")
+        self.assert_path(resp, "response/player/pdata/base/ap")
+        self.assert_path(resp, "response/player/pdata/base/cmnt")
+        self.assert_path(resp, "response/player/pdata/base/uattr")
+        self.assert_path(resp, "response/player/pdata/base/money")
+        self.assert_path(resp, "response/player/pdata/base/tbs")
+        self.assert_path(resp, "response/player/pdata/base/tbgs")
+        self.assert_path(resp, "response/player/pdata/base/mlog")
+        self.assert_path(resp, "response/player/pdata/base/class")
+        self.assert_path(resp, "response/player/pdata/base/class_ar")
+        self.assert_path(resp, "response/player/pdata/rival")
+        self.assert_path(resp, "response/player/pdata/config")
+        self.assert_path(resp, "response/player/pdata/custom")
+        self.assert_path(resp, "response/player/pdata/released")
+        self.assert_path(resp, "response/player/pdata/announce")
+        self.assert_path(resp, "response/player/pdata/dojo")
+        self.assert_path(resp, "response/player/pdata/player_param")
+        self.assert_path(resp, "response/player/pdata/shop_score")
+        self.assert_path(resp, "response/player/pdata/minigame")
+        self.assert_path(resp, "response/player/pdata/derby/is_open")
+        self.assert_path(resp, "response/player/pdata/mylist/list/idx")
+        self.assert_path(resp, "response/player/pdata/mylist/list/mlst")
+
+        if resp.child_value('player/pdata/base/name') != self.NAME:
+            raise Exception('Invalid name {} returned on profile read!'.format(resp.child_value('player/pdata/base/name')))
+
+    def verify_player_rb5_player_read_score(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb5_player_read_score')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.s16('ver', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        scores = []
+        for child in resp.child('player/pdata/record').children:
+            if child.name != 'rec':
+                continue
+
+            self.assert_path(child, 'rec/mid')
+            self.assert_path(child, 'rec/ntgrd')
+            self.assert_path(child, 'rec/pc')
+            self.assert_path(child, 'rec/ct')
+            self.assert_path(child, 'rec/ar')
+            self.assert_path(child, 'rec/scr')
+            self.assert_path(child, 'rec/ms')
+            self.assert_path(child, 'rec/param')
+            self.assert_path(child, 'rec/bscrt')
+            self.assert_path(child, 'rec/bart')
+            self.assert_path(child, 'rec/bctt')
+            self.assert_path(child, 'rec/bmst')
+            self.assert_path(child, 'rec/time')
+            self.assert_path(child, 'rec/k_flag')
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ntgrd'),
+                'clear_type': child.child_value('ct'),
+                'combo_type': child.child_value('param'),
+                'achievement_rate': child.child_value('ar'),
+                'score': child.child_value('scr'),
+                'miss_count': child.child_value('ms'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_rb5_player_write(
+        self,
+        refid: str,
+        loc: str,
+        scores: List[Dict[str, int]]=[],
+        rivals: List[int]=[],
+    ) -> int:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb5_player_write')
+        pdata = Node.void('pdata')
+        player.add_child(pdata)
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', 0))
+        account.add_child(Node.s32('plyid', 0))
+        account.add_child(Node.s32('tpc', 1))
+        account.add_child(Node.s32('dpc', 1))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', 1))
+        account.add_child(Node.string('rid', refid))
+        account.add_child(Node.string('lid', loc))
+        account.add_child(Node.u8('wmode', 0))
+        account.add_child(Node.u8('gmode', 0))
+        account.add_child(Node.s16('ver', 0))
+        account.add_child(Node.bool('pp', False))
+        account.add_child(Node.bool('ps', False))
+        account.add_child(Node.bool('continue', False))
+        account.add_child(Node.bool('firstfree', False))
+        account.add_child(Node.s16('pay', 0))
+        account.add_child(Node.s16('pay_pc', 0))
+        account.add_child(Node.u64('st', int(time.time() * 1000)))
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', self.NAME))
+        base.add_child(Node.s32('mg', 0))
+        base.add_child(Node.s32('ap', 0))
+        base.add_child(Node.s32('uattr', 0))
+        base.add_child(Node.s32('money', 0))
+        base.add_child(Node.bool('is_tut', False))
+        base.add_child(Node.s32('class', -1))
+        base.add_child(Node.s32('class_ar', 0))
+        stglog = Node.void('stglog')
+        pdata.add_child(stglog)
+
+        index = 0
+        for score in scores:
+            log = Node.void('log')
+            stglog.add_child(log)
+            log.add_child(Node.s8('stg', index))
+            log.add_child(Node.s16('mid', score['id']))
+            log.add_child(Node.s8('ng', score['chart']))
+            log.add_child(Node.s8('col', 1))
+            log.add_child(Node.s8('mt', 0))
+            log.add_child(Node.s8('rt', 0))
+            log.add_child(Node.s8('ct', score['clear_type']))
+            log.add_child(Node.s16('param', score['combo_type']))
+            log.add_child(Node.s16('grd', 0))
+            log.add_child(Node.s16('ar', score['achievement_rate']))
+            log.add_child(Node.s16('sc', score['score']))
+            log.add_child(Node.s16('jt_jst', 0))
+            log.add_child(Node.s16('jt_grt', 0))
+            log.add_child(Node.s16('jt_gd', 0))
+            log.add_child(Node.s16('jt_ms', score['miss_count']))
+            log.add_child(Node.s16('jt_jr', 0))
+            log.add_child(Node.s32('r_uid', 0))
+            log.add_child(Node.s32('r_plyid', 0))
+            log.add_child(Node.s8('r_stg', 0))
+            log.add_child(Node.s8('r_ct', -1))
+            log.add_child(Node.s16('r_sc', 0))
+            log.add_child(Node.s16('r_grd', 0))
+            log.add_child(Node.s16('r_ar', 0))
+            log.add_child(Node.s8('r_cpuid', -1))
+            log.add_child(Node.s32('time', int(time.time())))
+            log.add_child(Node.s8('decide', 0))
+            log.add_child(Node.s16('g_gauge', 5000))
+            log.add_child(Node.s32('k_flag', 0))
+            index = index + 1
+
+        rivalnode = Node.void('rival')
+        pdata.add_child(rivalnode)
+        for rival in rivals:
+            r = Node.void('r')
+            rivalnode.add_child(r)
+            r.add_child(Node.s32('id', rival))
+            r.add_child(Node.s8('regist_type', 3))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/uid")
+        return resp.child_value('player/uid')
+
+    def verify_lobby_rb5_lobby_read(self, location: str, extid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb5_lobby_read')
+        lobby.add_child(Node.s32('uid', extid))
+        lobby.add_child(Node.s32('plyid', 0))
+        lobby.add_child(Node.u8('m_grade', 255))
+        lobby.add_child(Node.string('lid', location))
+        lobby.add_child(Node.s32('max', 128))
+        lobby.add_child(Node.s32_array('friend', []))
+        lobby.add_child(Node.u8('var', 3))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+
+    def verify_lobby_rb5_lobby_entry(self, location: str, extid: int) -> int:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb5_lobby_entry')
+        e = Node.void('e')
+        lobby.add_child(e)
+        e.add_child(Node.s32('eid', 0))
+        e.add_child(Node.u16('mid', 79))
+        e.add_child(Node.u8('ng', 0))
+        e.add_child(Node.s32('uid', extid))
+        e.add_child(Node.s32('uattr', 0))
+        e.add_child(Node.string('pn', self.NAME))
+        e.add_child(Node.s32('plyid', 0))
+        e.add_child(Node.s16('mg', 255))
+        e.add_child(Node.s32('mopt', 0))
+        e.add_child(Node.string('lid', location))
+        e.add_child(Node.string('sn', ''))
+        e.add_child(Node.u8('pref', 51))
+        e.add_child(Node.s8('stg', 4))
+        e.add_child(Node.s8('pside', 0))
+        e.add_child(Node.s16('eatime', 30))
+        e.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        e.add_child(Node.u16('gp', 10007))
+        e.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        e.add_child(Node.u8('ver', 2))
+        lobby.add_child(Node.s32_array('friend', []))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+        self.assert_path(resp, "response/lobby/eid")
+        self.assert_path(resp, "response/lobby/e/eid")
+        self.assert_path(resp, "response/lobby/e/mid")
+        self.assert_path(resp, "response/lobby/e/ng")
+        self.assert_path(resp, "response/lobby/e/uid")
+        self.assert_path(resp, "response/lobby/e/uattr")
+        self.assert_path(resp, "response/lobby/e/pn")
+        self.assert_path(resp, "response/lobby/e/plyid")
+        self.assert_path(resp, "response/lobby/e/mg")
+        self.assert_path(resp, "response/lobby/e/mopt")
+        self.assert_path(resp, "response/lobby/e/lid")
+        self.assert_path(resp, "response/lobby/e/sn")
+        self.assert_path(resp, "response/lobby/e/pref")
+        self.assert_path(resp, "response/lobby/e/stg")
+        self.assert_path(resp, "response/lobby/e/pside")
+        self.assert_path(resp, "response/lobby/e/eatime")
+        self.assert_path(resp, "response/lobby/e/ga")
+        self.assert_path(resp, "response/lobby/e/gp")
+        self.assert_path(resp, "response/lobby/e/la")
+        self.assert_path(resp, "response/lobby/e/ver")
+        return resp.child_value('lobby/eid')
+
+    def verify_lobby_rb5_lobby_delete_entry(self, eid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb5_lobby_delete_entry')
+        lobby.add_child(Node.s32('eid', eid))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/@status")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'lobby2',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_dlstatus_progress()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_info_rb5_info_read(location)
+        self.verify_pcb_rb5_pcb_boot(location)
+        self.verify_pcb_rb5_pcb_error(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+            # Always get a player start, regardless of new profile or not
+            self.verify_player_rb5_player_start(ref_id)
+            self.verify_player_rb5_player_succeed(ref_id)
+            extid = self.verify_player_rb5_player_write(
+                ref_id,
+                location,
+            )
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify lobby functionality
+        self.verify_lobby_rb5_lobby_read(location, extid)
+        eid = self.verify_lobby_rb5_lobby_entry(location, extid)
+        self.verify_lobby_rb5_lobby_delete_entry(eid)
+
+        # Verify we start with empty scores
+        scores = self.verify_player_rb5_player_read_score(ref_id, location)
+        if len(scores) > 0:
+            raise Exception('Existing scores returned on new card?')
+
+        if cardid is None:
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 9,
+                            'chart': 1,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 7543,
+                            'score': 432,
+                            'miss_count': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 9,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 1,
+                            'achievement_rate': 9876,
+                            'score': 543,
+                            'miss_count': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 6,
+                            'chart': 2,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 1234,
+                            'score': 123,
+                            'miss_count': 54,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 6,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 1024,
+                            'score': 50,
+                            'miss_count': 90,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 9,
+                            'chart': 1,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 8765,
+                            'score': 469,
+                            'miss_count': 1,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 9,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 8765,
+                            'score': 432,
+                            'miss_count': 15,
+                            'expected_score': 543,
+                            'expected_clear_type': 9,
+                            'expected_combo_type': 1,
+                            'expected_achievement_rate': 9876,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+                self.verify_player_rb5_player_write(ref_id, location, scores=dummyscores)
+
+                self.verify_player_rb5_player_read(ref_id, card, location)
+                scores = self.verify_player_rb5_player_read_score(ref_id, location)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_achievement_rate' in expected:
+                        expected_achievement_rate = expected['expected_achievement_rate']
+                    else:
+                        expected_achievement_rate = expected['achievement_rate']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+                    if 'expected_combo_type' in expected:
+                        expected_combo_type = expected['expected_combo_type']
+                    else:
+                        expected_combo_type = expected['combo_type']
+                    if 'expected_miss_count' in expected:
+                        expected_miss_count = expected['expected_miss_count']
+                    else:
+                        expected_miss_count = expected['miss_count']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['achievement_rate'] != expected_achievement_rate:
+                        raise Exception('Expected an achievement rate of \'{}\' for song \'{}\' chart \'{}\' but got achievement rate \'{}\''.format(
+                            expected_achievement_rate, expected['id'], expected['chart'], actual['achievement_rate'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+                    if actual['combo_type'] != expected_combo_type:
+                        raise Exception('Expected a combo_type of \'{}\' for song \'{}\' chart \'{}\' but got combo_type \'{}\''.format(
+                            expected_combo_type, expected['id'], expected['chart'], actual['combo_type'],
+                        ))
+                    if actual['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, expected['id'], expected['chart'], actual['miss_count'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify ending game
+        self.verify_player_rb5_player_end(ref_id)
+
+        # Verify empty and non-empty select score
+        self.verify_player_rb5_player_read_rival_score(0)
+        self.verify_player_rb5_player_read_rival_score(extid)
+
+        # Verify rival score loading after rivaling ourselves
+        self.verify_player_rb5_player_write(ref_id, location, rivals=[extid])
+        self.verify_player_rb5_player_read_rival_ranking_data(extid)
+
+        # Verify high score tables and shop rank
+        self.verify_info_rb5_info_read_hit_chart()
+        self.verify_info_rb5_info_read_shop_ranking(location)
+        self.verify_player_rb5_player_read_rank()
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/reflec/volzza2.py b/bemani/client/reflec/volzza2.py
new file mode 100644
index 0000000..788c69b
--- /dev/null
+++ b/bemani/client/reflec/volzza2.py
@@ -0,0 +1,985 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class ReflecBeatVolzza2(BaseClient):
+    NAME = 'ＴＥＳＴ'
+
+    def verify_pcb_rb5_pcb_boot(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        pcb.set_attribute('method', 'rb5_pcb_boot')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.string('rno', 'MBR-JA-C01'))
+        call.add_child(pcb)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/sinfo/nm")
+        self.assert_path(resp, "response/pcb/sinfo/cl_enbl")
+        self.assert_path(resp, "response/pcb/sinfo/cl_h")
+        self.assert_path(resp, "response/pcb/sinfo/cl_m")
+        self.assert_path(resp, "response/pcb/sinfo/shop_flag")
+
+    def verify_pcb_rb5_pcb_error(self, loc: str) -> None:
+        call = self.call_node()
+
+        pcb = Node.void('pcb')
+        call.add_child(pcb)
+        pcb.set_attribute('method', 'rb5_pcb_error')
+        pcb.add_child(Node.string('lid', loc))
+        pcb.add_child(Node.string('code', 'exception'))
+        pcb.add_child(Node.string('msg', 'exceptionstring'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/pcb/@status")
+
+    def verify_info_rb5_info_read(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        call.add_child(info)
+        info.set_attribute('method', 'rb5_info_read')
+        info.add_child(Node.string('lid', loc))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/event_ctrl")
+        self.assert_path(resp, "response/info/item_lock_ctrl")
+        self.assert_path(resp, "response/info/mycourse_ctrl")
+
+    def verify_info_rb5_info_read_shop_ranking(self, loc: str) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        call.add_child(info)
+        info.set_attribute('method', 'rb5_info_read_shop_ranking')
+        # Arbitrarily chosen based on the song IDs we send in the
+        # score section below.
+        info.add_child(Node.s16('min', 1))
+        info.add_child(Node.s16('max', 10))
+        info.add_child(Node.string('lid', loc))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/shop_score/time")
+        self.assert_path(resp, "response/info/shop_score/data/rank")
+        self.assert_path(resp, "response/info/shop_score/data/music_id")
+        self.assert_path(resp, "response/info/shop_score/data/note_grade")
+        self.assert_path(resp, "response/info/shop_score/data/clear_type")
+        self.assert_path(resp, "response/info/shop_score/data/user_id")
+        self.assert_path(resp, "response/info/shop_score/data/icon_id")
+        self.assert_path(resp, "response/info/shop_score/data/score")
+        self.assert_path(resp, "response/info/shop_score/data/time")
+        self.assert_path(resp, "response/info/shop_score/data/name")
+
+    def verify_info_rb5_info_read_hit_chart(self) -> None:
+        call = self.call_node()
+
+        info = Node.void('info')
+        info.set_attribute('method', 'rb5_info_read_hit_chart')
+        info.add_child(Node.s32('ver', 0))
+        call.add_child(info)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/info/ver")
+        self.assert_path(resp, "response/info/ranking/weekly/bt")
+        self.assert_path(resp, "response/info/ranking/weekly/et")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/weekly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/monthly/bt")
+        self.assert_path(resp, "response/info/ranking/monthly/et")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/monthly/new/d/cnt")
+        self.assert_path(resp, "response/info/ranking/total/bt")
+        self.assert_path(resp, "response/info/ranking/total/et")
+        self.assert_path(resp, "response/info/ranking/total/new/d/mid")
+        self.assert_path(resp, "response/info/ranking/total/new/d/cnt")
+
+    def verify_player_rb5_player_start(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_start')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        player.add_child(Node.u16('gp', 10573))
+        player.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        player.add_child(Node.u8_array('pnid', [39, 16, 0, 0, 0, 23, 62, 60, 39, 127, 0, 0, 1, 23, 62, 60]))
+
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/plyid")
+        self.assert_path(resp, "response/player/start_time")
+        self.assert_path(resp, "response/player/event_ctrl")
+        self.assert_path(resp, "response/player/item_lock_ctrl")
+        self.assert_path(resp, "response/player/mycourse_ctrl")
+
+    def verify_player_rb5_player_end(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_end')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player")
+
+    def verify_player_rb5_player_read_rank_5(self) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read_rank_5')
+        player.add_child(Node.s32('uid', 0))
+        player.add_child(Node.s32_array('sc', [897, 897, 0, 0, 0]))
+        player.add_child(Node.s8('mg_id', 0))
+        player.add_child(Node.s32('mg_sc', 220))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/tbs/new_rank")
+        self.assert_path(resp, "response/player/tbs/old_rank")
+        self.assert_path(resp, "response/player/mng/new_rank")
+        self.assert_path(resp, "response/player/mng/old_rank")
+
+    def verify_player_rb5_player_read_rival_score_5(self, extid: int) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read_rival_score_5')
+        player.add_child(Node.s32('uid', extid))
+        player.add_child(Node.s32('music_id', 6))
+        player.add_child(Node.s8('note_grade', 0))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/@status")
+
+        # Verify that we got a score if the extid is nonzero
+        if extid != 0:
+            self.assert_path(resp, "response/player/player_select_score/user_id")
+            self.assert_path(resp, "response/player/player_select_score/name")
+            self.assert_path(resp, "response/player/player_select_score/m_score")
+            self.assert_path(resp, "response/player/player_select_score/m_scoreTime")
+            self.assert_path(resp, "response/player/player_select_score/m_iconID")
+
+            if resp.child_value('player/player_select_score/name') != self.NAME:
+                raise Exception(
+                    'Invalid name {} returned on score read!'.format(resp.child_value('player/player_select_score/name'))
+                )
+            if resp.child_value('player/player_select_score/user_id') != extid:
+                raise Exception(
+                    'Invalid name {} returned on score read!'.format(resp.child_value('player/player_select_score/user_id'))
+                )
+
+    def verify_player_rb5_player_read_rival_ranking_data_5(self, extid: int) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read_rival_ranking_data_5')
+        player.add_child(Node.s32('uid', extid))
+        player.add_child(Node.s8('mgid', -1))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/rival_data/rl/uid")
+        self.assert_path(resp, "response/player/rival_data/rl/nm")
+        self.assert_path(resp, "response/player/rival_data/rl/ic")
+        self.assert_path(resp, "response/player/rival_data/rl/sl/mid")
+        self.assert_path(resp, "response/player/rival_data/rl/sl/m")
+        self.assert_path(resp, "response/player/rival_data/rl/sl/t")
+        if resp.child_value('player/rival_data/rl/nm') != self.NAME:
+            raise Exception(
+                'Invalid name {} returned on rival ranking read!'.format(resp.child_value('player/rival_data/rl/nm'))
+            )
+
+    def verify_player_rb5_player_succeed(self, refid: str) -> None:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_succeed')
+        player.add_child(Node.string('rid', refid))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/name")
+        self.assert_path(resp, "response/player/grd")
+        self.assert_path(resp, "response/player/ap")
+        self.assert_path(resp, "response/player/uattr")
+
+    def verify_player_rb5_player_read(self, refid: str, cardid: str, location: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        player.set_attribute('method', 'rb5_player_read')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.string('lid', location))
+        player.add_child(Node.s16('ver', 0))
+        player.add_child(Node.string('card_id', cardid))
+        player.add_child(Node.s16('card_type', 1))
+        call.add_child(player)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/pdata/account/usrid")
+        self.assert_path(resp, "response/player/pdata/account/tpc")
+        self.assert_path(resp, "response/player/pdata/account/dpc")
+        self.assert_path(resp, "response/player/pdata/account/crd")
+        self.assert_path(resp, "response/player/pdata/account/brd")
+        self.assert_path(resp, "response/player/pdata/account/tdc")
+        self.assert_path(resp, "response/player/pdata/account/intrvld")
+        self.assert_path(resp, "response/player/pdata/account/ver")
+        self.assert_path(resp, "response/player/pdata/account/succeed")
+        self.assert_path(resp, "response/player/pdata/account/pst")
+        self.assert_path(resp, "response/player/pdata/account/st")
+        self.assert_path(resp, "response/player/pdata/account/opc")
+        self.assert_path(resp, "response/player/pdata/account/lpc")
+        self.assert_path(resp, "response/player/pdata/account/cpc")
+        self.assert_path(resp, "response/player/pdata/account/mpc")
+        self.assert_path(resp, "response/player/pdata/base/name")
+        self.assert_path(resp, "response/player/pdata/base/mg")
+        self.assert_path(resp, "response/player/pdata/base/ap")
+        self.assert_path(resp, "response/player/pdata/base/cmnt")
+        self.assert_path(resp, "response/player/pdata/base/uattr")
+        self.assert_path(resp, "response/player/pdata/base/money")
+        self.assert_path(resp, "response/player/pdata/base/tbs_5")
+        self.assert_path(resp, "response/player/pdata/base/tbgs_5")
+        self.assert_path(resp, "response/player/pdata/base/mlog")
+        self.assert_path(resp, "response/player/pdata/base/class")
+        self.assert_path(resp, "response/player/pdata/base/class_ar")
+        self.assert_path(resp, "response/player/pdata/base/skill_point")
+        self.assert_path(resp, "response/player/pdata/base/meteor_flg")
+        self.assert_path(resp, "response/player/pdata/rival")
+        self.assert_path(resp, "response/player/pdata/config")
+        self.assert_path(resp, "response/player/pdata/custom")
+        self.assert_path(resp, "response/player/pdata/released")
+        self.assert_path(resp, "response/player/pdata/announce")
+        self.assert_path(resp, "response/player/pdata/dojo")
+        self.assert_path(resp, "response/player/pdata/player_param")
+        self.assert_path(resp, "response/player/pdata/shop_score")
+        self.assert_path(resp, "response/player/pdata/minigame")
+        self.assert_path(resp, "response/player/pdata/derby/is_open")
+        self.assert_path(resp, "response/player/pdata/mylist/list/idx")
+        self.assert_path(resp, "response/player/pdata/mylist/list/mlst")
+        self.assert_path(resp, "response/player/pdata/mycourse/mycourse_id")
+        self.assert_path(resp, "response/player/pdata/mycourse_f")
+
+        if resp.child_value('player/pdata/base/name') != self.NAME:
+            raise Exception('Invalid name {} returned on profile read!'.format(resp.child_value('player/pdata/base/name')))
+
+        mycourse = [
+            {
+                'music_id': resp.child_value('player/pdata/mycourse/music_id_1'),
+                'note_grade': resp.child_value('player/pdata/mycourse/note_grade_1'),
+                'score': resp.child_value('player/pdata/mycourse/score_1'),
+            },
+            {
+                'music_id': resp.child_value('player/pdata/mycourse/music_id_2'),
+                'note_grade': resp.child_value('player/pdata/mycourse/note_grade_2'),
+                'score': resp.child_value('player/pdata/mycourse/score_2'),
+            },
+            {
+                'music_id': resp.child_value('player/pdata/mycourse/music_id_3'),
+                'note_grade': resp.child_value('player/pdata/mycourse/note_grade_3'),
+                'score': resp.child_value('player/pdata/mycourse/score_3'),
+            },
+            {
+                'music_id': resp.child_value('player/pdata/mycourse/music_id_4'),
+                'note_grade': resp.child_value('player/pdata/mycourse/note_grade_4'),
+                'score': resp.child_value('player/pdata/mycourse/score_4'),
+            },
+        ]
+        return {
+            'mycourse': mycourse,
+        }
+
+    def verify_player_rb5_player_read_score_5(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb5_player_read_score_5')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.s16('ver', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        scores = []
+        for child in resp.child('player/pdata/record').children:
+            if child.name != 'rec':
+                continue
+
+            self.assert_path(child, 'rec/mid')
+            self.assert_path(child, 'rec/ntgrd')
+            self.assert_path(child, 'rec/pc')
+            self.assert_path(child, 'rec/ct')
+            self.assert_path(child, 'rec/ar')
+            self.assert_path(child, 'rec/scr')
+            self.assert_path(child, 'rec/ms')
+            self.assert_path(child, 'rec/param')
+            self.assert_path(child, 'rec/bscrt')
+            self.assert_path(child, 'rec/bart')
+            self.assert_path(child, 'rec/bctt')
+            self.assert_path(child, 'rec/bmst')
+            self.assert_path(child, 'rec/time')
+            self.assert_path(child, 'rec/k_flag')
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ntgrd'),
+                'clear_type': child.child_value('ct'),
+                'combo_type': child.child_value('param'),
+                'achievement_rate': child.child_value('ar'),
+                'score': child.child_value('scr'),
+                'miss_count': child.child_value('ms'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_rb5_player_read_score_old_5(self, refid: str, location: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb5_player_read_score_old_5')
+        player.add_child(Node.string('rid', refid))
+        player.add_child(Node.s16('ver', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        scores = []
+        for child in resp.child('player/pdata/record_old').children:
+            if child.name != 'rec':
+                continue
+
+            self.assert_path(child, 'rec/mid')
+            self.assert_path(child, 'rec/ntgrd')
+            self.assert_path(child, 'rec/pc')
+            self.assert_path(child, 'rec/ct')
+            self.assert_path(child, 'rec/ar')
+            self.assert_path(child, 'rec/scr')
+            self.assert_path(child, 'rec/ms')
+            self.assert_path(child, 'rec/param')
+            self.assert_path(child, 'rec/bscrt')
+            self.assert_path(child, 'rec/bart')
+            self.assert_path(child, 'rec/bctt')
+            self.assert_path(child, 'rec/bmst')
+            self.assert_path(child, 'rec/time')
+            self.assert_path(child, 'rec/k_flag')
+
+            score = {
+                'id': child.child_value('mid'),
+                'chart': child.child_value('ntgrd'),
+                'clear_type': child.child_value('ct'),
+                'combo_type': child.child_value('param'),
+                'achievement_rate': child.child_value('ar'),
+                'score': child.child_value('scr'),
+                'miss_count': child.child_value('ms'),
+            }
+            scores.append(score)
+        return scores
+
+    def verify_player_rb5_player_write_5(
+        self,
+        refid: str,
+        loc: str,
+        scores: List[Dict[str, int]]=[],
+        rivals: List[int]=[],
+        mycourse: Optional[List[Dict[str, int]]]=None,
+    ) -> int:
+        call = self.call_node()
+
+        player = Node.void('player')
+        call.add_child(player)
+        player.set_attribute('method', 'rb5_player_write_5')
+        pdata = Node.void('pdata')
+        player.add_child(pdata)
+        account = Node.void('account')
+        pdata.add_child(account)
+        account.add_child(Node.s32('usrid', 0))
+        account.add_child(Node.s32('plyid', 0))
+        account.add_child(Node.s32('tpc', 1))
+        account.add_child(Node.s32('dpc', 1))
+        account.add_child(Node.s32('crd', 1))
+        account.add_child(Node.s32('brd', 1))
+        account.add_child(Node.s32('tdc', 1))
+        account.add_child(Node.string('rid', refid))
+        account.add_child(Node.string('lid', loc))
+        account.add_child(Node.u8('wmode', 0))
+        account.add_child(Node.u8('gmode', 0))
+        account.add_child(Node.s16('ver', 0))
+        account.add_child(Node.bool('pp', False))
+        account.add_child(Node.bool('ps', False))
+        account.add_child(Node.bool('continue', False))
+        account.add_child(Node.bool('firstfree', False))
+        account.add_child(Node.s16('pay', 0))
+        account.add_child(Node.s16('pay_pc', 0))
+        account.add_child(Node.u64('st', int(time.time() * 1000)))
+        base = Node.void('base')
+        pdata.add_child(base)
+        base.add_child(Node.string('name', self.NAME))
+        base.add_child(Node.s32('mg', 0))
+        base.add_child(Node.s32('ap', 0))
+        base.add_child(Node.s32('uattr', 0))
+        base.add_child(Node.s32('money', 0))
+        base.add_child(Node.bool('is_tut', False))
+        base.add_child(Node.s32('class', -1))
+        base.add_child(Node.s32('class_ar', 0))
+        base.add_child(Node.s32('skill_point', 0))
+        stglog = Node.void('stglog')
+        pdata.add_child(stglog)
+
+        index = 0
+        for score in scores:
+            log = Node.void('log')
+            stglog.add_child(log)
+            log.add_child(Node.s8('stg', index))
+            log.add_child(Node.s16('mid', score['id']))
+            log.add_child(Node.s8('ng', score['chart']))
+            log.add_child(Node.s8('col', 1))
+            log.add_child(Node.s8('mt', 0))
+            log.add_child(Node.s8('rt', 0))
+            log.add_child(Node.s8('ct', score['clear_type']))
+            log.add_child(Node.s16('param', score['combo_type']))
+            log.add_child(Node.s16('grd', 0))
+            log.add_child(Node.s16('ar', score['achievement_rate']))
+            log.add_child(Node.s16('sc', score['score']))
+            log.add_child(Node.s16('jt_jst', 0))
+            log.add_child(Node.s16('jt_grt', 0))
+            log.add_child(Node.s16('jt_gd', 0))
+            log.add_child(Node.s16('jt_ms', score['miss_count']))
+            log.add_child(Node.s16('jt_jr', 0))
+            log.add_child(Node.s32('r_uid', 0))
+            log.add_child(Node.s32('r_plyid', 0))
+            log.add_child(Node.s8('r_stg', 0))
+            log.add_child(Node.s8('r_ct', -1))
+            log.add_child(Node.s16('r_sc', 0))
+            log.add_child(Node.s16('r_grd', 0))
+            log.add_child(Node.s16('r_ar', 0))
+            log.add_child(Node.s8('r_cpuid', -1))
+            log.add_child(Node.s32('time', int(time.time())))
+            log.add_child(Node.s8('decide', 0))
+            log.add_child(Node.s16('g_gauge', 5000))
+            log.add_child(Node.s32('k_flag', 0))
+            index = index + 1
+
+        rivalnode = Node.void('rival')
+        pdata.add_child(rivalnode)
+        for rival in rivals:
+            r = Node.void('r')
+            rivalnode.add_child(r)
+            r.add_child(Node.s32('id', rival))
+            r.add_child(Node.s8('regist_type', 3))
+
+        if mycourse is not None:
+            mycoursenode = Node.void('mycourse')
+            pdata.add_child(mycoursenode)
+            mycoursenode.add_child(Node.s16('mycourse_id', 1))
+            mycoursenode.add_child(Node.s32('music_id_1', mycourse[0]['music_id']))
+            mycoursenode.add_child(Node.s16('note_grade_1', mycourse[0]['note_grade']))
+            mycoursenode.add_child(Node.s32('score_1', mycourse[0]['score']))
+            mycoursenode.add_child(Node.s32('music_id_2', mycourse[1]['music_id']))
+            mycoursenode.add_child(Node.s16('note_grade_2', mycourse[1]['note_grade']))
+            mycoursenode.add_child(Node.s32('score_2', mycourse[1]['score']))
+            mycoursenode.add_child(Node.s32('music_id_3', mycourse[2]['music_id']))
+            mycoursenode.add_child(Node.s16('note_grade_3', mycourse[2]['note_grade']))
+            mycoursenode.add_child(Node.s32('score_3', mycourse[2]['score']))
+            mycoursenode.add_child(Node.s32('music_id_4', mycourse[3]['music_id']))
+            mycoursenode.add_child(Node.s16('note_grade_4', mycourse[3]['note_grade']))
+            mycoursenode.add_child(Node.s32('score_4', mycourse[3]['score']))
+            mycoursenode.add_child(Node.s32('insert_time', -1))
+            mycoursenode.add_child(Node.s32('def_music_id_1', -1))
+            mycoursenode.add_child(Node.s16('def_note_grade_1', -1))
+            mycoursenode.add_child(Node.s32('def_music_id_2', -1))
+            mycoursenode.add_child(Node.s16('def_note_grade_2', -1))
+            mycoursenode.add_child(Node.s32('def_music_id_3', -1))
+            mycoursenode.add_child(Node.s16('def_note_grade_3', -1))
+            mycoursenode.add_child(Node.s32('def_music_id_4', -1))
+            mycoursenode.add_child(Node.s16('def_note_grade_4', -1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/player/uid")
+        return resp.child_value('player/uid')
+
+    def verify_lobby_rb5_lobby_read(self, location: str, extid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb5_lobby_read')
+        lobby.add_child(Node.s32('uid', extid))
+        lobby.add_child(Node.s32('plyid', 0))
+        lobby.add_child(Node.u8('m_grade', 255))
+        lobby.add_child(Node.string('lid', location))
+        lobby.add_child(Node.s32('max', 128))
+        lobby.add_child(Node.s32_array('friend', []))
+        lobby.add_child(Node.u8('var', 4))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+
+    def verify_lobby_rb5_lobby_entry(self, location: str, extid: int) -> int:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb5_lobby_entry')
+        e = Node.void('e')
+        lobby.add_child(e)
+        e.add_child(Node.s32('eid', 0))
+        e.add_child(Node.u16('mid', 79))
+        e.add_child(Node.u8('ng', 0))
+        e.add_child(Node.s32('uid', extid))
+        e.add_child(Node.s32('uattr', 0))
+        e.add_child(Node.string('pn', self.NAME))
+        e.add_child(Node.s32('plyid', 0))
+        e.add_child(Node.s16('mg', 255))
+        e.add_child(Node.s32('mopt', 0))
+        e.add_child(Node.string('lid', location))
+        e.add_child(Node.string('sn', ''))
+        e.add_child(Node.u8('pref', 51))
+        e.add_child(Node.s8('stg', 4))
+        e.add_child(Node.s8('pside', 0))
+        e.add_child(Node.s16('eatime', 30))
+        e.add_child(Node.u8_array('ga', [127, 0, 0, 1]))
+        e.add_child(Node.u16('gp', 10007))
+        e.add_child(Node.u8_array('la', [16, 0, 0, 0]))
+        e.add_child(Node.u8('ver', 2))
+        lobby.add_child(Node.s32_array('friend', []))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/interval")
+        self.assert_path(resp, "response/lobby/interval_p")
+        self.assert_path(resp, "response/lobby/eid")
+        self.assert_path(resp, "response/lobby/e/eid")
+        self.assert_path(resp, "response/lobby/e/mid")
+        self.assert_path(resp, "response/lobby/e/ng")
+        self.assert_path(resp, "response/lobby/e/uid")
+        self.assert_path(resp, "response/lobby/e/uattr")
+        self.assert_path(resp, "response/lobby/e/pn")
+        self.assert_path(resp, "response/lobby/e/plyid")
+        self.assert_path(resp, "response/lobby/e/mg")
+        self.assert_path(resp, "response/lobby/e/mopt")
+        self.assert_path(resp, "response/lobby/e/lid")
+        self.assert_path(resp, "response/lobby/e/sn")
+        self.assert_path(resp, "response/lobby/e/pref")
+        self.assert_path(resp, "response/lobby/e/stg")
+        self.assert_path(resp, "response/lobby/e/pside")
+        self.assert_path(resp, "response/lobby/e/eatime")
+        self.assert_path(resp, "response/lobby/e/ga")
+        self.assert_path(resp, "response/lobby/e/gp")
+        self.assert_path(resp, "response/lobby/e/la")
+        self.assert_path(resp, "response/lobby/e/ver")
+        return resp.child_value('lobby/eid')
+
+    def verify_lobby_rb5_lobby_delete_entry(self, eid: int) -> None:
+        call = self.call_node()
+
+        lobby = Node.void('lobby')
+        lobby.set_attribute('method', 'rb5_lobby_delete_entry')
+        lobby.add_child(Node.s32('eid', eid))
+        call.add_child(lobby)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/lobby/@status")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'lobby2',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        self.verify_dlstatus_progress()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_info_rb5_info_read(location)
+        self.verify_pcb_rb5_pcb_boot(location)
+        self.verify_pcb_rb5_pcb_error(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+            # Always get a player start, regardless of new profile or not
+            self.verify_player_rb5_player_start(ref_id)
+            self.verify_player_rb5_player_succeed(ref_id)
+            extid = self.verify_player_rb5_player_write_5(
+                ref_id,
+                location,
+            )
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify lobby functionality
+        self.verify_lobby_rb5_lobby_read(location, extid)
+        eid = self.verify_lobby_rb5_lobby_entry(location, extid)
+        self.verify_lobby_rb5_lobby_delete_entry(eid)
+
+        # Verify we start with empty scores
+        scores = self.verify_player_rb5_player_read_score_5(ref_id, location)
+        oldscores = self.verify_player_rb5_player_read_score_old_5(ref_id, location)
+        if len(scores) > 0 or len(oldscores) > 0:
+            raise Exception('Existing scores returned on new card?')
+        profile = self.verify_player_rb5_player_read(ref_id, card, location)
+        for val in profile['mycourse']:
+            if val['score'] != -1:
+                raise Exception('Existing score returned for new card on course?')
+            if val['music_id'] != -1:
+                raise Exception('Existing score returned for new card on course?')
+            if val['note_grade'] != -1:
+                raise Exception('Existing score returned for new card on course?')
+
+        if cardid is None:
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 9,
+                            'chart': 1,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 7543,
+                            'score': 432,
+                            'miss_count': 5,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 9,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 1,
+                            'achievement_rate': 9876,
+                            'score': 543,
+                            'miss_count': 0,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 6,
+                            'chart': 2,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 1234,
+                            'score': 123,
+                            'miss_count': 54,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 6,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 1024,
+                            'score': 50,
+                            'miss_count': 90,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 9,
+                            'chart': 1,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 8765,
+                            'score': 469,
+                            'miss_count': 1,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 9,
+                            'chart': 0,
+                            'clear_type': 9,
+                            'combo_type': 0,
+                            'achievement_rate': 8765,
+                            'score': 432,
+                            'miss_count': 15,
+                            'expected_score': 543,
+                            'expected_clear_type': 9,
+                            'expected_combo_type': 1,
+                            'expected_achievement_rate': 9876,
+                            'expected_miss_count': 0,
+                        },
+                    ]
+                self.verify_player_rb5_player_write_5(ref_id, location, scores=dummyscores)
+
+                self.verify_player_rb5_player_read(ref_id, card, location)
+                scores = self.verify_player_rb5_player_read_score_5(ref_id, location)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_achievement_rate' in expected:
+                        expected_achievement_rate = expected['expected_achievement_rate']
+                    else:
+                        expected_achievement_rate = expected['achievement_rate']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+                    if 'expected_combo_type' in expected:
+                        expected_combo_type = expected['expected_combo_type']
+                    else:
+                        expected_combo_type = expected['combo_type']
+                    if 'expected_miss_count' in expected:
+                        expected_miss_count = expected['expected_miss_count']
+                    else:
+                        expected_miss_count = expected['miss_count']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['achievement_rate'] != expected_achievement_rate:
+                        raise Exception('Expected an achievement rate of \'{}\' for song \'{}\' chart \'{}\' but got achievement rate \'{}\''.format(
+                            expected_achievement_rate, expected['id'], expected['chart'], actual['achievement_rate'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+                    if actual['combo_type'] != expected_combo_type:
+                        raise Exception('Expected a combo_type of \'{}\' for song \'{}\' chart \'{}\' but got combo_type \'{}\''.format(
+                            expected_combo_type, expected['id'], expected['chart'], actual['combo_type'],
+                        ))
+                    if actual['miss_count'] != expected_miss_count:
+                        raise Exception('Expected a miss count of \'{}\' for song \'{}\' chart \'{}\' but got miss count \'{}\''.format(
+                            expected_miss_count, expected['id'], expected['chart'], actual['miss_count'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify mycourse saving and updating
+        firstcourse = [
+            {
+                'music_id': 51,
+                'note_grade': 1,
+                'score': 1086,
+            },
+            {
+                'music_id': 37,
+                'note_grade': 1,
+                'score': 1041,
+            },
+            {
+                'music_id': 102,
+                'note_grade': 1,
+                'score': 935,
+            },
+            {
+                'music_id': 58,
+                'note_grade': 1,
+                'score': 973,
+            },
+        ]
+        self.verify_player_rb5_player_write_5(ref_id, location, mycourse=firstcourse)
+        profile = self.verify_player_rb5_player_read(ref_id, card, location)
+        for i in range(len(profile['mycourse'])):
+            if profile['mycourse'][i]['music_id'] != firstcourse[i]['music_id']:
+                raise Exception('invalid music ID for mycourse entry {}!'.format(i))
+            if profile['mycourse'][i]['note_grade'] != firstcourse[i]['note_grade']:
+                raise Exception('invalid chart for mycourse entry {}!'.format(i))
+            if profile['mycourse'][i]['score'] != firstcourse[i]['score']:
+                raise Exception('invalid score for mycourse entry {}!'.format(i))
+
+        # Do a worse job on a different course
+        secondcourse = [
+            {
+                'music_id': 2,
+                'note_grade': 1,
+                'score': 987,
+            },
+            {
+                'music_id': 6,
+                'note_grade': 1,
+                'score': 234,
+            },
+            {
+                'music_id': 102,
+                'note_grade': 1,
+                'score': 876,
+            },
+            {
+                'music_id': 58,
+                'note_grade': 1,
+                'score': 573,
+            },
+        ]
+        self.verify_player_rb5_player_write_5(ref_id, location, mycourse=secondcourse)
+        profile = self.verify_player_rb5_player_read(ref_id, card, location)
+        for i in range(len(profile['mycourse'])):
+            if profile['mycourse'][i]['music_id'] != firstcourse[i]['music_id']:
+                raise Exception('invalid music ID for mycourse entry {}!'.format(i))
+            if profile['mycourse'][i]['note_grade'] != firstcourse[i]['note_grade']:
+                raise Exception('invalid chart for mycourse entry {}!'.format(i))
+            if profile['mycourse'][i]['score'] != firstcourse[i]['score']:
+                raise Exception('invalid score for mycourse entry {}!'.format(i))
+
+        # Now, do better on our course, and verify it updates
+        thirdcourse = [
+            {
+                'music_id': 51,
+                'note_grade': 1,
+                'score': 1186,
+            },
+            {
+                'music_id': 37,
+                'note_grade': 1,
+                'score': 1141,
+            },
+            {
+                'music_id': 102,
+                'note_grade': 1,
+                'score': 1035,
+            },
+            {
+                'music_id': 58,
+                'note_grade': 1,
+                'score': 1073,
+            },
+        ]
+        self.verify_player_rb5_player_write_5(ref_id, location, mycourse=thirdcourse)
+        profile = self.verify_player_rb5_player_read(ref_id, card, location)
+        for i in range(len(profile['mycourse'])):
+            if profile['mycourse'][i]['music_id'] != thirdcourse[i]['music_id']:
+                raise Exception('invalid music ID for mycourse entry {}!'.format(i))
+            if profile['mycourse'][i]['note_grade'] != thirdcourse[i]['note_grade']:
+                raise Exception('invalid chart for mycourse entry {}!'.format(i))
+            if profile['mycourse'][i]['score'] != thirdcourse[i]['score']:
+                raise Exception('invalid score for mycourse entry {}!'.format(i))
+
+        # Verify ending game
+        self.verify_player_rb5_player_end(ref_id)
+
+        # Verify empty and non-empty select score
+        self.verify_player_rb5_player_read_rival_score_5(0)
+        self.verify_player_rb5_player_read_rival_score_5(extid)
+
+        # Verify rival score loading after rivaling ourselves
+        self.verify_player_rb5_player_write_5(ref_id, location, rivals=[extid])
+        self.verify_player_rb5_player_read_rival_ranking_data_5(extid)
+
+        # Verify high score tables and shop rank
+        self.verify_info_rb5_info_read_hit_chart()
+        self.verify_info_rb5_info_read_shop_ranking(location)
+        self.verify_player_rb5_player_read_rank_5()
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/sdvx/__init__.py b/bemani/client/sdvx/__init__.py
new file mode 100644
index 0000000..2baaf01
--- /dev/null
+++ b/bemani/client/sdvx/__init__.py
@@ -0,0 +1,5 @@
+from bemani.client.sdvx.booth import SoundVoltexBoothClient
+from bemani.client.sdvx.infiniteinfection import SoundVoltexInfiniteInfectionClient
+from bemani.client.sdvx.gravitywars_s1 import SoundVoltexGravityWarsS1Client
+from bemani.client.sdvx.gravitywars_s2 import SoundVoltexGravityWarsS2Client
+from bemani.client.sdvx.heavenlyhaven import SoundVoltexHeavenlyHavenClient
diff --git a/bemani/client/sdvx/booth.py b/bemani/client/sdvx/booth.py
new file mode 100644
index 0000000..d79dc6a
--- /dev/null
+++ b/bemani/client/sdvx/booth.py
@@ -0,0 +1,645 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.common import Time
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class SoundVoltexBoothClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '1.7.6'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        game.set_attribute('locid', location)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'hiscore')
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/ranking/@id")
+        self.assert_path(resp, "response/game/hiscore/@type")
+        self.assert_path(resp, "response/game/hiscore/music/@id")
+        self.assert_path(resp, "response/game/hiscore/music/note/@name")
+        self.assert_path(resp, "response/game/hiscore/music/note/@score")
+        self.assert_path(resp, "response/game/hiscore/music/note/@type")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', True))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/nxt_time")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('name', self.NAME)
+        game.set_attribute('method', 'new')
+        game.set_attribute('refid', refid)
+        game.set_attribute('locid', location)
+        game.set_attribute('dataid', refid)
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', refid)
+        game.set_attribute('method', 'frozen')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/@result")
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, exp: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('refid', refid)
+        game.set_attribute('locid', location)
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u8('hispeed', 16))
+        game.add_child(Node.u16('appeal_id', 19))
+        game.add_child(Node.u16('frame0', 0))
+        game.add_child(Node.u16('frame1', 0))
+        game.add_child(Node.u16('frame2', 0))
+        game.add_child(Node.u16('frame3', 0))
+        game.add_child(Node.u16('frame4', 0))
+        last = Node.void('last')
+        game.add_child(last)
+        last.set_attribute('music_type', '1')
+        last.set_attribute('music_id', '29')
+        last.set_attribute('sort_type', '4')
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        game.add_child(Node.u32('gain_exp', exp))
+        game.add_child(Node.u32('m_user_cnt', 0))
+        game.add_child(Node.bool_array('have_item', [False] * 512))
+        game.add_child(Node.bool_array('have_note', [False] * 512))
+        tracking = Node.void('tracking')
+        game.add_child(tracking)
+        m0 = Node.void('m0')
+        tracking.add_child(m0)
+        m0.add_child(Node.u8('type', 2))
+        m0.add_child(Node.u32('id', 5))
+        m0.add_child(Node.u32('score', 774566))
+        tracking.add_child(Node.time('p_start', Time.now() - 300))
+        tracking.add_child(Node.time('p_end', Time.now()))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'common')
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/limited")
+        self.assert_path(resp, "response/game/event/info/@id")
+        self.assert_path(resp, "response/game/catalog/info/@currency")
+        self.assert_path(resp, "response/game/catalog/info/@id")
+        self.assert_path(resp, "response/game/catalog/info/@price")
+        self.assert_path(resp, "response/game/kacinfo/note00")
+        self.assert_path(resp, "response/game/kacinfo/note01")
+        self.assert_path(resp, "response/game/kacinfo/note02")
+        self.assert_path(resp, "response/game/kacinfo/note10")
+        self.assert_path(resp, "response/game/kacinfo/note11")
+        self.assert_path(resp, "response/game/kacinfo/note12")
+        self.assert_path(resp, "response/game/kacinfo/rabbeat0")
+        self.assert_path(resp, "response/game/kacinfo/rabbeat1")
+
+    def verify_game_buy(self, refid: str, catalogid: int, success: bool) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('refid', refid)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'buy')
+        game.add_child(Node.u32('catalog_id', catalogid))
+        game.add_child(Node.u32('earned_gamecoin_packet', 0))
+        game.add_child(Node.u32('earned_gamecoin_block', 0))
+        game.add_child(Node.u32('open_index', 4))
+        game.add_child(Node.u32('currency_type', 1))
+        game.add_child(Node.u32('price', 10))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/gamecoin_packet")
+        self.assert_path(resp, "response/game/gamecoin_block")
+        self.assert_path(resp, "response/game/result")
+
+        if success:
+            if resp.child_value('game/result') != 0:
+                raise Exception('Failed to purchase!')
+        else:
+            if resp.child_value('game/result') == 0:
+                raise Exception('Purchased when shouldn\'t have!')
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('cardid', cardid)
+        game.set_attribute('dataid', refid)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'load')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game/@none")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game/name")
+            self.assert_path(resp, "response/game/code")
+            self.assert_path(resp, "response/game/gamecoin_packet")
+            self.assert_path(resp, "response/game/gamecoin_block")
+            self.assert_path(resp, "response/game/exp_point")
+            self.assert_path(resp, "response/game/m_user_cnt")
+            self.assert_path(resp, "response/game/have_item")
+            self.assert_path(resp, "response/game/have_note")
+            self.assert_path(resp, "response/game/last/@appeal_id")
+            self.assert_path(resp, "response/game/last/@frame0")
+            self.assert_path(resp, "response/game/last/@frame1")
+            self.assert_path(resp, "response/game/last/@frame2")
+            self.assert_path(resp, "response/game/last/@frame3")
+            self.assert_path(resp, "response/game/last/@frame4")
+            self.assert_path(resp, "response/game/last/@headphone")
+            self.assert_path(resp, "response/game/last/@hispeed")
+            self.assert_path(resp, "response/game/last/@music_id")
+            self.assert_path(resp, "response/game/last/@music_type")
+            self.assert_path(resp, "response/game/last/@sort_type")
+
+            return {
+                'name': resp.child_value('game/name'),
+                'packet': resp.child_value('game/gamecoin_packet'),
+                'block': resp.child_value('game/gamecoin_block'),
+                'exp': resp.child_value('game/exp_point'),
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_lounge(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'lounge')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/interval")
+
+    def verify_game_entry_s(self) -> int:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'entry_s')
+        game.add_child(Node.u8('c_ver', 22))
+        game.add_child(Node.u8('p_num', 1))
+        game.add_child(Node.u8('p_rest', 1))
+        game.add_child(Node.u8('filter', 1))
+        game.add_child(Node.u32('mid', 5))
+        game.add_child(Node.u32('sec', 45))
+        game.add_child(Node.u16('port', 10007))
+        game.add_child(Node.fouru8('gip', [127, 0, 0, 1]))
+        game.add_child(Node.fouru8('lip', [10, 0, 5, 73]))
+        game.add_child(Node.bool('claim', True))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/entry_id")
+        return resp.child_value('game/entry_id')
+
+    def verify_game_entry_e(self, eid: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'entry_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u32('eid', eid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'load_m')
+        game.set_attribute('ver', '0')
+        game.set_attribute('all', '1')
+        game.set_attribute('dataid', refid)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+        scores = []
+        for child in resp.child('game').children:
+            if child.name != 'music':
+                continue
+
+            musicid = int(child.attribute('music_id'))
+            for typenode in child.children:
+                if typenode.name != 'type':
+                    continue
+
+                chart = int(typenode.attribute('type_id'))
+                clear_type = int(typenode.attribute('clear_type'))
+                score = int(typenode.attribute('score'))
+                grade = int(typenode.attribute('score_grade'))
+
+                scores.append({
+                    'id': musicid,
+                    'chart': chart,
+                    'clear_type': clear_type,
+                    'score': score,
+                    'grade': grade,
+                })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'save_m')
+        game.set_attribute('max_chain', '0')
+        game.set_attribute('clear_type', str(score['clear_type']))
+        game.set_attribute('music_type', str(score['chart']))
+        game.set_attribute('score_grade', str(score['grade']))
+        game.set_attribute('locid', location)
+        game.set_attribute('music_id', str(score['id']))
+        game.set_attribute('dataid', refid)
+        game.set_attribute('ver', '0')
+        game.set_attribute('score', str(score['score']))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_shop(location)
+        self.verify_game_common()
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # SDVX doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        self.verify_game_frozen(ref_id, 0)
+
+        # Verify lobby functionality
+        self.verify_game_lounge()
+        eid = self.verify_game_entry_s()
+        self.verify_game_entry_e(eid)
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['exp'] != 0:
+                raise Exception('Profile has nonzero exp associated with it!')
+
+            # Verify purchase failure
+            self.verify_game_buy(ref_id, 1004, False)
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, exp=42)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['exp'] != 42:
+                raise Exception('Profile has invalid exp associated with it!')
+
+            self.verify_game_save(location, ref_id, packet=1, block=2, exp=3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 236:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['exp'] != 45:
+                raise Exception('Profile has invalid exp associated with it!')
+
+            # Verify purchase success
+            self.verify_game_buy(ref_id, 1004, True)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 226:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['exp'] != 45:
+                raise Exception('Profile has invalid exp associated with it!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 3,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 3,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 3,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/sdvx/gravitywars_s1.py b/bemani/client/sdvx/gravitywars_s1.py
new file mode 100644
index 0000000..ea8e8a5
--- /dev/null
+++ b/bemani/client/sdvx/gravitywars_s1.py
@@ -0,0 +1,806 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class SoundVoltexGravityWarsS1Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '2.3.8'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'hiscore')
+        game.add_child(Node.string('locid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/hitchart/info/id")
+        self.assert_path(resp, "response/game_3/hitchart/info/cnt")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/id")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/type")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/name")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/code")
+        self.assert_path(resp, "response/game_3/hiscore_allover/info/score")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/id")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/type")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/name")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/code")
+        self.assert_path(resp, "response/game_3/hiscore_location/info/score")
+        self.assert_path(resp, "response/game_3/clear_rate/d/id")
+        self.assert_path(resp, "response/game_3/clear_rate/d/type")
+        self.assert_path(resp, "response/game_3/clear_rate/d/cr")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', False))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+        game.add_child(Node.bool('newpc', False))
+        game.add_child(Node.s32('s_paseli', 206))
+        game.add_child(Node.s32('monitor', 1))
+        game.add_child(Node.string('romnumber', 'KFC-JA-M01'))
+        game.add_child(Node.string('etc', 'TaxMode:1,BasicRate:100/1,FirstFree:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/nxt_time")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('name', self.NAME))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'frozen')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/result")
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, blaster_energy: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u16('appeal_id', 1001))
+        game.add_child(Node.u16('comment_id', 0))
+        game.add_child(Node.s32('music_id', 29))
+        game.add_child(Node.u8('music_type', 1))
+        game.add_child(Node.u8('sort_type', 1))
+        game.add_child(Node.u8('narrow_down', 0))
+        game.add_child(Node.u8('gauge_option', 0))
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        item = Node.void('item')
+        game.add_child(item)
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 1))
+        info.add_child(Node.u32('type', 5))
+        info.add_child(Node.u32('param', 333333376))
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 0))
+        info.add_child(Node.u32('type', 5))
+        info.add_child(Node.u32('param', 600))
+        game.add_child(Node.s32_array('hidden_param', [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        game.add_child(Node.s16('skill_name_id', -1))
+        game.add_child(Node.s32('earned_blaster_energy', blaster_energy))
+        game.add_child(Node.u32('blaster_count', 0))
+        printn = Node.void('print')
+        game.add_child(printn)
+        printn.add_child(Node.s32('count', 0))
+        ea_shop = Node.void('ea_shop')
+        game.add_child(ea_shop)
+        ea_shop.add_child(Node.s32('used_packet_booster', 0))
+        ea_shop.add_child(Node.s32('used_block_booster', 0))
+        game.add_child(Node.s8('start_option', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_common(self, loc: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'common')
+        game.add_child(Node.string('locid', loc))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.string('hadid', '1000'))
+        game.add_child(Node.string('licid', '1000'))
+        game.add_child(Node.string('actid', self.pcbid))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/music_limited")
+        self.assert_path(resp, "response/game_3/event/info/event_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/course_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/level")
+        self.assert_path(resp, "response/game_3/skill_course/info/season_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/season_name")
+        self.assert_path(resp, "response/game_3/skill_course/info/season_new_flg")
+        self.assert_path(resp, "response/game_3/skill_course/info/course_name")
+        self.assert_path(resp, "response/game_3/skill_course/info/course_type")
+        self.assert_path(resp, "response/game_3/skill_course/info/skill_name_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/matching_assist")
+        self.assert_path(resp, "response/game_3/skill_course/info/gauge_type")
+        self.assert_path(resp, "response/game_3/skill_course/info/paseli_type")
+        self.assert_path(resp, "response/game_3/skill_course/info/track/track_no")
+        self.assert_path(resp, "response/game_3/skill_course/info/track/music_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/track/music_type")
+
+    def verify_game_buy(self, refid: str, catalogtype: int, catalogid: int, currencytype: int, price: int, itemtype: int, itemid: int, param: int, success: bool) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'buy')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u8('catalog_type', catalogtype))
+        game.add_child(Node.u32('catalog_id', catalogid))
+        game.add_child(Node.u32('earned_gamecoin_packet', 0))
+        game.add_child(Node.u32('earned_gamecoin_block', 0))
+        game.add_child(Node.u32('currency_type', currencytype))
+        item = Node.void('item')
+        game.add_child(item)
+        item.add_child(Node.u32('item_type', itemtype))
+        item.add_child(Node.u32('item_id', itemid))
+        item.add_child(Node.u32('param', param))
+        item.add_child(Node.u32('price', price))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/gamecoin_packet")
+        self.assert_path(resp, "response/game_3/gamecoin_block")
+        self.assert_path(resp, "response/game_3/result")
+
+        if success:
+            if resp.child_value('game_3/result') != 0:
+                raise Exception('Failed to purchase!')
+        else:
+            if resp.child_value('game_3/result') == 0:
+                raise Exception('Purchased when shouldn\'t have!')
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('cardid', cardid))
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game_3/result")
+            if resp.child_value('game_3/result') != 1:
+                raise Exception("Invalid result for new profile!")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game_3/name")
+            self.assert_path(resp, "response/game_3/code")
+            self.assert_path(resp, "response/game_3/gamecoin_packet")
+            self.assert_path(resp, "response/game_3/gamecoin_block")
+            self.assert_path(resp, "response/game_3/skill_name_id")
+            self.assert_path(resp, "response/game_3/hidden_param")
+            self.assert_path(resp, "response/game_3/blaster_energy")
+            self.assert_path(resp, "response/game_3/blaster_count")
+            self.assert_path(resp, "response/game_3/play_count")
+            self.assert_path(resp, "response/game_3/daily_count")
+            self.assert_path(resp, "response/game_3/play_chain")
+            self.assert_path(resp, "response/game_3/item")
+            self.assert_path(resp, "response/game_3/skill/course_all")
+            self.assert_path(resp, "response/game_3/story")
+
+            items: Dict[int, Dict[int, int]] = {}
+            for child in resp.child('game_3/item').children:
+                if child.name != 'info':
+                    continue
+
+                itype = child.child_value('type')
+                iid = child.child_value('id')
+                param = child.child_value('param')
+
+                if itype not in items:
+                    items[itype] = {}
+                items[itype][iid] = param
+
+            courses: Dict[int, Dict[int, Dict[str, int]]] = {}
+            for child in resp.child('game_3/skill/course_all').children:
+                if child.name != 'd':
+                    continue
+
+                crsid = child.child_value('crsid')
+                season = child.child_value('ssnid')
+                achievement_rate = child.child_value('ar')
+                clear_type = child.child_value('ct')
+
+                if season not in courses:
+                    courses[season] = {}
+                courses[season][crsid] = {
+                    'achievement_rate': achievement_rate,
+                    'clear_type': clear_type,
+                }
+
+            return {
+                'name': resp.child_value('game_3/name'),
+                'packet': resp.child_value('game_3/gamecoin_packet'),
+                'block': resp.child_value('game_3/gamecoin_block'),
+                'blaster_energy': resp.child_value('game_3/blaster_energy'),
+                'items': items,
+                'courses': courses,
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_lounge(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'lounge')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/interval")
+
+    def verify_game_entry_s(self) -> int:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'entry_s')
+        game.add_child(Node.u8('c_ver', 101))
+        game.add_child(Node.u8('p_num', 1))
+        game.add_child(Node.u8('p_rest', 1))
+        game.add_child(Node.u8('filter', 1))
+        game.add_child(Node.u32('mid', 416))
+        game.add_child(Node.u32('sec', 45))
+        game.add_child(Node.u16('port', 10007))
+        game.add_child(Node.fouru8('gip', [127, 0, 0, 1]))
+        game.add_child(Node.fouru8('lip', [10, 0, 5, 73]))
+        game.add_child(Node.u8('claim', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/entry_id")
+        return resp.child_value('game_3/entry_id')
+
+    def verify_game_entry_e(self, eid: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'entry_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u32('eid', eid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_save_e(self, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'save_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_play_e(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'play_e')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s8('mode', 2))
+        game.add_child(Node.s16('track_num', 3))
+        game.add_child(Node.s32('s_coin', 0))
+        game.add_child(Node.s32('s_paseli', 0))
+        game.add_child(Node.s16('blaster_count', 0))
+        game.add_child(Node.s16('blaster_cartridge', 0))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u16('drop_frame', 396))
+        game.add_child(Node.u16('drop_frame_max', 396))
+        game.add_child(Node.u16('drop_count', 1))
+        game.add_child(Node.string('etc', 'StoryID:0,StoryPrg:0,PrgPrm:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load_m')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/new")
+
+        scores = []
+        for child in resp.child('game_3/new').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_id')
+            chart = child.child_value('music_type')
+            clear_type = child.child_value('clear_type')
+            score = child.child_value('score')
+            grade = child.child_value('score_grade')
+
+            scores.append({
+                'id': musicid,
+                'chart': chart,
+                'clear_type': clear_type,
+                'score': score,
+                'grade': grade,
+            })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_m')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.u32('music_id', score['id']))
+        game.add_child(Node.u32('music_type', score['chart']))
+        game.add_child(Node.u32('score', score['score']))
+        game.add_child(Node.u32('clear_type', score['clear_type']))
+        game.add_child(Node.u32('score_grade', score['grade']))
+        game.add_child(Node.u32('max_chain', 0))
+        game.add_child(Node.u32('critical', 0))
+        game.add_child(Node.u32('near', 0))
+        game.add_child(Node.u32('error', 0))
+        game.add_child(Node.u32('effective_rate', 100))
+        game.add_child(Node.u32('btn_rate', 0))
+        game.add_child(Node.u32('long_rate', 0))
+        game.add_child(Node.u32('vol_rate', 0))
+        game.add_child(Node.u8('mode', 0))
+        game.add_child(Node.u8('gauge_type', 0))
+        game.add_child(Node.u16('online_num', 0))
+        game.add_child(Node.u16('local_num', 0))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_save_c(self, location: str, refid: str, season: int, course: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_c')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s16('crsid', course))
+        game.add_child(Node.s16('ct', 2))
+        game.add_child(Node.s16('ar', 15000))
+        game.add_child(Node.s32('ssnid', season))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_common(location)
+        self.verify_game_shop(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # SDVX doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        self.verify_game_frozen(ref_id, 0)
+        self.verify_game_save_e(ref_id)
+        self.verify_game_play_e(location, ref_id)
+
+        # Verify lobby functionality
+        self.verify_game_lounge()
+        eid = self.verify_game_entry_s()
+        self.verify_game_entry_e(eid)
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['blaster_energy'] != 0:
+                raise Exception('Profile has nonzero blaster energy associated with it!')
+            if profile['items']:
+                raise Exception('Profile already has purchased items!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            # Verify purchase failure, try buying song we can't afford
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, False)
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, blaster_energy=42)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 42:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 5 not in profile['items']:
+                raise Exception('Profile doesn\'t have user settings items in it!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            self.verify_game_save(location, ref_id, packet=1, block=2, blaster_energy=3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 236:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 5 not in profile['items']:
+                raise Exception('Profile doesn\'t have user settings items in it!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify purchase success, buy a song we can afford now
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, True)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 226:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 0 not in profile['items'] or 29 not in profile['items'][0]:
+                raise Exception('Purchase didn\'t add to profile!')
+            if profile['items'][0][29] != 3:
+                raise Exception('Purchase parameters are wrong!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify that we can finish skill analyzer courses
+            self.verify_game_save_c(location, ref_id, 14, 3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if 14 not in profile['courses'] or 3 not in profile['courses'][14]:
+                raise Exception('Course didn\'t add to profile!')
+            if profile['courses'][14][3]['achievement_rate'] != 15000:
+                raise Exception('Course didn\'t save achievement rate!')
+            if profile['courses'][14][3]['clear_type'] != 2:
+                raise Exception('Course didn\'t save clear type!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 3,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 3,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 3,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/sdvx/gravitywars_s2.py b/bemani/client/sdvx/gravitywars_s2.py
new file mode 100644
index 0000000..724f999
--- /dev/null
+++ b/bemani/client/sdvx/gravitywars_s2.py
@@ -0,0 +1,832 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class SoundVoltexGravityWarsS2Client(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '2.3.8'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'hiscore')
+        game.add_child(Node.string('locid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/hit/d/id")
+        self.assert_path(resp, "response/game_3/hit/d/cnt")
+        self.assert_path(resp, "response/game_3/sc/d/id")
+        self.assert_path(resp, "response/game_3/sc/d/ty")
+        self.assert_path(resp, "response/game_3/sc/d/a_sq")
+        self.assert_path(resp, "response/game_3/sc/d/a_nm")
+        self.assert_path(resp, "response/game_3/sc/d/a_sc")
+        self.assert_path(resp, "response/game_3/sc/d/cr")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', False))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+        game.add_child(Node.bool('newpc', False))
+        game.add_child(Node.s32('s_paseli', 206))
+        game.add_child(Node.s32('monitor', 1))
+        game.add_child(Node.string('romnumber', 'KFC-JA-B01'))
+        game.add_child(Node.string('etc', 'TaxMode:1,BasicRate:100/1,FirstFree:0'))
+        setting = Node.void('setting')
+        game.add_child(setting)
+        setting.add_child(Node.s32('coin_slot', 0))
+        setting.add_child(Node.s32('game_start', 1))
+        setting.add_child(Node.string('schedule', '0,0,0,0,0,0,0'))
+        setting.add_child(Node.string('reference', '1,1,1'))
+        setting.add_child(Node.string('basic_rate', '100,100,100'))
+        setting.add_child(Node.s32('tax_rate', 1))
+        setting.add_child(Node.string('time_service', '0,0,0'))
+        setting.add_child(Node.string('service_value', '10,10,10'))
+        setting.add_child(Node.string('service_limit', '10,10,10'))
+        setting.add_child(Node.string('service_time', '07:00-11:00,07:00-11:00,07:00-11:00'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/nxt_time")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('name', self.NAME))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'frozen')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/result")
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('cardid', cardid))
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game_3/result")
+            if resp.child_value('game_3/result') != 1:
+                raise Exception("Invalid result for new profile!")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game_3/name")
+            self.assert_path(resp, "response/game_3/code")
+            self.assert_path(resp, "response/game_3/gamecoin_packet")
+            self.assert_path(resp, "response/game_3/gamecoin_block")
+            self.assert_path(resp, "response/game_3/skill_name_id")
+            self.assert_path(resp, "response/game_3/skill_level")
+            self.assert_path(resp, "response/game_3/hidden_param")
+            self.assert_path(resp, "response/game_3/blaster_energy")
+            self.assert_path(resp, "response/game_3/blaster_count")
+            self.assert_path(resp, "response/game_3/play_count")
+            self.assert_path(resp, "response/game_3/daily_count")
+            self.assert_path(resp, "response/game_3/play_chain")
+            self.assert_path(resp, "response/game_3/item")
+            self.assert_path(resp, "response/game_3/skill/course_all")
+            self.assert_path(resp, "response/game_3/story")
+            self.assert_path(resp, "response/game_3/param")
+
+            items: Dict[int, Dict[int, int]] = {}
+            for child in resp.child('game_3/item').children:
+                if child.name != 'info':
+                    continue
+
+                itype = child.child_value('type')
+                iid = child.child_value('id')
+                param = child.child_value('param')
+
+                if itype not in items:
+                    items[itype] = {}
+                items[itype][iid] = param
+
+            courses: Dict[int, Dict[int, Dict[str, int]]] = {}
+            for child in resp.child('game_3/skill/course_all').children:
+                if child.name != 'd':
+                    continue
+
+                crsid = child.child_value('crsid')
+                season = child.child_value('ssnid')
+                achievement_rate = child.child_value('ar')
+                clear_type = child.child_value('ct')
+
+                if season not in courses:
+                    courses[season] = {}
+                courses[season][crsid] = {
+                    'achievement_rate': achievement_rate,
+                    'clear_type': clear_type,
+                }
+
+            return {
+                'name': resp.child_value('game_3/name'),
+                'packet': resp.child_value('game_3/gamecoin_packet'),
+                'block': resp.child_value('game_3/gamecoin_block'),
+                'blaster_energy': resp.child_value('game_3/blaster_energy'),
+                'skill_level': resp.child_value('game_3/skill_level'),
+                'items': items,
+                'courses': courses,
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, blaster_energy: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u16('appeal_id', 1001))
+        game.add_child(Node.u16('comment_id', 0))
+        game.add_child(Node.s32('music_id', 29))
+        game.add_child(Node.u8('music_type', 1))
+        game.add_child(Node.u8('sort_type', 1))
+        game.add_child(Node.u8('narrow_down', 0))
+        game.add_child(Node.u8('gauge_option', 0))
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        item = Node.void('item')
+        game.add_child(item)
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 1))
+        info.add_child(Node.u32('type', 5))
+        info.add_child(Node.u32('param', 333333376))
+        info = Node.void('info')
+        item.add_child(info)
+        info.add_child(Node.u32('id', 0))
+        info.add_child(Node.u32('type', 5))
+        info.add_child(Node.u32('param', 600))
+        game.add_child(Node.s32_array('hidden_param', [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        game.add_child(Node.s16('skill_name_id', -1))
+        game.add_child(Node.s32('earned_blaster_energy', blaster_energy))
+        game.add_child(Node.u32('blaster_count', 0))
+        printn = Node.void('print')
+        game.add_child(printn)
+        printn.add_child(Node.s32('count', 0))
+        ea_shop = Node.void('ea_shop')
+        game.add_child(ea_shop)
+        ea_shop.add_child(Node.s32('used_packet_booster', 0))
+        ea_shop.add_child(Node.s32('used_block_booster', 0))
+        game.add_child(Node.s8('start_option', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_common(self, loc: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'common')
+        game.add_child(Node.string('locid', loc))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.string('hadid', '1000'))
+        game.add_child(Node.string('licid', '1000'))
+        game.add_child(Node.string('actid', self.pcbid))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/music_limited")
+        self.assert_path(resp, "response/game_3/event/info/event_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/course_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/level")
+        self.assert_path(resp, "response/game_3/skill_course/info/season_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/season_name")
+        self.assert_path(resp, "response/game_3/skill_course/info/season_new_flg")
+        self.assert_path(resp, "response/game_3/skill_course/info/course_name")
+        self.assert_path(resp, "response/game_3/skill_course/info/course_type")
+        self.assert_path(resp, "response/game_3/skill_course/info/skill_name_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/matching_assist")
+        self.assert_path(resp, "response/game_3/skill_course/info/gauge_type")
+        self.assert_path(resp, "response/game_3/skill_course/info/paseli_type")
+        self.assert_path(resp, "response/game_3/skill_course/info/track/track_no")
+        self.assert_path(resp, "response/game_3/skill_course/info/track/music_id")
+        self.assert_path(resp, "response/game_3/skill_course/info/track/music_type")
+
+    def verify_game_buy(self, refid: str, catalogtype: int, catalogid: int, currencytype: int, price: int, itemtype: int, itemid: int, param: int, success: bool) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'buy')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u8('catalog_type', catalogtype))
+        game.add_child(Node.u32('catalog_id', catalogid))
+        game.add_child(Node.u32('earned_gamecoin_packet', 0))
+        game.add_child(Node.u32('earned_gamecoin_block', 0))
+        game.add_child(Node.u32('currency_type', currencytype))
+        item = Node.void('item')
+        game.add_child(item)
+        item.add_child(Node.u32('item_type', itemtype))
+        item.add_child(Node.u32('item_id', itemid))
+        item.add_child(Node.u32('param', param))
+        item.add_child(Node.u32('price', price))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/gamecoin_packet")
+        self.assert_path(resp, "response/game_3/gamecoin_block")
+        self.assert_path(resp, "response/game_3/result")
+
+        if success:
+            if resp.child_value('game_3/result') != 0:
+                raise Exception('Failed to purchase!')
+        else:
+            if resp.child_value('game_3/result') == 0:
+                raise Exception('Purchased when shouldn\'t have!')
+
+    def verify_game_lounge(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'lounge')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/interval")
+
+    def verify_game_entry_s(self) -> int:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'entry_s')
+        game.add_child(Node.u8('c_ver', 128))
+        game.add_child(Node.u8('p_num', 1))
+        game.add_child(Node.u8('p_rest', 1))
+        game.add_child(Node.u8('filter', 1))
+        game.add_child(Node.u32('mid', 416))
+        game.add_child(Node.u32('sec', 45))
+        game.add_child(Node.u16('port', 10007))
+        game.add_child(Node.fouru8('gip', [127, 0, 0, 1]))
+        game.add_child(Node.fouru8('lip', [10, 0, 5, 73]))
+        game.add_child(Node.u8('claim', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/entry_id")
+        return resp.child_value('game_3/entry_id')
+
+    def verify_game_entry_e(self, eid: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'entry_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u32('eid', eid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_save_e(self, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'save_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_play_e(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'play_e')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s8('mode', 2))
+        game.add_child(Node.s16('track_num', 3))
+        game.add_child(Node.s32('s_coin', 0))
+        game.add_child(Node.s32('s_paseli', 0))
+        game.add_child(Node.s16('blaster_count', 0))
+        game.add_child(Node.s16('blaster_cartridge', 0))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u16('drop_frame', 396))
+        game.add_child(Node.u16('drop_frame_max', 396))
+        game.add_child(Node.u16('drop_count', 1))
+        game.add_child(Node.string('etc', 'StoryID:0,StoryPrg:0,PrgPrm:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load_m')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3/new")
+
+        scores = []
+        for child in resp.child('game_3/new').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_id')
+            chart = child.child_value('music_type')
+            clear_type = child.child_value('clear_type')
+            score = child.child_value('score')
+            grade = child.child_value('score_grade')
+
+            scores.append({
+                'id': musicid,
+                'chart': chart,
+                'clear_type': clear_type,
+                'score': score,
+                'grade': grade,
+            })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_m')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.u32('music_id', score['id']))
+        game.add_child(Node.u32('music_type', score['chart']))
+        game.add_child(Node.u32('score', score['score']))
+        game.add_child(Node.u32('clear_type', score['clear_type']))
+        game.add_child(Node.u32('score_grade', score['grade']))
+        game.add_child(Node.u32('max_chain', 0))
+        game.add_child(Node.u32('critical', 0))
+        game.add_child(Node.u32('near', 0))
+        game.add_child(Node.u32('error', 0))
+        game.add_child(Node.u32('effective_rate', 100))
+        game.add_child(Node.u32('btn_rate', 0))
+        game.add_child(Node.u32('long_rate', 0))
+        game.add_child(Node.u32('vol_rate', 0))
+        game.add_child(Node.u8('mode', 0))
+        game.add_child(Node.u8('gauge_type', 0))
+        game.add_child(Node.u16('online_num', 0))
+        game.add_child(Node.u16('local_num', 0))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_load_r(self, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('method', 'load_r')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify_game_save_c(self, location: str, refid: str, season: int, course: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_3')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_c')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s16('crsid', course))
+        game.add_child(Node.s16('ct', 2))
+        game.add_child(Node.s16('ar', 15000))
+        game.add_child(Node.s32('ssnid', season))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_3")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_common(location)
+        self.verify_game_shop(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # SDVX doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify rivals node (necessary to return but can hold nothing)
+        self.verify_game_load_r(ref_id)
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        self.verify_game_frozen(ref_id, 0)
+        self.verify_game_save_e(ref_id)
+        self.verify_game_play_e(location, ref_id)
+
+        # Verify lobby functionality
+        self.verify_game_lounge()
+        eid = self.verify_game_entry_s()
+        self.verify_game_entry_e(eid)
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['blaster_energy'] != 0:
+                raise Exception('Profile has nonzero blaster energy associated with it!')
+            if profile['items']:
+                raise Exception('Profile already has purchased items!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            # Verify purchase failure, try buying song we can't afford
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, False)
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, blaster_energy=42)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 42:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 5 not in profile['items']:
+                raise Exception('Profile doesn\'t have user settings items in it!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            self.verify_game_save(location, ref_id, packet=1, block=2, blaster_energy=3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 236:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 5 not in profile['items']:
+                raise Exception('Profile doesn\'t have user settings items in it!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify purchase success, buy a song we can afford now
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, True)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 226:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 0 not in profile['items'] or 29 not in profile['items'][0]:
+                raise Exception('Purchase didn\'t add to profile!')
+            if profile['items'][0][29] != 3:
+                raise Exception('Purchase parameters are wrong!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify that we can finish skill analyzer courses
+            self.verify_game_save_c(location, ref_id, 14, 3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if 14 not in profile['courses'] or 3 not in profile['courses'][14]:
+                raise Exception('Course didn\'t add to profile!')
+            if profile['courses'][14][3]['achievement_rate'] != 15000:
+                raise Exception('Course didn\'t save achievement rate!')
+            if profile['courses'][14][3]['clear_type'] != 2:
+                raise Exception('Course didn\'t save clear type!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 3,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 3,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 3,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/sdvx/heavenlyhaven.py b/bemani/client/sdvx/heavenlyhaven.py
new file mode 100644
index 0000000..a0e7de6
--- /dev/null
+++ b/bemani/client/sdvx/heavenlyhaven.py
@@ -0,0 +1,914 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class SoundVoltexHeavenlyHavenClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '2.3.8'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_exception(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        game.set_attribute('method', 'sv4_exception')
+        game.add_child(Node.string('text', ''))
+        game.add_child(Node.string('lid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_hiscore')
+        game.add_child(Node.string('locid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/sc/d/id")
+        self.assert_path(resp, "response/game/sc/d/ty")
+        self.assert_path(resp, "response/game/sc/d/a_sq")
+        self.assert_path(resp, "response/game/sc/d/a_nm")
+        self.assert_path(resp, "response/game/sc/d/a_sc")
+        self.assert_path(resp, "response/game/sc/d/cr")
+        self.assert_path(resp, "response/game/sc/d/avg_sc")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', False))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+        game.add_child(Node.bool('newpc', False))
+        game.add_child(Node.s32('s_paseli', 206))
+        game.add_child(Node.s32('monitor', 1))
+        game.add_child(Node.string('romnumber', 'KFC-JA-B01'))
+        game.add_child(Node.string('etc', 'TaxMode:1,BasicRate:100/1,FirstFree:0'))
+        setting = Node.void('setting')
+        game.add_child(setting)
+        setting.add_child(Node.s32('coin_slot', 0))
+        setting.add_child(Node.s32('game_start', 1))
+        setting.add_child(Node.string('schedule', '0,0,0,0,0,0,0'))
+        setting.add_child(Node.string('reference', '1,1,1'))
+        setting.add_child(Node.string('basic_rate', '100,100,100'))
+        setting.add_child(Node.s32('tax_rate', 1))
+        setting.add_child(Node.string('time_service', '0,0,0'))
+        setting.add_child(Node.string('service_value', '10,10,10'))
+        setting.add_child(Node.string('service_limit', '10,10,10'))
+        setting.add_child(Node.string('service_time', '07:00-11:00,07:00-11:00,07:00-11:00'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/nxt_time")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_new')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('name', self.NAME))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_frozen')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/result")
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_load')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('cardid', cardid))
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game/result")
+            if resp.child_value('game/result') != 1:
+                raise Exception("Invalid result for new profile!")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game/name")
+            self.assert_path(resp, "response/game/code")
+            self.assert_path(resp, "response/game/sdvx_id")
+            self.assert_path(resp, "response/game/gamecoin_packet")
+            self.assert_path(resp, "response/game/gamecoin_block")
+            self.assert_path(resp, "response/game/skill_name_id")
+            self.assert_path(resp, "response/game/skill_base_id")
+            self.assert_path(resp, "response/game/skill_level")
+            self.assert_path(resp, "response/game/blaster_energy")
+            self.assert_path(resp, "response/game/blaster_count")
+            self.assert_path(resp, "response/game/play_count")
+            self.assert_path(resp, "response/game/today_count")
+            self.assert_path(resp, "response/game/play_chain")
+            self.assert_path(resp, "response/game/item")
+            self.assert_path(resp, "response/game/skill")
+            self.assert_path(resp, "response/game/param")
+            self.assert_path(resp, "response/game/pbc_infection/packet/before")
+            self.assert_path(resp, "response/game/pbc_infection/packet/after")
+            self.assert_path(resp, "response/game/pbc_infection/block/before")
+            self.assert_path(resp, "response/game/pbc_infection/block/after")
+            self.assert_path(resp, "response/game/pbc_infection/coloris/before")
+            self.assert_path(resp, "response/game/pbc_infection/coloris/after")
+            self.assert_path(resp, "response/game/pb_infection/packet/before")
+            self.assert_path(resp, "response/game/pb_infection/packet/after")
+            self.assert_path(resp, "response/game/pb_infection/block/before")
+            self.assert_path(resp, "response/game/pb_infection/block/after")
+
+            items: Dict[int, Dict[int, int]] = {}
+            for child in resp.child('game/item').children:
+                if child.name != 'info':
+                    continue
+
+                itype = child.child_value('type')
+                iid = child.child_value('id')
+                param = child.child_value('param')
+
+                if itype not in items:
+                    items[itype] = {}
+                items[itype][iid] = param
+
+            courses: Dict[int, Dict[int, Dict[str, int]]] = {}
+            for child in resp.child('game/skill').children:
+                if child.name != 'course':
+                    continue
+
+                crsid = child.child_value('crsid')
+                season = child.child_value('ssnid')
+                achievement_rate = child.child_value('ar')
+                clear_type = child.child_value('ct')
+                grade = child.child_value('gr')
+                score = child.child_value('sc')
+
+                if season not in courses:
+                    courses[season] = {}
+                courses[season][crsid] = {
+                    'achievement_rate': achievement_rate,
+                    'clear_type': clear_type,
+                    'grade': grade,
+                    'score': score,
+                }
+
+            return {
+                'name': resp.child_value('game/name'),
+                'packet': resp.child_value('game/gamecoin_packet'),
+                'block': resp.child_value('game/gamecoin_block'),
+                'blaster_energy': resp.child_value('game/blaster_energy'),
+                'skill_level': resp.child_value('game/skill_level'),
+                'items': items,
+                'courses': courses,
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, blaster_energy: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_save')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u16('appeal_id', 1001))
+        game.add_child(Node.u16('comment_id', 0))
+        game.add_child(Node.s32('music_id', 29))
+        game.add_child(Node.u8('music_type', 1))
+        game.add_child(Node.u8('sort_type', 1))
+        game.add_child(Node.u8('narrow_down', 0))
+        game.add_child(Node.u8('gauge_option', 0))
+        game.add_child(Node.u8('ars_option', 0))
+        game.add_child(Node.u8('notes_option', 0))
+        game.add_child(Node.u8('early_late_disp', 0))
+        game.add_child(Node.s32('draw_adjust', 0))
+        game.add_child(Node.u8('eff_c_left', 0))
+        game.add_child(Node.u8('eff_c_right', 1))
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        item = Node.void('item')
+        game.add_child(item)
+        game.add_child(Node.s16('skill_name_id', 0))
+        game.add_child(Node.s16('skill_base_id', 0))
+        game.add_child(Node.s16('skill_name', 0))
+        game.add_child(Node.s32('earned_blaster_energy', blaster_energy))
+        game.add_child(Node.u32('blaster_count', 0))
+        printn = Node.void('print')
+        game.add_child(printn)
+        printn.add_child(Node.s32('count', 0))
+        ea_shop = Node.void('ea_shop')
+        game.add_child(ea_shop)
+        ea_shop.add_child(Node.s32('used_packet_booster', 0))
+        ea_shop.add_child(Node.s32('used_block_booster', 0))
+        game.add_child(Node.s8('start_option', 1))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_common(self, loc: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_common')
+        game.add_child(Node.string('locid', loc))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/music_limited")
+        self.assert_path(resp, "response/game/catalog")
+        self.assert_path(resp, "response/game/event/info/event_id")
+        self.assert_path(resp, "response/game/reitaisai2018")
+        self.assert_path(resp, "response/game/volte_factory/goods")
+        self.assert_path(resp, "response/game/volte_factory/stock")
+        self.assert_path(resp, "response/game/appealcard")
+        self.assert_path(resp, "response/game/extend")
+        self.assert_path(resp, "response/game/skill_course/info/season_id")
+        self.assert_path(resp, "response/game/skill_course/info/season_name")
+        self.assert_path(resp, "response/game/skill_course/info/season_new_flg")
+        self.assert_path(resp, "response/game/skill_course/info/course_id")
+        self.assert_path(resp, "response/game/skill_course/info/course_name")
+        self.assert_path(resp, "response/game/skill_course/info/course_type")
+        self.assert_path(resp, "response/game/skill_course/info/skill_level")
+        self.assert_path(resp, "response/game/skill_course/info/skill_name_id")
+        self.assert_path(resp, "response/game/skill_course/info/matching_assist")
+        self.assert_path(resp, "response/game/skill_course/info/clear_rate")
+        self.assert_path(resp, "response/game/skill_course/info/avg_score")
+        self.assert_path(resp, "response/game/skill_course/info/track/track_no")
+        self.assert_path(resp, "response/game/skill_course/info/track/music_id")
+        self.assert_path(resp, "response/game/skill_course/info/track/music_type")
+
+    def verify_game_buy(self, refid: str, catalogtype: int, catalogid: int, currencytype: int, price: int, itemtype: int, itemid: int, param: int, success: bool) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_buy')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u8('catalog_type', catalogtype))
+        game.add_child(Node.u32('catalog_id', catalogid))
+        game.add_child(Node.u32('earned_gamecoin_packet', 0))
+        game.add_child(Node.u32('earned_gamecoin_block', 0))
+        game.add_child(Node.u32('currency_type', currencytype))
+        item = Node.void('item')
+        game.add_child(item)
+        item.add_child(Node.u32('item_type', itemtype))
+        item.add_child(Node.u32('item_id', itemid))
+        item.add_child(Node.u32('param', param))
+        item.add_child(Node.u32('price', price))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/gamecoin_packet")
+        self.assert_path(resp, "response/game/gamecoin_block")
+        self.assert_path(resp, "response/game/result")
+
+        if success:
+            if resp.child_value('game/result') != 0:
+                raise Exception('Failed to purchase!')
+        else:
+            if resp.child_value('game/result') == 0:
+                raise Exception('Purchased when shouldn\'t have!')
+
+    def verify_game_lounge(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_lounge')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/interval")
+
+    def verify_game_entry_s(self) -> int:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_entry_s')
+        game.add_child(Node.u8('c_ver', 174))
+        game.add_child(Node.u8('p_num', 1))
+        game.add_child(Node.u8('p_rest', 1))
+        game.add_child(Node.u8('filter', 1))
+        game.add_child(Node.u32('mid', 492))
+        game.add_child(Node.u32('sec', 45))
+        game.add_child(Node.u16('port', 10007))
+        game.add_child(Node.fouru8('gip', [127, 0, 0, 1]))
+        game.add_child(Node.fouru8('lip', [10, 0, 5, 73]))
+        game.add_child(Node.u8('claim', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/entry_id")
+        return resp.child_value('game/entry_id')
+
+    def verify_game_entry_e(self, eid: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_entry_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u32('eid', eid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_save_e(self, location: str, cardid: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_save_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('cardnumber', cardid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.s32('playid', 1))
+        game.add_child(Node.bool('is_paseli', False))
+        game.add_child(Node.s32('online_num', 0))
+        game.add_child(Node.s32('local_num', 0))
+        game.add_child(Node.s32('start_option', 0))
+        game.add_child(Node.s32('print_num', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+        self.assert_path(resp, "response/game/pbc_infection/packet/before")
+        self.assert_path(resp, "response/game/pbc_infection/packet/after")
+        self.assert_path(resp, "response/game/pbc_infection/block/before")
+        self.assert_path(resp, "response/game/pbc_infection/block/after")
+        self.assert_path(resp, "response/game/pbc_infection/coloris/before")
+        self.assert_path(resp, "response/game/pbc_infection/coloris/after")
+        self.assert_path(resp, "response/game/pb_infection/packet/before")
+        self.assert_path(resp, "response/game/pb_infection/packet/after")
+        self.assert_path(resp, "response/game/pb_infection/block/before")
+        self.assert_path(resp, "response/game/pb_infection/block/after")
+
+    def verify_game_play_s(self) -> int:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_play_s')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/play_id")
+        return resp.child_value('game/play_id')
+
+    def verify_game_play_e(self, location: str, refid: str, play_id: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_play_e')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('play_id', play_id))
+        game.add_child(Node.s8('start_type', 1))
+        game.add_child(Node.s8('mode', 2))
+        game.add_child(Node.s16('track_num', 3))
+        game.add_child(Node.s32('s_coin', 0))
+        game.add_child(Node.s32('s_paseli', 247))
+        game.add_child(Node.u32('print_card', 0))
+        game.add_child(Node.u32('print_result', 0))
+        game.add_child(Node.u32('blaster_num', 0))
+        game.add_child(Node.u32('today_cnt', 1))
+        game.add_child(Node.u32('play_chain', 1))
+        game.add_child(Node.u32('week_play_cnt', 0))
+        game.add_child(Node.u32('week_chain', 0))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u16('drop_frame', 16169))
+        game.add_child(Node.u16('drop_frame_max', 11984))
+        game.add_child(Node.u16('drop_count', 6))
+        game.add_child(Node.string('etc', 'play_t:605'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_load_m')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game/music")
+
+        scores = []
+        for child in resp.child('game/music').children:
+            if child.name != 'info':
+                continue
+
+            musicid = child.child_value('param')[0]
+            chart = child.child_value('param')[1]
+            clear_type = child.child_value('param')[3]
+            score = child.child_value('param')[2]
+            grade = child.child_value('param')[4]
+
+            scores.append({
+                'id': musicid,
+                'chart': chart,
+                'clear_type': clear_type,
+                'score': score,
+                'grade': grade,
+            })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, play_id: int, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_save_m')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.u32('play_id', play_id))
+        game.add_child(Node.u16('track_no', 0))
+        game.add_child(Node.u32('music_id', score['id']))
+        game.add_child(Node.u32('music_type', score['chart']))
+        game.add_child(Node.u32('score', score['score']))
+        game.add_child(Node.u32('clear_type', score['clear_type']))
+        game.add_child(Node.u32('score_grade', score['grade']))
+        game.add_child(Node.u32('max_chain', 0))
+        game.add_child(Node.u32('critical', 0))
+        game.add_child(Node.u32('near', 0))
+        game.add_child(Node.u32('error', 0))
+        game.add_child(Node.u32('effective_rate', 100))
+        game.add_child(Node.u32('btn_rate', 0))
+        game.add_child(Node.u32('long_rate', 0))
+        game.add_child(Node.u32('vol_rate', 0))
+        game.add_child(Node.u8('mode', 0))
+        game.add_child(Node.u8('gauge_type', 0))
+        game.add_child(Node.u8('notes_option', 0))
+        game.add_child(Node.u16('online_num', 0))
+        game.add_child(Node.u16('local_num', 0))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_load_r(self, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('method', 'sv4_load_r')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify_game_save_c(self, location: str, refid: str, play_id: int, season: int, course: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'sv4_save_c')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('play_id', play_id))
+        game.add_child(Node.s32('ssnid', season))
+        game.add_child(Node.s16('crsid', course))
+        game.add_child(Node.s16('ct', 2))
+        game.add_child(Node.s16('ar', 15000))
+        game.add_child(Node.u32('sc', 1234567))
+        game.add_child(Node.s16('gr', 7))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'local2',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_common(location)
+        self.verify_game_shop(location)
+        self.verify_game_exception(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # SDVX doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify rivals node (necessary to return but can hold nothing)
+        self.verify_game_load_r(ref_id)
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        play_id = self.verify_game_play_s()
+        self.verify_game_save_e(location, card, ref_id)
+
+        # Verify lobby functionality
+        self.verify_game_lounge()
+        eid = self.verify_game_entry_s()
+        self.verify_game_entry_e(eid)
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['blaster_energy'] != 0:
+                raise Exception('Profile has nonzero blaster energy associated with it!')
+            if profile['items']:
+                raise Exception('Profile already has purchased items!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            # Verify purchase failure, try buying song we can't afford
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, False)
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, blaster_energy=42)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 42:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            self.verify_game_save(location, ref_id, packet=1, block=2, blaster_energy=3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 236:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify purchase success, buy a song we can afford now
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, True)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 226:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 0 not in profile['items'] or 29 not in profile['items'][0]:
+                raise Exception('Purchase didn\'t add to profile!')
+            if profile['items'][0][29] != 3:
+                raise Exception('Purchase parameters are wrong!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify that we can finish skill analyzer courses
+            self.verify_game_save_c(location, ref_id, play_id, 14, 3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if 14 not in profile['courses'] or 3 not in profile['courses'][14]:
+                raise Exception('Course didn\'t add to profile!')
+            if profile['courses'][14][3]['achievement_rate'] != 15000:
+                raise Exception('Course didn\'t save achievement rate!')
+            if profile['courses'][14][3]['clear_type'] != 2:
+                raise Exception('Course didn\'t save clear type!')
+            if profile['courses'][14][3]['score'] != 1234567:
+                raise Exception('Course didn\'t save score!')
+            if profile['courses'][14][3]['grade'] != 7:
+                raise Exception('Course didn\'t save grade!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 3,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 3,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 3,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, play_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Unfreeze account
+        self.verify_game_play_e(location, ref_id, play_id)
+        self.verify_game_frozen(ref_id, 0)
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/client/sdvx/infiniteinfection.py b/bemani/client/sdvx/infiniteinfection.py
new file mode 100644
index 0000000..f922dd1
--- /dev/null
+++ b/bemani/client/sdvx/infiniteinfection.py
@@ -0,0 +1,773 @@
+import random
+import time
+from typing import Any, Dict, List, Optional
+
+from bemani.client.base import BaseClient
+from bemani.protocol import Node
+
+
+class SoundVoltexInfiniteInfectionClient(BaseClient):
+    NAME = 'TEST'
+
+    def verify_eventlog_write(self, location: str) -> None:
+        call = self.call_node()
+
+        # Construct node
+        eventlog = Node.void('eventlog')
+        call.add_child(eventlog)
+        eventlog.set_attribute('method', 'write')
+        eventlog.add_child(Node.u32('retrycnt', 0))
+        data = Node.void('data')
+        eventlog.add_child(data)
+        data.add_child(Node.string('eventid', 'S_PWRON'))
+        data.add_child(Node.s32('eventorder', 0))
+        data.add_child(Node.u64('pcbtime', int(time.time() * 1000)))
+        data.add_child(Node.s64('gamesession', -1))
+        data.add_child(Node.string('strdata1', '1.7.6'))
+        data.add_child(Node.string('strdata2', ''))
+        data.add_child(Node.s64('numdata1', 1))
+        data.add_child(Node.s64('numdata2', 0))
+        data.add_child(Node.string('locationid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/eventlog/gamesession")
+        self.assert_path(resp, "response/eventlog/logsendflg")
+        self.assert_path(resp, "response/eventlog/logerrlevel")
+        self.assert_path(resp, "response/eventlog/evtidnosendflg")
+
+    def verify_game_hiscore(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'hiscore')
+        game.add_child(Node.string('locid', location))
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/hitchart/info/id")
+        self.assert_path(resp, "response/game_2/hitchart/info/cnt")
+        self.assert_path(resp, "response/game_2/hiscore_allover/info/id")
+        self.assert_path(resp, "response/game_2/hiscore_allover/info/type")
+        self.assert_path(resp, "response/game_2/hiscore_allover/info/name")
+        self.assert_path(resp, "response/game_2/hiscore_allover/info/code")
+        self.assert_path(resp, "response/game_2/hiscore_allover/info/score")
+        self.assert_path(resp, "response/game_2/hiscore_location/info/id")
+        self.assert_path(resp, "response/game_2/hiscore_location/info/type")
+        self.assert_path(resp, "response/game_2/hiscore_location/info/name")
+        self.assert_path(resp, "response/game_2/hiscore_location/info/code")
+        self.assert_path(resp, "response/game_2/hiscore_location/info/score")
+        self.assert_path(resp, "response/game_2/clear_rate/d/id")
+        self.assert_path(resp, "response/game_2/clear_rate/d/type")
+        self.assert_path(resp, "response/game_2/clear_rate/d/cr")
+
+    def verify_game_shop(self, location: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'shop')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.string('regcode', '.'))
+        game.add_child(Node.string('locname', ''))
+        game.add_child(Node.u8('loctype', 0))
+        game.add_child(Node.string('cstcode', ''))
+        game.add_child(Node.string('cpycode', ''))
+        game.add_child(Node.s32('latde', 0))
+        game.add_child(Node.s32('londe', 0))
+        game.add_child(Node.u8('accu', 0))
+        game.add_child(Node.string('linid', '.'))
+        game.add_child(Node.u8('linclass', 0))
+        game.add_child(Node.ipv4('ipaddr', '0.0.0.0'))
+        game.add_child(Node.string('hadid', '00010203040506070809'))
+        game.add_child(Node.string('licid', '00010203040506070809'))
+        game.add_child(Node.string('actid', self.pcbid))
+        game.add_child(Node.s8('appstate', 0))
+        game.add_child(Node.s8('c_need', 1))
+        game.add_child(Node.s8('c_credit', 2))
+        game.add_child(Node.s8('s_credit', 2))
+        game.add_child(Node.bool('free_p', True))
+        game.add_child(Node.bool('close', False))
+        game.add_child(Node.s32('close_t', 1380))
+        game.add_child(Node.u32('playc', 0))
+        game.add_child(Node.u32('playn', 0))
+        game.add_child(Node.u32('playe', 0))
+        game.add_child(Node.u32('test_m', 0))
+        game.add_child(Node.u32('service', 0))
+        game.add_child(Node.bool('paseli', True))
+        game.add_child(Node.u32('update', 0))
+        game.add_child(Node.string('shopname', ''))
+        game.add_child(Node.bool('newpc', False))
+        game.add_child(Node.s32('s_paseli', 206))
+        game.add_child(Node.s32('monitor', 1))
+        game.add_child(Node.string('romnumber', 'KFC-JA-M01'))
+        game.add_child(Node.string('etc', 'TaxMode:1,BasicRate:100/1,FirstFree:0'))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/nxt_time")
+
+    def verify_game_new(self, location: str, refid: str) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'new')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('name', self.NAME))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2")
+
+    def verify_game_frozen(self, refid: str, time: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'frozen')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u32('sec', time))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/result")
+
+    def verify_game_save(self, location: str, refid: str, packet: int, block: int, blaster_energy: int, appealcards: List[int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'save')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('locid', location))
+        game.add_child(Node.u8('headphone', 0))
+        game.add_child(Node.u8('hispeed', 52))
+        game.add_child(Node.u16('appeal_id', 1001))
+        game.add_child(Node.u16('comment_id', 0))
+        game.add_child(Node.s32('music_id', 29))
+        game.add_child(Node.u8('music_type', 1))
+        game.add_child(Node.u8('sort_type', 1))
+        game.add_child(Node.u8('narrow_down', 0))
+        game.add_child(Node.u8('gauge_option', 0))
+        game.add_child(Node.u32('earned_gamecoin_packet', packet))
+        game.add_child(Node.u32('earned_gamecoin_block', block))
+        game.add_child(Node.void('item'))
+        appealcard = Node.void('appealcard')
+        game.add_child(appealcard)
+        for card in appealcards:
+            info = Node.void('info')
+            info.add_child(Node.u32('id', card))
+            info.add_child(Node.u32('count', 0))
+            appealcard.add_child(info)
+        game.add_child(Node.s32_array('hidden_param', [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+        game.add_child(Node.s16('skill_name_id', -1))
+        game.add_child(Node.s32('earned_blaster_energy', blaster_energy))
+        game.add_child(Node.u32('blaster_count', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2")
+
+    def verify_game_common(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'common')
+        call.add_child(game)
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/music_limited")
+        self.assert_path(resp, "response/game_2/event/info/event_id")
+        self.assert_path(resp, "response/game_2/catalog")
+        self.assert_path(resp, "response/game_2/skill_course/info/course_id")
+        self.assert_path(resp, "response/game_2/skill_course/info/level")
+        self.assert_path(resp, "response/game_2/skill_course/info/season_id")
+        self.assert_path(resp, "response/game_2/skill_course/info/season_name")
+        self.assert_path(resp, "response/game_2/skill_course/info/season_new_flg")
+        self.assert_path(resp, "response/game_2/skill_course/info/course_name")
+        self.assert_path(resp, "response/game_2/skill_course/info/course_type")
+        self.assert_path(resp, "response/game_2/skill_course/info/skill_name_id")
+        self.assert_path(resp, "response/game_2/skill_course/info/matching_assist")
+        self.assert_path(resp, "response/game_2/skill_course/info/gauge_type")
+        self.assert_path(resp, "response/game_2/skill_course/info/paseli_type")
+        self.assert_path(resp, "response/game_2/skill_course/info/track/track_no")
+        self.assert_path(resp, "response/game_2/skill_course/info/track/music_id")
+        self.assert_path(resp, "response/game_2/skill_course/info/track/music_type")
+
+    def verify_game_buy(self, refid: str, catalogtype: int, catalogid: int, currencytype: int, price: int, itemtype: int, itemid: int, param: int, success: bool) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'buy')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.u8('catalog_type', catalogtype))
+        game.add_child(Node.u32('catalog_id', catalogid))
+        game.add_child(Node.u32('earned_gamecoin_packet', 0))
+        game.add_child(Node.u32('earned_gamecoin_block', 0))
+        game.add_child(Node.u32('currency_type', currencytype))
+        game.add_child(Node.u32('price', price))
+        game.add_child(Node.u32('item_type', itemtype))
+        game.add_child(Node.u32('item_id', itemid))
+        game.add_child(Node.u32('param', param))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/gamecoin_packet")
+        self.assert_path(resp, "response/game_2/gamecoin_block")
+        self.assert_path(resp, "response/game_2/result")
+
+        if success:
+            if resp.child_value('game_2/result') != 0:
+                raise Exception('Failed to purchase!')
+        else:
+            if resp.child_value('game_2/result') == 0:
+                raise Exception('Purchased when shouldn\'t have!')
+
+    def verify_game_load(self, cardid: str, refid: str, msg_type: str) -> Dict[str, Any]:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'load')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.string('cardid', cardid))
+        game.add_child(Node.string('refid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        if msg_type == "new":
+            self.assert_path(resp, "response/game_2/result")
+            if resp.child_value('game_2/result') != 1:
+                raise Exception("Invalid result for new profile!")
+            return None
+
+        if msg_type == "existing":
+            self.assert_path(resp, "response/game_2/name")
+            self.assert_path(resp, "response/game_2/code")
+            self.assert_path(resp, "response/game_2/gamecoin_packet")
+            self.assert_path(resp, "response/game_2/gamecoin_block")
+            self.assert_path(resp, "response/game_2/skill_name_id")
+            self.assert_path(resp, "response/game_2/hidden_param")
+            self.assert_path(resp, "response/game_2/blaster_energy")
+            self.assert_path(resp, "response/game_2/blaster_count")
+            self.assert_path(resp, "response/game_2/play_count")
+            self.assert_path(resp, "response/game_2/daily_count")
+            self.assert_path(resp, "response/game_2/play_chain")
+            self.assert_path(resp, "response/game_2/item")
+            self.assert_path(resp, "response/game_2/appealcard")
+            self.assert_path(resp, "response/game_2/skill/course_all")
+
+            items: Dict[int, Dict[int, int]] = {}
+            for child in resp.child('game_2/item').children:
+                if child.name != 'info':
+                    continue
+
+                itype = child.child_value('type')
+                iid = child.child_value('id')
+                param = child.child_value('param')
+
+                if itype not in items:
+                    items[itype] = {}
+                items[itype][iid] = param
+
+            appealcards: Dict[int, int] = {}
+            for child in resp.child('game_2/appealcard').children:
+                if child.name != 'info':
+                    continue
+
+                iid = child.child_value('id')
+                count = child.child_value('count')
+
+                appealcards[iid] = count
+
+            courses: Dict[int, Dict[int, Dict[str, int]]] = {}
+            for child in resp.child('game_2/skill/course_all').children:
+                if child.name != 'd':
+                    continue
+
+                crsid = child.child_value('crsid')
+                season = child.child_value('ssnid')
+                achievement_rate = child.child_value('ar')
+                clear_type = child.child_value('ct')
+
+                if season not in courses:
+                    courses[season] = {}
+                courses[season][crsid] = {
+                    'achievement_rate': achievement_rate,
+                    'clear_type': clear_type,
+                }
+
+            return {
+                'name': resp.child_value('game_2/name'),
+                'packet': resp.child_value('game_2/gamecoin_packet'),
+                'block': resp.child_value('game_2/gamecoin_block'),
+                'blaster_energy': resp.child_value('game_2/blaster_energy'),
+                'items': items,
+                'appealcards': appealcards,
+                'courses': courses,
+            }
+        else:
+            raise Exception("Invalid game load type {}".format(msg_type))
+
+    def verify_game_lounge(self) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'lounge')
+        game.set_attribute('ver', '0')
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/interval")
+
+    def verify_game_entry_s(self) -> int:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'entry_s')
+        game.add_child(Node.u8('c_ver', 69))
+        game.add_child(Node.u8('p_num', 1))
+        game.add_child(Node.u8('p_rest', 1))
+        game.add_child(Node.u8('filter', 1))
+        game.add_child(Node.u32('mid', 416))
+        game.add_child(Node.u32('sec', 45))
+        game.add_child(Node.u16('port', 10007))
+        game.add_child(Node.fouru8('gip', [127, 0, 0, 1]))
+        game.add_child(Node.fouru8('lip', [10, 0, 5, 73]))
+        game.add_child(Node.u8('claim', 0))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/entry_id")
+        return resp.child_value('game_2/entry_id')
+
+    def verify_game_entry_e(self, eid: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'entry_e')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.u32('eid', eid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2")
+
+    def verify_game_load_m(self, refid: str) -> List[Dict[str, int]]:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('method', 'load_m')
+        game.set_attribute('ver', '0')
+        game.add_child(Node.string('dataid', refid))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2/new")
+
+        scores = []
+        for child in resp.child('game_2/new').children:
+            if child.name != 'music':
+                continue
+
+            musicid = child.child_value('music_id')
+            chart = child.child_value('music_type')
+            clear_type = child.child_value('clear_type')
+            score = child.child_value('score')
+            grade = child.child_value('score_grade')
+
+            scores.append({
+                'id': musicid,
+                'chart': chart,
+                'clear_type': clear_type,
+                'score': score,
+                'grade': grade,
+            })
+
+        return scores
+
+    def verify_game_save_m(self, location: str, refid: str, score: Dict[str, int]) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_m')
+        game.add_child(Node.string('refid', refid))
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.u32('music_id', score['id']))
+        game.add_child(Node.u32('music_type', score['chart']))
+        game.add_child(Node.u32('score', score['score']))
+        game.add_child(Node.u32('clear_type', score['clear_type']))
+        game.add_child(Node.u32('score_grade', score['grade']))
+        game.add_child(Node.u32('max_chain', 0))
+        game.add_child(Node.u32('critical', 0))
+        game.add_child(Node.u32('near', 0))
+        game.add_child(Node.u32('error', 0))
+        game.add_child(Node.u32('effective_rate', 100))
+        game.add_child(Node.u32('btn_rate', 0))
+        game.add_child(Node.u32('long_rate', 0))
+        game.add_child(Node.u32('vol_rate', 0))
+        game.add_child(Node.u8('mode', 0))
+        game.add_child(Node.u8('gauge_type', 0))
+        game.add_child(Node.u16('online_num', 0))
+        game.add_child(Node.u16('local_num', 0))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2")
+
+    def verify_game_save_c(self, location: str, refid: str, season: int, course: int) -> None:
+        call = self.call_node()
+
+        game = Node.void('game_2')
+        call.add_child(game)
+        game.set_attribute('ver', '0')
+        game.set_attribute('method', 'save_c')
+        game.add_child(Node.string('dataid', refid))
+        game.add_child(Node.s16('crsid', course))
+        game.add_child(Node.s16('ct', 2))
+        game.add_child(Node.s16('ar', 15000))
+        game.add_child(Node.s32('ssnid', season))
+        game.add_child(Node.string('locid', location))
+
+        # Swap with server
+        resp = self.exchange('', call)
+
+        # Verify that response is correct
+        self.assert_path(resp, "response/game_2")
+
+    def verify(self, cardid: Optional[str]) -> None:
+        # Verify boot sequence is okay
+        self.verify_services_get(
+            expected_services=[
+                'pcbtracker',
+                'pcbevent',
+                'local',
+                'message',
+                'facility',
+                'cardmng',
+                'package',
+                'posevent',
+                'pkglist',
+                'dlstatus',
+                'eacoin',
+                'lobby',
+                'ntp',
+                'keepalive'
+            ]
+        )
+        paseli_enabled = self.verify_pcbtracker_alive()
+        self.verify_message_get()
+        self.verify_package_list()
+        location = self.verify_facility_get()
+        self.verify_pcbevent_put()
+        self.verify_eventlog_write(location)
+        self.verify_game_common()
+        self.verify_game_shop(location)
+
+        # Verify card registration and profile lookup
+        if cardid is not None:
+            card = cardid
+        else:
+            card = self.random_card()
+            print("Generated random card ID {} for use.".format(card))
+
+        if cardid is None:
+            self.verify_cardmng_inquire(card, msg_type='unregistered', paseli_enabled=paseli_enabled)
+            ref_id = self.verify_cardmng_getrefid(card)
+            if len(ref_id) != 16:
+                raise Exception('Invalid refid \'{}\' returned when registering card'.format(ref_id))
+            if ref_id != self.verify_cardmng_inquire(card, msg_type='new', paseli_enabled=paseli_enabled):
+                raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+            # SDVX doesn't read the new profile, it asks for the profile itself after calling new
+            self.verify_game_load(card, ref_id, msg_type='new')
+            self.verify_game_new(location, ref_id)
+            self.verify_game_load(card, ref_id, msg_type='existing')
+        else:
+            print("Skipping new card checks for existing card")
+            ref_id = self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled)
+
+        # Verify pin handling and return card handling
+        self.verify_cardmng_authpass(ref_id, correct=True)
+        self.verify_cardmng_authpass(ref_id, correct=False)
+        if ref_id != self.verify_cardmng_inquire(card, msg_type='query', paseli_enabled=paseli_enabled):
+            raise Exception('Invalid refid \'{}\' returned when querying card'.format(ref_id))
+
+        # Verify account freezing
+        self.verify_game_frozen(ref_id, 900)
+        self.verify_game_frozen(ref_id, 0)
+
+        # Verify lobby functionality
+        self.verify_game_lounge()
+        eid = self.verify_game_entry_s()
+        self.verify_game_entry_e(eid)
+
+        if cardid is None:
+            # Verify profile loading and saving
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 0:
+                raise Exception('Profile has nonzero blocks associated with it!')
+            if profile['block'] != 0:
+                raise Exception('Profile has nonzero packets associated with it!')
+            if profile['blaster_energy'] != 0:
+                raise Exception('Profile has nonzero blaster energy associated with it!')
+            if profile['items']:
+                raise Exception('Profile already has purchased items!')
+            if profile['appealcards']:
+                raise Exception('Profile already has appeal cards!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            # Verify purchase failure, try buying song we can't afford
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, False)
+
+            self.verify_game_save(location, ref_id, packet=123, block=234, blaster_energy=42, appealcards=[])
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 123:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 234:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 42:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if profile['items']:
+                raise Exception('Profile already has purchased items!')
+            if profile['appealcards']:
+                raise Exception('Profile already has appeal cards!')
+            if profile['courses']:
+                raise Exception('Profile already has finished courses!')
+
+            self.verify_game_save(location, ref_id, packet=1, block=2, blaster_energy=3, appealcards=[])
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 236:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if profile['items']:
+                raise Exception('Profile has invalid purchased items!')
+            if profile['appealcards']:
+                raise Exception('Profile has invalid appeal cards!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify purchase success, buy a song we can afford now
+            self.verify_game_buy(ref_id, 0, 29, 1, 10, 0, 29, 3, True)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if profile['name'] != self.NAME:
+                raise Exception('Profile has incorrect name {} associated with it!'.format(profile['name']))
+            if profile['packet'] != 124:
+                raise Exception('Profile has invalid blocks associated with it!')
+            if profile['block'] != 226:
+                raise Exception('Profile has invalid packets associated with it!')
+            if profile['blaster_energy'] != 45:
+                raise Exception('Profile has invalid blaster energy associated with it!')
+            if 0 not in profile['items'] or 29 not in profile['items'][0]:
+                raise Exception('Purchase didn\'t add to profile!')
+            if profile['items'][0][29] != 3:
+                raise Exception('Purchase parameters are wrong!')
+            if profile['appealcards']:
+                raise Exception('Profile has invalid appeal cards!')
+            if profile['courses']:
+                raise Exception('Profile has invalid finished courses!')
+
+            # Verify that we can earn appeal cards
+            self.verify_game_save(location, ref_id, packet=0, block=0, blaster_energy=0, appealcards=[1001, 1002, 1003, 1004, 1005])
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            for i in [1001, 1002, 1003, 1004, 1005]:
+                if i not in profile['appealcards']:
+                    raise Exception('Profile missing appeal card {}'.format(i))
+                if profile['appealcards'][i] != 0:
+                    raise Exception('Profile has bad count for appeal card {}'.format(i))
+
+            # Verify that we can finish skill analyzer courses
+            self.verify_game_save_c(location, ref_id, 14, 3)
+            profile = self.verify_game_load(card, ref_id, msg_type='existing')
+            if 14 not in profile['courses'] or 3 not in profile['courses'][14]:
+                raise Exception('Course didn\'t add to profile!')
+            if profile['courses'][14][3]['achievement_rate'] != 15000:
+                raise Exception('Course didn\'t save achievement rate!')
+            if profile['courses'][14][3]['clear_type'] != 2:
+                raise Exception('Course didn\'t save clear type!')
+
+            # Verify empty profile has no scores on it
+            scores = self.verify_game_load_m(ref_id)
+            if len(scores) > 0:
+                raise Exception('Score on an empty profile!')
+
+            # Verify score saving and updating
+            for phase in [1, 2]:
+                if phase == 1:
+                    dummyscores = [
+                        # An okay score on a chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 3,
+                            'clear_type': 2,
+                            'score': 765432,
+                        },
+                        # A good score on an easier chart of the same song
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 6,
+                            'clear_type': 3,
+                            'score': 7654321,
+                        },
+                        # A bad score on a hard chart
+                        {
+                            'id': 2,
+                            'chart': 2,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 12345,
+                        },
+                        # A terrible score on an easy chart
+                        {
+                            'id': 3,
+                            'chart': 0,
+                            'grade': 1,
+                            'clear_type': 1,
+                            'score': 123,
+                        },
+                    ]
+                if phase == 2:
+                    dummyscores = [
+                        # A better score on the same chart
+                        {
+                            'id': 1,
+                            'chart': 1,
+                            'grade': 5,
+                            'clear_type': 3,
+                            'score': 8765432,
+                        },
+                        # A worse score on another same chart
+                        {
+                            'id': 1,
+                            'chart': 0,
+                            'grade': 4,
+                            'clear_type': 2,
+                            'score': 6543210,
+                            'expected_score': 7654321,
+                            'expected_clear_type': 3,
+                            'expected_grade': 6,
+                        },
+                    ]
+                for dummyscore in dummyscores:
+                    self.verify_game_save_m(location, ref_id, dummyscore)
+
+                scores = self.verify_game_load_m(ref_id)
+                for expected in dummyscores:
+                    actual = None
+                    for received in scores:
+                        if received['id'] == expected['id'] and received['chart'] == expected['chart']:
+                            actual = received
+                            break
+
+                    if actual is None:
+                        raise Exception("Didn't find song {} chart {} in response!".format(expected['id'], expected['chart']))
+
+                    if 'expected_score' in expected:
+                        expected_score = expected['expected_score']
+                    else:
+                        expected_score = expected['score']
+                    if 'expected_grade' in expected:
+                        expected_grade = expected['expected_grade']
+                    else:
+                        expected_grade = expected['grade']
+                    if 'expected_clear_type' in expected:
+                        expected_clear_type = expected['expected_clear_type']
+                    else:
+                        expected_clear_type = expected['clear_type']
+
+                    if actual['score'] != expected_score:
+                        raise Exception('Expected a score of \'{}\' for song \'{}\' chart \'{}\' but got score \'{}\''.format(
+                            expected_score, expected['id'], expected['chart'], actual['score'],
+                        ))
+                    if actual['grade'] != expected_grade:
+                        raise Exception('Expected a grade of \'{}\' for song \'{}\' chart \'{}\' but got grade \'{}\''.format(
+                            expected_grade, expected['id'], expected['chart'], actual['grade'],
+                        ))
+                    if actual['clear_type'] != expected_clear_type:
+                        raise Exception('Expected a clear_type of \'{}\' for song \'{}\' chart \'{}\' but got clear_type \'{}\''.format(
+                            expected_clear_type, expected['id'], expected['chart'], actual['clear_type'],
+                        ))
+
+                # Sleep so we don't end up putting in score history on the same second
+                time.sleep(1)
+
+        else:
+            print("Skipping score checks for existing card")
+
+        # Verify high score tables
+        self.verify_game_hiscore(location)
+
+        # Verify paseli handling
+        if paseli_enabled:
+            print("PASELI enabled for this PCBID, executing PASELI checks")
+        else:
+            print("PASELI disabled for this PCBID, skipping PASELI checks")
+            return
+
+        sessid, balance = self.verify_eacoin_checkin(card)
+        if balance == 0:
+            print("Skipping PASELI consume check because card has 0 balance")
+        else:
+            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
+        self.verify_eacoin_checkout(sessid)
diff --git a/bemani/common/__init__.py b/bemani/common/__init__.py
new file mode 100644
index 0000000..f2b811e
--- /dev/null
+++ b/bemani/common/__init__.py
@@ -0,0 +1,9 @@
+from bemani.common.model import Model
+from bemani.common.validateddict import ValidatedDict, intish
+from bemani.common.http import HTTP
+from bemani.common.constants import APIConstants, GameConstants, VersionConstants, DBConstants
+from bemani.common.card import CardCipher, CardCipherException
+from bemani.common.id import ID
+from bemani.common.aes import AESCipher
+from bemani.common.time import Time
+from bemani.common.parallel import Parallel
diff --git a/bemani/common/aes.py b/bemani/common/aes.py
new file mode 100644
index 0000000..731305c
--- /dev/null
+++ b/bemani/common/aes.py
@@ -0,0 +1,38 @@
+import base64
+import hashlib
+from Crypto import Random
+from Crypto.Cipher import AES
+
+
+class AESCipher:
+    """
+    Simple AES cipher used to provide cookie support to the frontend.
+    """
+
+    def __init__(self, key: str) -> None:
+        self.__padamt = 16
+        self.__key = hashlib.sha256(key.encode('utf-8')).digest()
+
+    def __pad(self, s: str) -> str:
+        intermediate = "{}.{}".format(len(s), s)
+        while len(intermediate) % self.__padamt != 0:
+            intermediate = intermediate + '-'
+        return intermediate
+
+    def __unpad(self, s: str) -> str:
+        length, string = s.split('.', 1)
+        intlength = int(length)
+        return string[:intlength]
+
+    def encrypt(self, raw: str) -> str:
+        raw = self.__pad(raw)
+        random = Random.new()  # type: ignore
+        iv = random.read(AES.block_size)
+        cipher = AES.new(self.__key, AES.MODE_CBC, iv)
+        return base64.b64encode(iv + cipher.encrypt(raw.encode('utf-8')), altchars=b"._").decode('utf-8')
+
+    def decrypt(self, encoded: str) -> str:
+        enc = base64.b64decode(encoded.encode('utf-8'), altchars=b"._")
+        iv = enc[:AES.block_size]
+        cipher = AES.new(self.__key, AES.MODE_CBC, iv)
+        return self.__unpad(cipher.decrypt(enc[AES.block_size:]).decode('utf-8'))
diff --git a/bemani/common/card.py b/bemani/common/card.py
new file mode 100644
index 0000000..73795c3
--- /dev/null
+++ b/bemani/common/card.py
@@ -0,0 +1,540 @@
+from typing import List
+
+
+class CardCipherException(Exception):
+    pass
+
+
+class CardCipher:
+    """
+    Algorithm for converting between the Card ID as stored in an
+    eAmusement card and the 16 character card string as shown on
+    the back of a card and in-game. All of this was kindly RE'd by
+    Tau and converted ham-fistedly to Python.
+    """
+
+    KEY = [
+        0x20d0d03c, 0x868ecb41, 0xbcd89c84, 0x4c0e0d0d,
+        0x84fc30ac, 0x4cc1890e, 0xfc5418a4, 0x02c50f44,
+        0x68acb4e0, 0x06cd4a4e, 0xcc28906c, 0x4f0c8ac0,
+        0xb03ca468, 0x884ac7c4, 0x389490d8, 0xcf80c6c2,
+        0x58d87404, 0xc48ec444, 0xb4e83c50, 0x498d0147,
+        0x64f454c0, 0x4c4701c8, 0xec302cc4, 0xc6c949c1,
+        0xc84c00f0, 0xcdcc49cc, 0x883c5cf4, 0x8b0fcb80,
+        0x703cc0b0, 0xcb820a8d, 0x78804c8c, 0x4fca830e,
+        0x80d0f03c, 0x8ec84f8c, 0x98c89c4c, 0xc80d878f,
+        0x54bc949c, 0xc801c5ce, 0x749078dc, 0xc3c80d46,
+        0x2c8070f0, 0x0cce4dcf, 0x8c3874e4, 0x8d448ac3,
+        0x987cac70, 0xc0c20ac5, 0x288cfc78, 0xc28543c8,
+        0x4c8c7434, 0xc50e4f8d, 0x8468f4b4, 0xcb4a0307,
+        0x2854dc98, 0x48430b45, 0x6858fce8, 0x4681cd49,
+        0xd04808ec, 0x458d0fcb, 0xe0a48ce4, 0x880f8fce,
+        0x7434b8fc, 0xce080a8e, 0x5860fc6c, 0x46c886cc,
+        0xd01098a4, 0xce090b8c, 0x1044cc2c, 0x86898e0f,
+        0xd0809c3c, 0x4a05860f, 0x54b4f80c, 0x4008870e,
+        0x1480b88c, 0x0ac8854f, 0x1c9034cc, 0x08444c4e,
+        0x0cb83c64, 0x41c08cc6, 0x1c083460, 0xc0c603ce,
+        0x2ca0645c, 0x818246cb, 0x0408e454, 0xc5464487,
+        0x88607c18, 0xc1424187, 0x284c7c90, 0xc1030509,
+        0x40486c94, 0x4603494b, 0xe0404ce4, 0x4109094d,
+        0x60443ce4, 0x4c0b8b8d, 0xe054e8bc, 0x02008e89,
+    ]
+
+    LUT_A0 = [
+        0x02080008, 0x02082000, 0x00002008, 0x00000000,
+        0x02002000, 0x00080008, 0x02080000, 0x02082008,
+        0x00000008, 0x02000000, 0x00082000, 0x00002008,
+        0x00082008, 0x02002008, 0x02000008, 0x02080000,
+        0x00002000, 0x00082008, 0x00080008, 0x02002000,
+        0x02082008, 0x02000008, 0x00000000, 0x00082000,
+        0x02000000, 0x00080000, 0x02002008, 0x02080008,
+        0x00080000, 0x00002000, 0x02082000, 0x00000008,
+        0x00080000, 0x00002000, 0x02000008, 0x02082008,
+        0x00002008, 0x02000000, 0x00000000, 0x00082000,
+        0x02080008, 0x02002008, 0x02002000, 0x00080008,
+        0x02082000, 0x00000008, 0x00080008, 0x02002000,
+        0x02082008, 0x00080000, 0x02080000, 0x02000008,
+        0x00082000, 0x00002008, 0x02002008, 0x02080000,
+        0x00000008, 0x02082000, 0x00082008, 0x00000000,
+        0x02000000, 0x02080008, 0x00002000, 0x00082008,
+    ]
+
+    LUT_A1 = [
+        0x08000004, 0x00020004, 0x00000000, 0x08020200,
+        0x00020004, 0x00000200, 0x08000204, 0x00020000,
+        0x00000204, 0x08020204, 0x00020200, 0x08000000,
+        0x08000200, 0x08000004, 0x08020000, 0x00020204,
+        0x00020000, 0x08000204, 0x08020004, 0x00000000,
+        0x00000200, 0x00000004, 0x08020200, 0x08020004,
+        0x08020204, 0x08020000, 0x08000000, 0x00000204,
+        0x00000004, 0x00020200, 0x00020204, 0x08000200,
+        0x00000204, 0x08000000, 0x08000200, 0x00020204,
+        0x08020200, 0x00020004, 0x00000000, 0x08000200,
+        0x08000000, 0x00000200, 0x08020004, 0x00020000,
+        0x00020004, 0x08020204, 0x00020200, 0x00000004,
+        0x08020204, 0x00020200, 0x00020000, 0x08000204,
+        0x08000004, 0x08020000, 0x00020204, 0x00000000,
+        0x00000200, 0x08000004, 0x08000204, 0x08020200,
+        0x08020000, 0x00000204, 0x00000004, 0x08020004,
+    ]
+
+    LUT_A2 = [
+        0x80040100, 0x01000100, 0x80000000, 0x81040100,
+        0x00000000, 0x01040000, 0x81000100, 0x80040000,
+        0x01040100, 0x81000000, 0x01000000, 0x80000100,
+        0x81000000, 0x80040100, 0x00040000, 0x01000000,
+        0x81040000, 0x00040100, 0x00000100, 0x80000000,
+        0x00040100, 0x81000100, 0x01040000, 0x00000100,
+        0x80000100, 0x00000000, 0x80040000, 0x01040100,
+        0x01000100, 0x81040000, 0x81040100, 0x00040000,
+        0x81040000, 0x80000100, 0x00040000, 0x81000000,
+        0x00040100, 0x01000100, 0x80000000, 0x01040000,
+        0x81000100, 0x00000000, 0x00000100, 0x80040000,
+        0x00000000, 0x81040000, 0x01040100, 0x00000100,
+        0x01000000, 0x81040100, 0x80040100, 0x00040000,
+        0x81040100, 0x80000000, 0x01000100, 0x80040100,
+        0x80040000, 0x00040100, 0x01040000, 0x81000100,
+        0x80000100, 0x01000000, 0x81000000, 0x01040100,
+    ]
+
+    LUT_A3 = [
+        0x04010801, 0x00000000, 0x00010800, 0x04010000,
+        0x04000001, 0x00000801, 0x04000800, 0x00010800,
+        0x00000800, 0x04010001, 0x00000001, 0x04000800,
+        0x00010001, 0x04010800, 0x04010000, 0x00000001,
+        0x00010000, 0x04000801, 0x04010001, 0x00000800,
+        0x00010801, 0x04000000, 0x00000000, 0x00010001,
+        0x04000801, 0x00010801, 0x04010800, 0x04000001,
+        0x04000000, 0x00010000, 0x00000801, 0x04010801,
+        0x00010001, 0x04010800, 0x04000800, 0x00010801,
+        0x04010801, 0x00010001, 0x04000001, 0x00000000,
+        0x04000000, 0x00000801, 0x00010000, 0x04010001,
+        0x00000800, 0x04000000, 0x00010801, 0x04000801,
+        0x04010800, 0x00000800, 0x00000000, 0x04000001,
+        0x00000001, 0x04010801, 0x00010800, 0x04010000,
+        0x04010001, 0x00010000, 0x00000801, 0x04000800,
+        0x04000801, 0x00000001, 0x04010000, 0x00010800,
+    ]
+
+    LUT_B0 = [
+        0x00000400, 0x00000020, 0x00100020, 0x40100000,
+        0x40100420, 0x40000400, 0x00000420, 0x00000000,
+        0x00100000, 0x40100020, 0x40000020, 0x00100400,
+        0x40000000, 0x00100420, 0x00100400, 0x40000020,
+        0x40100020, 0x00000400, 0x40000400, 0x40100420,
+        0x00000000, 0x00100020, 0x40100000, 0x00000420,
+        0x40100400, 0x40000420, 0x00100420, 0x40000000,
+        0x40000420, 0x40100400, 0x00000020, 0x00100000,
+        0x40000420, 0x00100400, 0x40100400, 0x40000020,
+        0x00000400, 0x00000020, 0x00100000, 0x40100400,
+        0x40100020, 0x40000420, 0x00000420, 0x00000000,
+        0x00000020, 0x40100000, 0x40000000, 0x00100020,
+        0x00000000, 0x40100020, 0x00100020, 0x00000420,
+        0x40000020, 0x00000400, 0x40100420, 0x00100000,
+        0x00100420, 0x40000000, 0x40000400, 0x40100420,
+        0x40100000, 0x00100420, 0x00100400, 0x40000400,
+    ]
+
+    LUT_B1 = [
+        0x00800000, 0x00001000, 0x00000040, 0x00801042,
+        0x00801002, 0x00800040, 0x00001042, 0x00801000,
+        0x00001000, 0x00000002, 0x00800002, 0x00001040,
+        0x00800042, 0x00801002, 0x00801040, 0x00000000,
+        0x00001040, 0x00800000, 0x00001002, 0x00000042,
+        0x00800040, 0x00001042, 0x00000000, 0x00800002,
+        0x00000002, 0x00800042, 0x00801042, 0x00001002,
+        0x00801000, 0x00000040, 0x00000042, 0x00801040,
+        0x00801040, 0x00800042, 0x00001002, 0x00801000,
+        0x00001000, 0x00000002, 0x00800002, 0x00800040,
+        0x00800000, 0x00001040, 0x00801042, 0x00000000,
+        0x00001042, 0x00800000, 0x00000040, 0x00001002,
+        0x00800042, 0x00000040, 0x00000000, 0x00801042,
+        0x00801002, 0x00801040, 0x00000042, 0x00001000,
+        0x00001040, 0x00801002, 0x00800040, 0x00000042,
+        0x00000002, 0x00001042, 0x00801000, 0x00800002,
+    ]
+
+    LUT_B2 = [
+        0x10400000, 0x00404010, 0x00000010, 0x10400010,
+        0x10004000, 0x00400000, 0x10400010, 0x00004010,
+        0x00400010, 0x00004000, 0x00404000, 0x10000000,
+        0x10404010, 0x10000010, 0x10000000, 0x10404000,
+        0x00000000, 0x10004000, 0x00404010, 0x00000010,
+        0x10000010, 0x10404010, 0x00004000, 0x10400000,
+        0x10404000, 0x00400010, 0x10004010, 0x00404000,
+        0x00004010, 0x00000000, 0x00400000, 0x10004010,
+        0x00404010, 0x00000010, 0x10000000, 0x00004000,
+        0x10000010, 0x10004000, 0x00404000, 0x10400010,
+        0x00000000, 0x00404010, 0x00004010, 0x10404000,
+        0x10004000, 0x00400000, 0x10404010, 0x10000000,
+        0x10004010, 0x10400000, 0x00400000, 0x10404010,
+        0x00004000, 0x00400010, 0x10400010, 0x00004010,
+        0x00400010, 0x00000000, 0x10404000, 0x10000010,
+        0x10400000, 0x10004010, 0x00000010, 0x00404000,
+    ]
+
+    LUT_B3 = [
+        0x00208080, 0x00008000, 0x20200000, 0x20208080,
+        0x00200000, 0x20008080, 0x20008000, 0x20200000,
+        0x20008080, 0x00208080, 0x00208000, 0x20000080,
+        0x20200080, 0x00200000, 0x00000000, 0x20008000,
+        0x00008000, 0x20000000, 0x00200080, 0x00008080,
+        0x20208080, 0x00208000, 0x20000080, 0x00200080,
+        0x20000000, 0x00000080, 0x00008080, 0x20208000,
+        0x00000080, 0x20200080, 0x20208000, 0x00000000,
+        0x00000000, 0x20208080, 0x00200080, 0x20008000,
+        0x00208080, 0x00008000, 0x20000080, 0x00200080,
+        0x20208000, 0x00000080, 0x00008080, 0x20200000,
+        0x20008080, 0x20000000, 0x20200000, 0x00208000,
+        0x20208080, 0x00008080, 0x00208000, 0x20200080,
+        0x00200000, 0x20000080, 0x20008000, 0x00000000,
+        0x00008000, 0x00200000, 0x20200080, 0x00208080,
+        0x20000000, 0x20208000, 0x00000080, 0x20008080,
+    ]
+
+    VALID_CHARS = "0123456789ABCDEFGHJKLMNPRSTUWXYZ"
+    CONV_CHARS = {
+        "I": "1",
+        "O": "0",
+    }
+
+    @staticmethod
+    def __type_from_cardid(cardid: str) -> int:
+        if cardid[:2].upper() == 'E0':
+            return 1
+        if cardid[:2].upper() == '01':
+            return 2
+        raise CardCipherException('Unrecognized card type')
+
+    @staticmethod
+    def encode(cardid: str) -> str:
+        """
+        Given a card ID as stored on a card (Usually starting with E004), convert
+        it to the card string as shown on the back of the card.
+
+        Parameters:
+            cardid - 16 digit card ID (hex values stored as string).
+
+        Returns:
+            String representation of the card string.
+        """
+        if len(cardid) != 16:
+            raise CardCipherException(
+                'Expected 16-character card ID, got {}'.format(len(cardid)),
+            )
+
+        cardint = [int(cardid[i:(i + 2)], 16) for i in range(0, len(cardid), 2)]
+
+        # Reverse bytes
+        reverse = [0] * 8
+        for i in range(0, 8):
+            reverse[7 - i] = cardint[i]
+
+        # Encipher
+        ciphered = CardCipher.__encode(bytes(reverse))
+
+        # Convert 8 x 8 bit bytes into 13 x 5 bit groups (sort of)
+        bits = [0] * 65
+        for i in range(0, 64):
+            bits[i] = (ciphered[i >> 3] >> (~i & 7)) & 1
+
+        groups = [0] * 16
+        for i in range(0, 13):
+            groups[i] = (
+                (bits[i * 5 + 0] << 4) |
+                (bits[i * 5 + 1] << 3) |
+                (bits[i * 5 + 2] << 2) |
+                (bits[i * 5 + 3] << 1) |
+                (bits[i * 5 + 4] << 0)
+            )
+
+        # Smear 13 groups out into 14 groups
+        groups[13] = 1
+        groups[0] ^= CardCipher.__type_from_cardid(cardid)
+
+        for i in range(0, 14):
+            groups[i] ^= groups[i - 1]
+
+        # Scheme field is 1 for old-style, 2 for felica cards
+        groups[14] = CardCipher.__type_from_cardid(cardid)
+        groups[15] = CardCipher.__checksum(groups)
+
+        # Convert to chars and return
+        return ''.join([CardCipher.VALID_CHARS[i] for i in groups])
+
+    @staticmethod
+    def decode(cardid: str) -> str:
+        """
+        Given a card string as shown on the back of the card, return the card ID
+        as stored on the card itself. Does some sanitization to remove dashes,
+        spaces and convert confusing characters (1, L and 0, O) before converting.
+
+        Parameters:
+            cardid - String representation of the card string.
+
+        Returns:
+            16 digit card ID (hex values stored as string).
+        """
+        # First sanitize the input
+        cardid = cardid.replace(' ', '')
+        cardid = cardid.replace('-', '')
+        cardid = cardid.upper()
+        for c in CardCipher.CONV_CHARS:
+            cardid = cardid.replace(c, CardCipher.CONV_CHARS[c])
+
+        if len(cardid) != 16:
+            raise CardCipherException(
+                'Expected 16-character card ID, got {}'.format(len(cardid)),
+            )
+
+        for c in cardid:
+            if c not in CardCipher.VALID_CHARS:
+                raise CardCipherException(
+                    'Got unexpected character {} in card ID'.format(c),
+                )
+
+        # Convert chars to groups
+        groups = [0] * 16
+
+        for i in range(0, 16):
+            for j in range(0, 32):
+                if cardid[i] == CardCipher.VALID_CHARS[j]:
+                    groups[i] = j
+                    break
+
+        # Verify scheme and checksum
+        if (groups[14] != 1 and groups[14] != 2):
+            raise CardCipherException(
+                "Unrecognized card type"
+            )
+        if groups[15] != CardCipher.__checksum(groups):
+            raise CardCipherException(
+                "Bad card number"
+            )
+
+        # Un-smear 14 fields back into 13
+        for i in range(13, 0, -1):
+            groups[i] ^= groups[i - 1]
+        groups[0] ^= groups[14]
+
+        # Explode groups into bits
+        bits = [0] * 64
+
+        for i in range(0, 64):
+            bits[i] = (groups[int(i / 5)] >> (4 - (i % 5))) & 1
+
+        # Re-pack bits into eight bytes
+        ciphered = [0] * 8
+
+        for i in range(0, 64):
+            ciphered[int(i / 8)] |= bits[i] << (~i & 7)
+
+        # Decipher and reverse
+        deciphered = CardCipher.__decode(bytes(ciphered))
+        reverse = [0] * 8
+        for i in range(0, 8):
+            reverse[i] = deciphered[7 - i]
+
+        def tohex(x: int) -> str:
+            h = hex(x)[2:]
+            while len(h) < 2:
+                h = '0' + h
+            return h.upper()
+
+        # Convert to a string, verify we have the same type
+        finalvalue = ''.join([tohex(v) for v in reverse])
+        if groups[14] != CardCipher.__type_from_cardid(finalvalue):
+            raise CardCipherException(
+                "Card type mismatch"
+            )
+        return finalvalue
+
+    @staticmethod
+    def __checksum(data: List[int]) -> int:
+        checksum = 0
+
+        for i in range(0, 15):
+            checksum += (i % 3 + 1) * data[i]
+
+        while checksum >= 0x20:
+            checksum = (checksum & 0x1F) + (checksum >> 5)
+
+        return checksum
+
+    @staticmethod
+    def __encode(inbytes: bytes) -> bytes:
+        if len(inbytes) != 8:
+            raise CardCipherException(
+                'Expected 8-byte input, got {}'.format(len(inbytes)),
+            )
+
+        inp = [b for b in inbytes]
+        out = [0] * 8
+
+        CardCipher.__from_int(out, CardCipher.__operatorA(0x00, CardCipher.__to_int(inp)))
+        CardCipher.__from_int(out, CardCipher.__operatorB(0x20, CardCipher.__to_int(out)))
+        CardCipher.__from_int(out, CardCipher.__operatorA(0x40, CardCipher.__to_int(out)))
+
+        return bytes(out)
+
+    @staticmethod
+    def __decode(inbytes: bytes) -> bytes:
+        if len(inbytes) != 8:
+            raise CardCipherException(
+                'Expected 8-byte input, got {}'.format(len(inbytes)),
+            )
+
+        inp = [b for b in inbytes]
+        out = [0] * 8
+
+        CardCipher.__from_int(out, CardCipher.__operatorB(0x40, CardCipher.__to_int(inp)))
+        CardCipher.__from_int(out, CardCipher.__operatorA(0x20, CardCipher.__to_int(out)))
+        CardCipher.__from_int(out, CardCipher.__operatorB(0x00, CardCipher.__to_int(out)))
+
+        return bytes(out)
+
+    @staticmethod
+    def __to_int(data: List[int]) -> int:
+        inX = (
+            (data[0] & 0xFF) |
+            ((data[1] & 0xFF) << 8) |
+            ((data[2] & 0xFF) << 16) |
+            ((data[3] & 0xFF) << 24)
+        )
+
+        inY = (
+            (data[4] & 0xFF) |
+            ((data[5] & 0xFF) << 8) |
+            ((data[6] & 0xFF) << 16) |
+            ((data[7] & 0xFF) << 24)
+        )
+
+        v7 = ((((inX ^ (inY >> 4)) & 0xF0F0F0F) << 4) ^ inY) & 0xFFFFFFFF
+        v8 = (((inX ^ (inY >> 4)) & 0xF0F0F0F) ^ inX) & 0xFFFFFFFF
+
+        v9 = ((v7 ^ (v8 >> 16))) & 0x0000FFFF
+        v10 = (((v7 ^ (v8 >> 16)) << 16) ^ v8) & 0xFFFFFFFF
+
+        v11 = (v9 ^ v7) & 0xFFFFFFFF
+        v12 = (v10 ^ (v11 >> 2)) & 0x33333333
+        v13 = (v11 ^ (v12 << 2)) & 0xFFFFFFFF
+
+        v14 = (v12 ^ v10) & 0xFFFFFFFF
+        v15 = (v13 ^ (v14 >> 8)) & 0x00FF00FF
+        v16 = (v14 ^ (v15 << 8)) & 0xFFFFFFFF
+
+        v17 = CardCipher.__ror(v15 ^ v13, 1)
+        v18 = (v16 ^ v17) & 0x55555555
+
+        v3 = CardCipher.__ror(v18 ^ v16, 1)
+        v4 = (v18 ^ v17) & 0xFFFFFFFF
+
+        return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)
+
+    @staticmethod
+    def __from_int(data: List[int], state: int) -> None:
+        v3 = (state >> 32) & 0xFFFFFFFF
+        v4 = state & 0xFFFFFFFF
+
+        v22 = CardCipher.__ror(v4, 31)
+        v23 = (v3 ^ v22) & 0x55555555
+        v24 = (v23 ^ v22) & 0xFFFFFFFF
+
+        v25 = CardCipher.__ror(v23 ^ v3, 31)
+        v26 = (v25 ^ (v24 >> 8)) & 0x00FF00FF
+        v27 = (v24 ^ (v26 << 8)) & 0xFFFFFFFF
+
+        v28 = (v26 ^ v25) & 0xFFFFFFFF
+        v29 = ((v28 >> 2) ^ v27) & 0x33333333
+        v30 = ((v29 << 2) ^ v28) & 0xFFFFFFFF
+
+        v31 = (v29 ^ v27) & 0xFFFFFFFF
+        v32 = (v30 ^ (v31 >> 16)) & 0x0000FFFF
+        v33 = (v31 ^ (v32 << 16)) & 0xFFFFFFFF
+
+        v34 = (v32 ^ v30) & 0xFFFFFFFF
+        v35 = (v33 ^ (v34 >> 4)) & 0xF0F0F0F
+
+        outY = ((v35 << 4) ^ v34) & 0xFFFFFFFF
+        outX = (v35 ^ v33) & 0xFFFFFFFF
+
+        data[0] = outX & 0xFF
+        data[1] = (outX >> 8) & 0xFF
+        data[2] = (outX >> 16) & 0xFF
+        data[3] = (outX >> 24) & 0xFF
+        data[4] = outY & 0xFF
+        data[5] = (outY >> 8) & 0xFF
+        data[6] = (outY >> 16) & 0xFF
+        data[7] = (outY >> 24) & 0xFF
+
+    @staticmethod
+    def __operatorA(off: int, state: int) -> int:
+        v3 = (state >> 32) & 0xFFFFFFFF
+        v4 = state & 0xFFFFFFFF
+
+        for i in range(0, 32, 4):
+            v20 = CardCipher.__ror(v3 ^ CardCipher.KEY[off + i + 1], 28)
+
+            v4 ^= (
+                CardCipher.LUT_B0[(v20 >> 26) & 0x3F] ^
+                CardCipher.LUT_B1[(v20 >> 18) & 0x3F] ^
+                CardCipher.LUT_B2[(v20 >> 10) & 0x3F] ^
+                CardCipher.LUT_B3[(v20 >> 2) & 0x3F] ^
+                CardCipher.LUT_A0[((v3 ^ CardCipher.KEY[off + i]) >> 26) & 0x3F] ^
+                CardCipher.LUT_A1[((v3 ^ CardCipher.KEY[off + i]) >> 18) & 0x3F] ^
+                CardCipher.LUT_A2[((v3 ^ CardCipher.KEY[off + i]) >> 10) & 0x3F] ^
+                CardCipher.LUT_A3[((v3 ^ CardCipher.KEY[off + i]) >> 2) & 0x3F]
+            )
+
+            v21 = CardCipher.__ror(v4 ^ CardCipher.KEY[off + i + 3], 28)
+
+            v3 ^= (
+                CardCipher.LUT_B0[(v21 >> 26) & 0x3F] ^
+                CardCipher.LUT_B1[(v21 >> 18) & 0x3F] ^
+                CardCipher.LUT_B2[(v21 >> 10) & 0x3F] ^
+                CardCipher.LUT_B3[(v21 >> 2) & 0x3F] ^
+                CardCipher.LUT_A0[((v4 ^ CardCipher.KEY[off + i + 2]) >> 26) & 0x3F] ^
+                CardCipher.LUT_A1[((v4 ^ CardCipher.KEY[off + i + 2]) >> 18) & 0x3F] ^
+                CardCipher.LUT_A2[((v4 ^ CardCipher.KEY[off + i + 2]) >> 10) & 0x3F] ^
+                CardCipher.LUT_A3[((v4 ^ CardCipher.KEY[off + i + 2]) >> 2) & 0x3F]
+            )
+
+        return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)
+
+    @staticmethod
+    def __operatorB(off: int, state: int) -> int:
+        v3 = (state >> 32) & 0xFFFFFFFF
+        v4 = state & 0xFFFFFFFF
+
+        for i in range(0, 32, 4):
+            v20 = CardCipher.__ror(v3 ^ CardCipher.KEY[off + 31 - i], 28)
+
+            v4 ^= (
+                CardCipher.LUT_A0[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 26) & 0x3F] ^
+                CardCipher.LUT_A1[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 18) & 0x3F] ^
+                CardCipher.LUT_A2[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 10) & 0x3F] ^
+                CardCipher.LUT_A3[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 2) & 0x3F] ^
+                CardCipher.LUT_B0[(v20 >> 26) & 0x3F] ^
+                CardCipher.LUT_B1[(v20 >> 18) & 0x3F] ^
+                CardCipher.LUT_B2[(v20 >> 10) & 0x3F] ^
+                CardCipher.LUT_B3[(v20 >> 2) & 0x3F]
+            )
+
+            v21 = CardCipher.__ror(v4 ^ CardCipher.KEY[off + 29 - i], 28)
+
+            v3 ^= (
+                CardCipher.LUT_A0[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 26) & 0x3F] ^
+                CardCipher.LUT_A1[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 18) & 0x3F] ^
+                CardCipher.LUT_A2[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 10) & 0x3F] ^
+                CardCipher.LUT_A3[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 2) & 0x3F] ^
+                CardCipher.LUT_B0[(v21 >> 26) & 0x3F] ^
+                CardCipher.LUT_B1[(v21 >> 18) & 0x3F] ^
+                CardCipher.LUT_B2[(v21 >> 10) & 0x3F] ^
+                CardCipher.LUT_B3[(v21 >> 2) & 0x3F]
+            )
+
+        return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)
+
+    @staticmethod
+    def __ror(val: int, amount: int) -> int:
+        return ((val << (32 - amount)) & 0xFFFFFFFF) | ((val >> amount) & 0xFFFFFFFF)
diff --git a/bemani/common/constants.py b/bemani/common/constants.py
new file mode 100644
index 0000000..7cbdb0b
--- /dev/null
+++ b/bemani/common/constants.py
@@ -0,0 +1,253 @@
+class GameConstants:
+    BISHI_BASHI = 'bishi'
+    DANCE_EVOLUTION = 'danevo'
+    DDR = 'ddr'
+    IIDX = 'iidx'
+    JUBEAT = 'jubeat'
+    MUSECA = 'museca'
+    POPN_MUSIC = 'pnm'
+    REFLEC_BEAT = 'reflec'
+    SDVX = 'sdvx'
+
+
+class VersionConstants:
+    BISHI_BASHI_TSBB = 1
+
+    DDR_1STMIX = 1
+    DDR_2NDMIX = 2
+    DDR_3RDMIX = 3
+    DDR_4THMIX = 4
+    DDR_5THMIX = 5
+    DDR_6THMIX = 6
+    DDR_7THMIX = 7
+    DDR_EXTREME = 8
+    DDR_SUPERNOVA = 9
+    DDR_SUPERNOVA_2 = 10
+    DDR_X = 11
+    DDR_X2 = 12
+    DDR_X3_VS_2NDMIX = 13
+    DDR_2013 = 14
+    DDR_2014 = 15
+    DDR_ACE = 16
+    DDR_A20 = 17
+
+    IIDX = 1
+    IIDX_2ND_STYLE = 2
+    IIDX_3RD_STYLE = 3
+    IIDX_4TH_STYLE = 4
+    IIDX_5TH_STYLE = 5
+    IIDX_6TH_STYLE = 6
+    IIDX_7TH_STYLE = 7
+    IIDX_8TH_STYLE = 8
+    IIDX_9TH_STYLE = 9
+    IIDX_10TH_STYLE = 10
+    IIDX_RED = 11
+    IIDX_HAPPY_SKY = 12
+    IIDX_DISTORTED = 13
+    IIDX_GOLD = 14
+    IIDX_DJ_TROOPERS = 15
+    IIDX_EMPRESS = 16
+    IIDX_SIRIUS = 17
+    IIDX_RESORT_ANTHEM = 18
+    IIDX_LINCLE = 19
+    IIDX_TRICORO = 20
+    IIDX_SPADA = 21
+    IIDX_PENDUAL = 22
+    IIDX_COPULA = 23
+    IIDX_SINOBUZ = 24
+    IIDX_CANNON_BALLERS = 25
+
+    JUBEAT = 1
+    JUBEAT_RIPPLES = 2
+    JUBEAT_RIPPLES_APPEND = 3
+    JUBEAT_KNIT = 4
+    JUBEAT_KNIT_APPEND = 5
+    JUBEAT_COPIOUS = 6
+    JUBEAT_COPIOUS_APPEND = 7
+    JUBEAT_SAUCER = 8
+    JUBEAT_SAUCER_FULFILL = 9
+    JUBEAT_PROP = 10
+    JUBEAT_QUBELL = 11
+    JUBEAT_CLAN = 12
+    JUBEAT_FESTO = 13
+
+    MUSECA = 1
+    MUSECA_1_PLUS = 2
+
+    POPN_MUSIC = 1
+    POPN_MUSIC_2 = 2
+    POPN_MUSIC_3 = 3
+    POPN_MUSIC_4 = 4
+    POPN_MUSIC_5 = 5
+    POPN_MUSIC_6 = 6
+    POPN_MUSIC_7 = 7
+    POPN_MUSIC_8 = 8
+    POPN_MUSIC_9 = 9
+    POPN_MUSIC_10 = 10
+    POPN_MUSIC_11 = 11
+    POPN_MUSIC_IROHA = 12
+    POPN_MUSIC_CARNIVAL = 13
+    POPN_MUSIC_FEVER = 14
+    POPN_MUSIC_ADVENTURE = 15
+    POPN_MUSIC_PARTY = 16
+    POPN_MUSIC_THE_MOVIE = 17
+    POPN_MUSIC_SENGOKU_RETSUDEN = 18
+    POPN_MUSIC_TUNE_STREET = 19
+    POPN_MUSIC_FANTASIA = 20
+    POPN_MUSIC_SUNNY_PARK = 21
+    POPN_MUSIC_LAPISTORIA = 22
+    POPN_MUSIC_ECLALE = 23
+    POPN_MUSIC_USANEKO = 24
+    POPN_MUSIC_PEACE = 25
+
+    REFLEC_BEAT = 1
+    REFLEC_BEAT_LIMELIGHT = 2
+    REFLEC_BEAT_COLETTE = 3
+    REFLEC_BEAT_GROOVIN = 4
+    REFLEC_BEAT_VOLZZA = 5
+    REFLEC_BEAT_VOLZZA_2 = 6
+    REFLEC_BEAT_REFLESIA = 7
+
+    SDVX_BOOTH = 1
+    SDVX_INFINITE_INFECTION = 2
+    SDVX_GRAVITY_WARS = 3
+    SDVX_HEAVENLY_HAVEN = 4
+
+
+class APIConstants:
+    ID_TYPE_SERVER = 'server'
+    ID_TYPE_CARD = 'card'
+    ID_TYPE_SONG = 'song'
+    ID_TYPE_INSTANCE = 'instance'
+
+
+class DBConstants:
+    # When adding new game series, I try to make sure that constants
+    # go in order, and have a difference of 100 between them. This is
+    # so I can promote lamps/scores/etc by using a simple "max", while
+    # still allowing for new game versions to insert new constants anywhere
+    # in the lineup. You'll notice a few areas where constants go up by
+    # non-100. This is because a new game came out in this series after
+    # existing scores were in production, so constants for new grades/lamps
+    # had to be snuck in. The actual constant doesn't matter as long as they
+    # go in order, so this works out nicely.
+
+    # Its up to various games to map the in-game constant to these DB
+    # constants. Most games will implement a pair of functions that takes
+    # one of these values and spits out the game-specific constant, and
+    # vice versa. This keeps us individual game agnostic and allows us to
+    # react easily to renumberings and constant insertions. These constants
+    # will only be found in the DB itself, as well as used on the frontend
+    # to display various general information about scores.
+
+    OMNIMIX_VERSION_BUMP = 10000
+
+    DDR_HALO_NONE = 100
+    DDR_HALO_GOOD_FULL_COMBO = 200
+    DDR_HALO_GREAT_FULL_COMBO = 300
+    DDR_HALO_PERFECT_FULL_COMBO = 400
+    DDR_HALO_MARVELOUS_FULL_COMBO = 500
+    DDR_RANK_E = 100
+    DDR_RANK_D = 200
+    DDR_RANK_D_PLUS = 233
+    DDR_RANK_C_MINUS = 266
+    DDR_RANK_C = 300
+    DDR_RANK_C_PLUS = 333
+    DDR_RANK_B_MINUS = 366
+    DDR_RANK_B = 400
+    DDR_RANK_B_PLUS = 433
+    DDR_RANK_A_MINUS = 466
+    DDR_RANK_A = 500
+    DDR_RANK_A_PLUS = 533
+    DDR_RANK_AA_MINUS = 566
+    DDR_RANK_AA = 600
+    DDR_RANK_AA_PLUS = 650
+    DDR_RANK_AAA = 700
+
+    IIDX_CLEAR_STATUS_NO_PLAY = 50
+    IIDX_CLEAR_STATUS_FAILED = 100
+    IIDX_CLEAR_STATUS_ASSIST_CLEAR = 200
+    IIDX_CLEAR_STATUS_EASY_CLEAR = 300
+    IIDX_CLEAR_STATUS_CLEAR = 400
+    IIDX_CLEAR_STATUS_HARD_CLEAR = 500
+    IIDX_CLEAR_STATUS_EX_HARD_CLEAR = 600
+    IIDX_CLEAR_STATUS_FULL_COMBO = 700
+    IIDX_DAN_RANK_7_KYU = 100
+    IIDX_DAN_RANK_6_KYU = 200
+    IIDX_DAN_RANK_5_KYU = 300
+    IIDX_DAN_RANK_4_KYU = 400
+    IIDX_DAN_RANK_3_KYU = 500
+    IIDX_DAN_RANK_2_KYU = 600
+    IIDX_DAN_RANK_1_KYU = 700
+    IIDX_DAN_RANK_1_DAN = 800
+    IIDX_DAN_RANK_2_DAN = 900
+    IIDX_DAN_RANK_3_DAN = 1000
+    IIDX_DAN_RANK_4_DAN = 1100
+    IIDX_DAN_RANK_5_DAN = 1200
+    IIDX_DAN_RANK_6_DAN = 1300
+    IIDX_DAN_RANK_7_DAN = 1400
+    IIDX_DAN_RANK_8_DAN = 1500
+    IIDX_DAN_RANK_9_DAN = 1600
+    IIDX_DAN_RANK_10_DAN = 1700
+    IIDX_DAN_RANK_CHUDEN = 1800
+    IIDX_DAN_RANK_KAIDEN = 1900
+
+    JUBEAT_PLAY_MEDAL_FAILED = 100
+    JUBEAT_PLAY_MEDAL_CLEARED = 200
+    JUBEAT_PLAY_MEDAL_NEARLY_FULL_COMBO = 300
+    JUBEAT_PLAY_MEDAL_FULL_COMBO = 400
+    JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT = 500
+    JUBEAT_PLAY_MEDAL_EXCELLENT = 600
+
+    MUSECA_GRADE_DEATH = 100        # 没
+    MUSECA_GRADE_POOR = 200         # 拙
+    MUSECA_GRADE_MEDIOCRE = 300     # 凡
+    MUSECA_GRADE_GOOD = 400         # 佳
+    MUSECA_GRADE_GREAT = 500        # 良
+    MUSECA_GRADE_EXCELLENT = 600    # 優
+    MUSECA_GRADE_SUPERB = 700       # 秀
+    MUSECA_GRADE_MASTERPIECE = 800  # 傑
+    MUSECA_GRADE_PERFECT = 900      # 傑
+    MUSECA_CLEAR_TYPE_FAILED = 100
+    MUSECA_CLEAR_TYPE_CLEARED = 200
+    MUSECA_CLEAR_TYPE_FULL_COMBO = 300
+
+    POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED = 100
+    POPN_MUSIC_PLAY_MEDAL_DIAMOND_FAILED = 200
+    POPN_MUSIC_PLAY_MEDAL_STAR_FAILED = 300
+    POPN_MUSIC_PLAY_MEDAL_EASY_CLEAR = 400
+    POPN_MUSIC_PLAY_MEDAL_CIRCLE_CLEARED = 500
+    POPN_MUSIC_PLAY_MEDAL_DIAMOND_CLEARED = 600
+    POPN_MUSIC_PLAY_MEDAL_STAR_CLEARED = 700
+    POPN_MUSIC_PLAY_MEDAL_CIRCLE_FULL_COMBO = 800
+    POPN_MUSIC_PLAY_MEDAL_DIAMOND_FULL_COMBO = 900
+    POPN_MUSIC_PLAY_MEDAL_STAR_FULL_COMBO = 1000
+    POPN_MUSIC_PLAY_MEDAL_PERFECT = 1100
+
+    REFLEC_BEAT_CLEAR_TYPE_NO_PLAY = 100
+    REFLEC_BEAT_CLEAR_TYPE_FAILED = 200
+    REFLEC_BEAT_CLEAR_TYPE_CLEARED = 300
+    REFLEC_BEAT_CLEAR_TYPE_HARD_CLEARED = 400
+    REFLEC_BEAT_CLEAR_TYPE_S_HARD_CLEARED = 500
+    REFLEC_BEAT_COMBO_TYPE_NONE = 100
+    REFLEC_BEAT_COMBO_TYPE_ALMOST_COMBO = 200
+    REFLEC_BEAT_COMBO_TYPE_FULL_COMBO = 300
+    REFLEC_BEAT_COMBO_TYPE_FULL_COMBO_ALL_JUST = 400
+
+    SDVX_CLEAR_TYPE_NO_PLAY = 50
+    SDVX_CLEAR_TYPE_FAILED = 100
+    SDVX_CLEAR_TYPE_CLEAR = 200
+    SDVX_CLEAR_TYPE_HARD_CLEAR = 300
+    SDVX_CLEAR_TYPE_ULTIMATE_CHAIN = 400
+    SDVX_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN = 500
+    SDVX_GRADE_NO_PLAY = 100
+    SDVX_GRADE_D = 200
+    SDVX_GRADE_C = 300
+    SDVX_GRADE_B = 400
+    SDVX_GRADE_A = 500
+    SDVX_GRADE_A_PLUS = 550
+    SDVX_GRADE_AA = 600
+    SDVX_GRADE_AA_PLUS = 650
+    SDVX_GRADE_AAA = 700
+    SDVX_GRADE_AAA_PLUS = 800
+    SDVX_GRADE_S = 900
diff --git a/bemani/common/http.py b/bemani/common/http.py
new file mode 100644
index 0000000..fe8e75d
--- /dev/null
+++ b/bemani/common/http.py
@@ -0,0 +1,157 @@
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class HTTP:
+    @staticmethod
+    def parse(data: bytes, request: bool=False, response: bool=False) -> Optional[Dict[str, Any]]:
+        """
+        A very lazy and hastily coded HTTP parser.
+
+        Assumes that data is a valid HTTP stream and just tokenizes relevant pieces.
+        This can probably be made far more robust by scrapping it and using flask or
+        another real parser. However, it does the job.
+
+        Parameters:
+            data - A string blob that represents an HTTP request
+            request - Set to true if this is expected to be a request
+            response - Set to true if this is expected to be a response
+
+        Returns a dictionary containing:
+            version - HTTP version
+            headers - Dictionary of headers keyed by header name
+            data - Post body in unmolested form
+            uri - Requested URI when this is a request
+            method - Requested method on URI when this is a request
+            code - HTTP response code when this is a response
+        """
+        try:
+            # Try to get the headers and post body as two separate elemenst
+            binary_headers, data = data.split(b"\r\n\r\n", 1)
+        except ValueError:
+            # Can't even separate header from post body
+            return None
+
+        # Split headers individually
+        headerlist = binary_headers.split(b"\r\n")
+
+        try:
+            if request:
+                # Remove the first header as this is the HTTP request
+                method, uri, version = headerlist.pop(0).split(b' ', 2)
+            elif response:
+                # Remove the first header as this is the HTTP response
+                version, code, error = headerlist.pop(0).split(b' ', 2)
+            else:
+                raise Exception("Logic error!")
+        except ValueError:
+            # Can't parse the headers returned
+            return None
+
+        headers: Dict[str, str] = {}
+        preserved: List[Tuple[str, str]] = []
+
+        # This is lazy because we can have multiple values, but whatever, it works
+        for header in headerlist:
+            name, info = header.split(b":", 1)
+            key = name.decode('ascii').lower()
+            value = info.decode('ascii').strip()
+            headers[key] = value
+            preserved.append((key, value))
+
+        # Cap post body to length if we have a content-length header
+        if 'content-length' in headers:
+            data = data[:int(headers['content-length'])]
+            valid = len(data) == int(headers['content-length'])
+        elif 'transfer-encoding' in headers and headers['transfer-encoding'] == 'chunked':
+            real_data = b''
+
+            while True:
+                try:
+                    size_bytes, rest = data.split(b"\r\n", 1)
+                except ValueError:
+                    # Not enough values to unpack
+                    size_bytes = b'0'
+
+                size = int(size_bytes, 16)
+
+                if size == 0:
+                    # End of chunks
+                    break
+
+                # Grab the real data
+                real_data = real_data + rest[:size]
+
+                # Skip past data and \r\n
+                data = rest[(size + 2):]
+
+            data = real_data
+            valid = True
+        else:
+            valid = True
+
+        if request:
+            return {
+                'method': method.decode('ascii').lower(),
+                'uri': uri.decode('ascii'),
+                'version': version.decode('ascii'),
+                'headers': headers,
+                'preserved_headers': preserved,
+                'data': data,
+                'valid': valid,
+            }
+        elif response:
+            return {
+                'code': code.decode('ascii'),
+                'version': version.decode('ascii'),
+                'error': error.decode('ascii'),
+                'headers': headers,
+                'preserved_headers': preserved,
+                'data': data,
+                'valid': valid,
+            }
+        else:
+            return None
+
+    @staticmethod
+    def generate(parsed_headers: Dict[str, Any], data: bytes, request: bool=False, response: bool=False) -> bytes:
+        """
+        A very lazy and hastily coded HTTP packet generator.
+
+        Parameters:
+            parsed_headers - A dictionary of headers to include
+            data - Bytes which should make up the body of the HTTP packet
+            request - Set to True if this is a request
+            response - Set to True if this is a response
+
+        Returns:
+            Binary data which can be sent over the wire to a HTTP server.
+        """
+        out = []
+
+        # Add first part of header
+        if request:
+            out.append('{} {} {}'.format(parsed_headers['method'], parsed_headers['uri'], parsed_headers['version']))
+        elif response:
+            out.append('{} {} {}'.format(parsed_headers['version'], parsed_headers['code'], parsed_headers['error']))
+        else:
+            raise Exception("Logic error!")
+
+        # Add the rest of the headers
+        for header in parsed_headers['preserved_headers']:
+            name, value = header
+            if name.lower() == 'content-length':
+                # Fix this
+                value = len(data)
+            elif name.lower() == 'transfer-encoding':
+                # Either we support and strip this, or error!
+                if value.lower() == 'chunked':
+                    # We support parsing this, but aren't going to re-generate
+                    continue
+                else:
+                    # Woah, can't figure this out!
+                    raise Exception("Unknown transfer-encodign {}".format(value))
+
+            out.append("{}: {}".format(name, value))
+
+        # Concatenate it with the binary data
+        return "\r\n".join(out).encode('ascii') + b'\r\n\r\n' + data
diff --git a/bemani/common/id.py b/bemani/common/id.py
new file mode 100644
index 0000000..3b10571
--- /dev/null
+++ b/bemani/common/id.py
@@ -0,0 +1,61 @@
+from typing import Optional
+
+
+class ID:
+
+    @staticmethod
+    def format_extid(extid: int) -> str:
+        """
+        Take an ExtID as an integer, format it as a string.
+
+        If we had the ExtID 12345678, this would format as '1234-5678'
+
+        Parameters:
+            extid - The ID as an integer
+
+        Returns:
+            A string suitable for display to the user.
+        """
+        extid_str = str(extid)
+        while len(extid_str) < 8:
+            extid_str = '0' + extid_str
+        return '{}-{}'.format(extid_str[0:4], extid_str[4:8])
+
+    @staticmethod
+    def parse_extid(extid: str) -> Optional[int]:
+        """
+        Take an ExtID as a string, and return the integer.
+
+        If we had the ExtID '1234-5678', this would return 12345678.
+
+        Parameters:
+            extid - The string ID as shown to a suer
+
+        Returns:
+            An integer extid suitable for looking up in a DB.
+        """
+        try:
+            if len(extid) == 9 and extid[4:5] == '-':
+                return int(extid[0:4] + extid[5:9])
+        except ValueError:
+            pass
+        return None
+
+    @staticmethod
+    def format_machine_id(machine_id: int) -> str:
+        """
+        Take a machine ID as an integer, format it as a string.
+        """
+        return 'US-{}'.format(machine_id)
+
+    @staticmethod
+    def parse_machine_id(machine_id: str) -> Optional[int]:
+        """
+        Take a formatted machine ID as a string, returning an int.
+        """
+        try:
+            if machine_id[:3] == 'US-':
+                return int(machine_id[3:])
+        except ValueError:
+            pass
+        return None
diff --git a/bemani/common/model.py b/bemani/common/model.py
new file mode 100644
index 0000000..afd042c
--- /dev/null
+++ b/bemani/common/model.py
@@ -0,0 +1,52 @@
+from typing import Optional
+
+
+class Model:
+    """
+    Object representing a parsed Model String.
+    """
+
+    def __init__(self, game: str, dest: str, spec: str, rev: str, version: Optional[int]) -> None:
+        """
+        Initialize a Model object.
+
+        Parameters:
+            game - Game code (such as LDJ)
+            dest - Destination region for the game (such as J)
+            spec - Spec for the game (such as A)
+            rev - Revision of the game (such as A)
+            version - Integer representing version, usually in the form of YYYYMMDDXX where
+                      YYYY is a year, MM is a month, DD is a day and XX is sub-day versioning.
+        """
+        self.game = game
+        self.dest = dest
+        self.spec = spec
+        self.rev = rev
+        self.version = version
+
+    @staticmethod
+    def from_modelstring(model: str) -> 'Model':
+        """
+        Parse a modelstring and return a Model
+
+        Parameters:
+            model - Modelstring in a form similar to "K39:J:B:A:2010122200". Note that
+                    The last part (version number) may be left off.
+
+        Returns:
+            A Model object.
+        """
+        parts = model.split(':')
+        if len(parts) == 5:
+            game, dest, spec, rev, version = parts
+            return Model(game, dest, spec, rev, int(version))
+        elif len(parts) == 4:
+            game, dest, spec, rev = parts
+            return Model(game, dest, spec, rev, None)
+        raise Exception('Couldn\'t parse model {}'.format(model))
+
+    def __str__(self) -> str:
+        if self.version is None:
+            return '{}:{}:{}:{}'.format(self.game, self.dest, self.spec, self.rev)
+        else:
+            return '{}:{}:{}:{}:{}'.format(self.game, self.dest, self.spec, self.rev, self.version)
diff --git a/bemani/common/parallel.py b/bemani/common/parallel.py
new file mode 100644
index 0000000..88710f0
--- /dev/null
+++ b/bemani/common/parallel.py
@@ -0,0 +1,85 @@
+import concurrent.futures
+from typing import Any, Callable, List, TypeVar
+
+T = TypeVar('T')
+
+
+class Parallel:
+    """
+    Utilities for executing parallel operations. This is used as a convenience
+    so that we don't have to plumb async/await support (yuck) through the network,
+    but we can still make multiple queries at once to remote services and the DB.
+    """
+
+    @staticmethod
+    def execute(lambdas: List[Callable[[], Any]]) -> List[Any]:
+        """
+        Given a list of callables, execute them and return a list of their returns.
+        Guarantees order of return based on order of callable.
+        """
+
+        if len(lambdas) == 0:
+            return []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=len(lambdas)) as executor:
+            futures = {executor.submit(lambdas[pos]): pos for pos in range(len(lambdas))}
+            results = []  # List: Tuple[Any, int]
+
+            for future in concurrent.futures.as_completed(futures):
+                pos = futures[future]
+                data = future.result()
+                results.append((data, pos))
+
+            return [r[0] for r in sorted(results, key=lambda r: r[1])]
+
+    @staticmethod
+    def map(lam: Callable[[T], Any], params: List[T]) -> List[Any]:
+        """
+        Given a callable and a list of params, executes that callable with each set
+        of params in the list and returns a list of their returns. Guarantees order
+        of return.
+        """
+
+        if len(params) == 0:
+            return []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=len(params)) as executor:
+            futures = {executor.submit(lam, params[pos]): pos for pos in range(len(params))}
+            results = []  # List: Tuple[Any, int]
+
+            for future in concurrent.futures.as_completed(futures):
+                pos = futures[future]
+                data = future.result()
+                results.append((data, pos))
+
+            return [r[0] for r in sorted(results, key=lambda r: r[1])]
+
+    @staticmethod
+    def call(lambdas: 'List[Callable[..., Any]]', *params: Any) -> List[Any]:
+        """
+        Given a list of callables and zero or more params, calls each callable in
+        parallel with the params specified. Essentially a map of params to multiple
+        callables in parallel. Returns a list of returns, garanteed to be in the
+        same order as the lambdas.
+        """
+
+        if len(lambdas) == 0:
+            return []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=len(lambdas)) as executor:
+            futures = {executor.submit(lambdas[pos], *params): pos for pos in range(len(lambdas))}
+            results = []  # List: Tuple[Any, int]
+
+            for future in concurrent.futures.as_completed(futures):
+                pos = futures[future]
+                data = future.result()
+                results.append((data, pos))
+
+            return [r[0] for r in sorted(results, key=lambda r: r[1])]
+
+    @staticmethod
+    def flatten(lists: List[List[Any]]) -> List[Any]:
+        """
+        Convenience function that probably exists in functools, but whatever.
+        Takes a list of lists, and returns a list made of all those lists
+        joined together.
+        """
+
+        return [item for sublist in lists for item in sublist]
diff --git a/bemani/common/time.py b/bemani/common/time.py
new file mode 100644
index 0000000..2edc5eb
--- /dev/null
+++ b/bemani/common/time.py
@@ -0,0 +1,184 @@
+import calendar
+import datetime
+from dateutil import tz
+
+from typing import List, Optional
+
+
+class Time:
+    """
+    Python's time stuff sucks, so this provides a sane interface to getting
+    standard unix timestamps at UTC timezone given various parameters.
+    """
+
+    SECONDS_IN_MINUTE = 60
+    SECONDS_IN_HOUR = 3600
+    SECONDS_IN_DAY = 86400
+    SECONDS_IN_WEEK = 604800
+
+    @staticmethod
+    def now() -> int:
+        """
+        Returns the current unix timestamp in the UTC timezone.
+        """
+        return calendar.timegm(datetime.datetime.utcnow().timetuple())
+
+    @staticmethod
+    def end_of_today() -> int:
+        """
+        Returns the unix timestamp for the end of today in UTC timezone.
+        """
+        now = datetime.datetime.utcnow().date()
+        beginning_of_day = datetime.datetime(
+            now.year,
+            now.month,
+            now.day,
+            tzinfo=tz.tzutc()  # type: ignore
+        )
+        end_of_day = beginning_of_day + datetime.timedelta(days=1)
+        return calendar.timegm(end_of_day.timetuple())
+
+    @staticmethod
+    def beginning_of_today() -> int:
+        """
+        Returns the unix timestamp for the beginning of today in UTC timezone.
+        """
+        now = datetime.datetime.utcnow().date()
+        beginning_of_day = datetime.datetime(
+            now.year,
+            now.month,
+            now.day,
+            tzinfo=tz.tzutc()  # type: ignore
+        )
+        return calendar.timegm(beginning_of_day.timetuple())
+
+    @staticmethod
+    def end_of_this_week() -> int:
+        """
+        Returns the unix timestamp for the end of this week in UTC timezone.
+        """
+        now = datetime.datetime.utcnow().date()
+        this_week = now - datetime.timedelta(days=now.timetuple().tm_wday)  # type: ignore
+        next_week = this_week + datetime.timedelta(days=7)
+        return calendar.timegm(next_week.timetuple())
+
+    @staticmethod
+    def beginning_of_this_week() -> int:
+        """
+        Returns the unix timestamp for the beginning of this week in UTC timezone.
+        """
+        now = datetime.datetime.utcnow().date()
+        this_week = now - datetime.timedelta(days=now.timetuple().tm_wday)  # type: ignore
+        return calendar.timegm(this_week.timetuple())
+
+    @staticmethod
+    def end_of_this_month() -> int:
+        """
+        Returns the unix timestamp for the end of this month in UTC timezone.
+        """
+        now = datetime.datetime.utcnow().date()
+        return Time.timestamp_from_date(now.year, now.month + 1, 1)
+
+    @staticmethod
+    def beginning_of_this_month() -> int:
+        """
+        Returns the unix timestamp for the beginning of this month in UTC timezone.
+        """
+        now = datetime.datetime.utcnow().date()
+        this_month = datetime.date(now.year, now.month, 1)
+        return calendar.timegm(this_month.timetuple())
+
+    @staticmethod
+    def todays_date() -> List[int]:
+        """
+        Returns a [year, month, day] list representing today's date.
+        """
+        now = datetime.datetime.utcnow().date()
+        return [now.year, now.month, now.day]
+
+    @staticmethod
+    def yesterdays_date() -> List[int]:
+        """
+        Returns a [year, month, day] list representing yesterday's date.
+        """
+        now = datetime.datetime.utcnow().date()
+        yesterday = now - datetime.timedelta(days=1)
+        return [yesterday.year, yesterday.month, yesterday.day]
+
+    @staticmethod
+    def week_in_days_since_epoch(timestamp: Optional[int]=None) -> int:
+        """
+        Returns the day number of the beginning of this week, where day zero is
+        the unix epoch at UTC timezone. So if we were one week in, this would return
+        7. If a timestamp is provided, returns the same value from that reverence
+        point instead of now.
+        """
+        if timestamp is None:
+            date = datetime.datetime.utcnow().date()
+        else:
+            date = datetime.datetime.utcfromtimestamp(timestamp).date()
+        week = date - datetime.timedelta(days=date.timetuple().tm_wday)  # type: ignore
+        return (week - datetime.date(1970, 1, 1)).days
+
+    @staticmethod
+    def days_into_year(timestamp: Optional[int]=None) -> List[int]:
+        """
+        Returns a [year, days] list representing the current year, and number
+        of days into the current year. If a timestamp is provided, returns the
+        same value from that reverence point instead of now.
+        """
+        if timestamp is None:
+            date = datetime.datetime.utcnow().date().timetuple()
+        else:
+            date = datetime.datetime.utcfromtimestamp(timestamp).date().timetuple()
+        return [date.tm_year, date.tm_yday]  # type: ignore
+
+    @staticmethod
+    def days_into_week(timestamp: Optional[int]=None) -> int:
+        """
+        Returns an integer representing the number of days into the current week
+        we are, with 0 = monday, 1 = tuesday, etc. If a timestamp is provided,
+        returns the same value from that reverence point instead of now.
+        """
+        if timestamp is None:
+            date = datetime.datetime.utcnow().date().timetuple()
+        else:
+            date = datetime.datetime.utcfromtimestamp(timestamp).date().timetuple()
+        return date.tm_wday  # type: ignore
+
+    @staticmethod
+    def timestamp_from_date(year: int, month: int=1, day: int=1) -> int:
+        """
+        Given a date (either a year, year/month, or year/month/day), returns
+        the unix timestamp from UTC of that date. Supports out of bounds
+        indexing on month.
+        """
+        while month < 1:
+            year = year - 1
+            month = month + 12
+        while month > 12:
+            year = year + 1
+            month = month - 12
+
+        date = datetime.datetime(
+            year,
+            month,
+            day,
+            tzinfo=tz.tzutc()  # type: ignore
+        )
+        return calendar.timegm(date.timetuple())
+
+    @staticmethod
+    def date_from_timestamp(timestamp: int) -> List[int]:
+        """
+        Returns a [year, month, day] given a UTC unix timestamp.
+        """
+        date = datetime.datetime.utcfromtimestamp(timestamp).date()
+        return [date.year, date.month, date.day]
+
+    @staticmethod
+    def format(timestamp: int, formatstr: str) -> str:
+        """
+        Returns a unix timestamp based at UTC timezone formatted as a string.
+        """
+        return datetime.datetime.utcfromtimestamp(timestamp).strftime(formatstr)
diff --git a/bemani/common/validateddict.py b/bemani/common/validateddict.py
new file mode 100644
index 0000000..4e3092e
--- /dev/null
+++ b/bemani/common/validateddict.py
@@ -0,0 +1,439 @@
+from typing import Optional, List, Dict, Any
+
+
+def intish(val: Any, base: int=10) -> Optional[int]:
+    if val is None:
+        return None
+    try:
+        return int(val, base)
+    except ValueError:
+        return None
+
+
+class ValidatedDict(dict):
+    """
+    Helper class which gives a Dict object superpowers. Allows stores and loads to be
+    validated so you only ever update when given good data, and only ever return
+    non-default values when data is good. Used primarily for storing data pulled
+    directly from game responses, or reading data to echo to a game.
+
+    All of the get functions will verify that the attribute exists and is the right
+    type. If it is not, the default value is returned.
+
+    all of the set functions will verify that the to-be-stored value matches the
+    type. If it does not, the value is not updated.
+    """
+
+    def get_int(self, name: str, default: int=0) -> int:
+        """
+        Given the name of a value, return an integer stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            default - The default to return if the value doesn't exist, or isn't an integer.
+
+        Returns:
+            An integer.
+        """
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != int:
+            return default
+        return val
+
+    def get_float(self, name: str, default: float=0.0) -> float:
+        """
+        Given the name of a value, return a float stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            default - The default to return if the value doesn't exist, or isn't a float.
+
+        Returns:
+            A float.
+        """
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != float:
+            return default
+        return val
+
+    def get_bool(self, name: str, default: bool=False) -> bool:
+        """
+        Given the name of a value, return a boolean stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            default - The default to return if the value doesn't exist, or isn't a boolean.
+
+        Returns:
+            A boolean.
+        """
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != bool:
+            return default
+        return val
+
+    def get_str(self, name: str, default: str='') -> str:
+        """
+        Given the name of a value, return string stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            default - The default to return if the value doesn't exist, or isn't a string.
+
+        Returns:
+            A string.
+        """
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != str:
+            return default
+        return val
+
+    def get_bytes(self, name: str, default: bytes=b'') -> bytes:
+        """
+        Given the name of a value, return bytes stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            default - The default to return if the value doesn't exist, or isn't bytes.
+
+        Returns:
+            A bytestring.
+        """
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != bytes:
+            return default
+        return val
+
+    def get_int_array(self, name: str, length: int, default: Optional[List[int]]=None) -> List[int]:
+        """
+        Given the name of a value, return a list of integers stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            length - The expected length of the array
+            default - The default to return if the value doesn't exist, or isn't a list of integers
+                      of the right length.
+
+        Returns:
+            A list of integers.
+        """
+        if default is None:
+            default = [0] * length
+        if len(default) != length:
+            raise Exception('Gave default of wrong length!')
+
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != list:
+            return default
+        if len(val) != length:
+            return default
+        for v in val:
+            if type(v) != int:
+                return default
+        return val
+
+    def get_bool_array(self, name: str, length: int, default: Optional[List[bool]]=None) -> List[bool]:
+        """
+        Given the name of a value, return a list of booleans stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            length - The expected length of the array
+            default - The default to return if the value doesn't exist, or isn't a list of booleans
+                      of the right length.
+
+        Returns:
+            A list of booleans.
+        """
+        if default is None:
+            default = [False] * length
+        if len(default) != length:
+            raise Exception('Gave default of wrong length!')
+
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != list:
+            return default
+        if len(val) != length:
+            return default
+        for v in val:
+            if type(v) != bool:
+                return default
+        return val
+
+    def get_bytes_array(self, name: str, length: int, default: Optional[List[bytes]]=None) -> List[bytes]:
+        """
+        Given the name of a value, return a list of bytestrings stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            length - The expected length of the array
+            default - The default to return if the value doesn't exist, or isn't a list of bytestrings
+                      of the right length.
+
+        Returns:
+            A list of bytestrings.
+        """
+        if default is None:
+            default = [b''] * length
+        if len(default) != length:
+            raise Exception('Gave default of wrong length!')
+
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != list:
+            return default
+        if len(val) != length:
+            return default
+        for v in val:
+            if type(v) != bytes:
+                return default
+        return val
+
+    def get_str_array(self, name: str, length: int, default: Optional[List[str]]=None) -> List[str]:
+        """
+        Given the name of a value, return a list of strings stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            length - The expected length of the array
+            default - The default to return if the value doesn't exist, or isn't a list of strings
+                      of the right length.
+
+        Returns:
+            A list of strings.
+        """
+        if default is None:
+            default = [''] * length
+        if len(default) != length:
+            raise Exception('Gave default of wrong length!')
+
+        val = self.get(name)
+        if val is None:
+            return default
+        if type(val) != list:
+            return default
+        if len(val) != length:
+            return default
+        for v in val:
+            if type(v) != str:
+                return default
+        return val
+
+    def get_dict(self, name: str, default: Optional[Dict[Any, Any]]=None) -> 'ValidatedDict':
+        """
+        Given the name of a value, return a dictionary stored under that name.
+
+        Parameters:
+            name - Name of attribute
+            default - The default to return if the value doesn't exist, or isn't a dictionary.
+
+        Returns:
+            A dictionary, wrapped with this helper class so the same helper methods may be called.
+        """
+        if default is None:
+            default = {}
+        validateddefault = ValidatedDict(default)
+
+        val = self.get(name)
+        if val is None:
+            return validateddefault
+        if not isinstance(val, dict):
+            return validateddefault
+        return ValidatedDict(val)
+
+    def replace_int(self, name: str, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            val - The value to store, if it is actually an integer.
+        """
+        if val is None:
+            return
+        if type(val) != int:
+            return
+        self[name] = val
+
+    def replace_float(self, name: str, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            val - The value to store, if it is actually a float
+        """
+        if val is None:
+            return
+        if type(val) != float:
+            return
+        self[name] = val
+
+    def replace_bool(self, name: str, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            val - The value to store, if it is actually a boolean.
+        """
+        if val is None:
+            return
+        if type(val) != bool:
+            return
+        self[name] = val
+
+    def replace_str(self, name: str, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            val - The value to store, if it is actually a string.
+        """
+        if val is None:
+            return
+        if type(val) != str:
+            return
+        self[name] = val
+
+    def replace_bytes(self, name: str, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            val - The value to store, if it is actually a bytestring.
+        """
+        if val is None:
+            return
+        if type(val) != bytes:
+            return
+        self[name] = val
+
+    def replace_int_array(self, name: str, length: int, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            length - Expected length of the list
+            val - The value to store, if it is actually a list of integers containing length elements.
+        """
+        if val is None:
+            return
+        if type(val) != list:
+            return
+        if len(val) != length:
+            return
+        for v in val:
+            if type(v) != int:
+                return
+        self[name] = val
+
+    def replace_bool_array(self, name: str, length: int, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            length - Expected length of the list
+            val - The value to store, if it is actually a list of booleans containing length elements.
+        """
+        if val is None:
+            return
+        if type(val) != list:
+            return
+        if len(val) != length:
+            return
+        for v in val:
+            if type(v) != bool:
+                return
+        self[name] = val
+
+    def replace_bytes_array(self, name: str, length: int, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            length - Expected length of the list
+            val - The value to store, if it is actually a list of bytestrings containing length elements.
+        """
+        if val is None:
+            return
+        if type(val) != list:
+            return
+        if len(val) != length:
+            return
+        for v in val:
+            if type(v) != bytes:
+                return
+        self[name] = val
+
+    def replace_str_array(self, name: str, length: int, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            length - Expected length of the list
+            val - The value to store, if it is actually a list of strings containing length elements.
+        """
+        if val is None:
+            return
+        if type(val) != list:
+            return
+        if len(val) != length:
+            return
+        for v in val:
+            if type(v) != str:
+                return
+        self[name] = val
+
+    def replace_dict(self, name: str, val: Any) -> None:
+        """
+        Given the name of a value and a new value to store, update that value.
+
+        Parameters:
+            name - Name of attribute
+            val - The value to store, if it is actually a dictionary.
+        """
+        if val is None:
+            return
+        if not isinstance(val, dict):
+            return
+        self[name] = val
+
+    def increment_int(self, name: str) -> None:
+        """
+        Given the name of a value, increment the value by 1.
+
+        If the value doesn't exist or isn't an integer, converts it to an integer
+        and sets it to 1 (as if it was 0 before). If it is an integer, increments
+        it by 1.
+
+        Parameters:
+            name - Name of attribute
+        """
+        if name not in self:
+            self[name] = 1
+        elif type(self[name]) != int:
+            self[name] = 1
+        else:
+            self[name] = self[name] + 1
diff --git a/bemani/data/__init__.py b/bemani/data/__init__.py
new file mode 100644
index 0000000..6360d8f
--- /dev/null
+++ b/bemani/data/__init__.py
@@ -0,0 +1,4 @@
+from bemani.data.data import Data, DBCreateException
+from bemani.data.exceptions import ScoreSaveException
+from bemani.data.types import User, Achievement, Machine, Arcade, Score, Attempt, News, Link, Song, Event, Server, Client, UserID, ArcadeID
+from bemani.data.remoteuser import RemoteUser
diff --git a/bemani/data/api/__init__.py b/bemani/data/api/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/bemani/data/api/base.py b/bemani/data/api/base.py
new file mode 100644
index 0000000..0366113
--- /dev/null
+++ b/bemani/data/api/base.py
@@ -0,0 +1,19 @@
+from typing import List, Optional
+
+from bemani.data.api.client import APIClient
+from bemani.data.interfaces import APIProviderInterface
+
+
+class BaseGlobalData:
+
+    def __init__(self, api: APIProviderInterface) -> None:
+        self.__localapi = api
+        self.__apiclients: Optional[List[APIClient]] = None
+
+    @property
+    def clients(self) -> List[APIClient]:
+        if self.__apiclients is None:
+            servers = self.__localapi.get_all_servers()
+            self.__apiclients = [APIClient(server.uri, server.token, server.allow_stats, server.allow_scores) for server in servers]
+
+        return self.__apiclients
diff --git a/bemani/data/api/client.py b/bemani/data/api/client.py
new file mode 100644
index 0000000..c7545ba
--- /dev/null
+++ b/bemani/data/api/client.py
@@ -0,0 +1,268 @@
+import json
+import requests
+from typing import Tuple, Dict, List, Any, Optional
+
+from bemani.common import GameConstants, VersionConstants, DBConstants, ValidatedDict
+
+
+class APIException(Exception):
+    pass
+
+
+class NotAuthorizedAPIException(APIException):
+    pass
+
+
+class UnsupportedRequestAPIException(APIException):
+    pass
+
+
+class UnrecognizedRequestAPIException(APIException):
+    pass
+
+
+class UnsupportedVersionAPIException(APIException):
+    pass
+
+
+class RemoteServerErrorAPIException(APIException):
+    pass
+
+
+class APIClient:
+    """
+    A client that fully speaks BEMAPI and can pull information from a remote server.
+    """
+
+    API_VERSION = 'v1'
+
+    def __init__(self, base_uri: str, token: str, allow_stats: bool, allow_scores: bool) -> None:
+        self.base_uri = base_uri
+        self.token = token
+        self.allow_stats = allow_stats
+        self.allow_scores = allow_scores
+
+    def __exchange_data(self, request_uri: str, request_args: Dict[str, Any]) -> Dict[str, Any]:
+        if self.base_uri[-1:] != '/':
+            uri = '{}/{}'.format(self.base_uri, request_uri)
+        else:
+            uri = '{}{}'.format(self.base_uri, request_uri)
+
+        headers = {
+            'Authorization': 'Token {}'.format(self.token),
+            'Content-Type': 'application/json; charset=utf-8',
+        }
+        data = json.dumps(request_args).encode('utf8')
+
+        try:
+            r = requests.request(
+                'GET',
+                uri,
+                headers=headers,
+                data=data,
+                allow_redirects=False,
+                timeout=10,
+            )
+        except Exception:
+            raise APIException('Failed to query remote server!')
+
+        if r.headers['content-type'] != 'application/json; charset=utf-8':
+            raise APIException('API returned invalid content type \'{}\'!'.format(r.headers['content-type']))
+
+        jsondata = r.json()
+
+        if r.status_code == 200:
+            return jsondata
+
+        if 'error' not in jsondata:
+            raise APIException('API returned error code {} but did not include \'error\' attribute in response JSON!'.format(r.status_code))
+        error = jsondata['error']
+
+        if r.status_code == 401:
+            raise NotAuthorizedAPIException('The API token used is not authorized against this server!')
+        if r.status_code == 404:
+            raise UnsupportedRequestAPIException('The server does not support this game/version or request object!')
+        if r.status_code == 405:
+            raise UnrecognizedRequestAPIException('The server did not recognize the request!')
+        if r.status_code == 500:
+            raise RemoteServerErrorAPIException('The server had an error processing the request and returned \'{}\''.format(error))
+        if r.status_code == 501:
+            raise UnsupportedVersionAPIException('The server does not support this version of the API!')
+        raise APIException('The server returned an invalid status code {}!', format(r.status_code))
+
+    def __translate(self, game: str, version: int) -> Tuple[str, str]:
+        servergame = {
+            GameConstants.DDR: 'ddr',
+            GameConstants.IIDX: 'iidx',
+            GameConstants.JUBEAT: 'jubeat',
+            GameConstants.MUSECA: 'museca',
+            GameConstants.POPN_MUSIC: 'popnmusic',
+            GameConstants.REFLEC_BEAT: 'reflecbeat',
+            GameConstants.SDVX: 'soundvoltex',
+        }.get(game)
+        if servergame is None:
+            raise UnsupportedRequestAPIException('The client does not support this game/version!')
+
+        if version >= DBConstants.OMNIMIX_VERSION_BUMP:
+            version = version - DBConstants.OMNIMIX_VERSION_BUMP
+            omnimix = True
+        else:
+            omnimix = False
+
+        serverversion = {
+            GameConstants.DDR: {
+                VersionConstants.DDR_X2: '12',
+                VersionConstants.DDR_X3_VS_2NDMIX: '13',
+                VersionConstants.DDR_2013: '14',
+                VersionConstants.DDR_2014: '15',
+                VersionConstants.DDR_ACE: '16',
+            },
+            GameConstants.IIDX: {
+                VersionConstants.IIDX_TRICORO: '20',
+                VersionConstants.IIDX_SPADA: '21',
+                VersionConstants.IIDX_PENDUAL: '22',
+                VersionConstants.IIDX_COPULA: '23',
+                VersionConstants.IIDX_SINOBUZ: '24',
+                VersionConstants.IIDX_CANNON_BALLERS: '25',
+            },
+            GameConstants.JUBEAT: {
+                VersionConstants.JUBEAT_SAUCER: '5',
+                VersionConstants.JUBEAT_SAUCER_FULFILL: '5a',
+                VersionConstants.JUBEAT_PROP: '6',
+                VersionConstants.JUBEAT_QUBELL: '7',
+                VersionConstants.JUBEAT_CLAN: '8',
+            },
+            GameConstants.MUSECA: {
+                VersionConstants.MUSECA: '1',
+                VersionConstants.MUSECA_1_PLUS: '1p',
+            },
+            GameConstants.POPN_MUSIC: {
+                VersionConstants.POPN_MUSIC_TUNE_STREET: '19',
+                VersionConstants.POPN_MUSIC_FANTASIA: '20',
+                VersionConstants.POPN_MUSIC_SUNNY_PARK: '21',
+                VersionConstants.POPN_MUSIC_LAPISTORIA: '22',
+                VersionConstants.POPN_MUSIC_ECLALE: '23',
+                VersionConstants.POPN_MUSIC_USANEKO: '24',
+            },
+            GameConstants.REFLEC_BEAT: {
+                VersionConstants.REFLEC_BEAT: '1',
+                VersionConstants.REFLEC_BEAT_LIMELIGHT: '2',
+                VersionConstants.REFLEC_BEAT_COLETTE: '3as',
+                VersionConstants.REFLEC_BEAT_GROOVIN: '4u',
+                VersionConstants.REFLEC_BEAT_VOLZZA: '5',
+                VersionConstants.REFLEC_BEAT_VOLZZA_2: '5a',
+                VersionConstants.REFLEC_BEAT_REFLESIA: '6',
+            },
+            GameConstants.SDVX: {
+                VersionConstants.SDVX_BOOTH: '1',
+                VersionConstants.SDVX_INFINITE_INFECTION: '2',
+                VersionConstants.SDVX_GRAVITY_WARS: '3',
+                VersionConstants.SDVX_HEAVENLY_HAVEN: '4',
+            },
+        }.get(game, {}).get(version)
+        if serverversion is None:
+            raise UnsupportedRequestAPIException('The client does not support this game/version!')
+
+        if omnimix:
+            serverversion = 'o' + serverversion
+
+        return (servergame, serverversion)
+
+    def get_server_info(self) -> ValidatedDict:
+        resp = self.__exchange_data('', {})
+        return ValidatedDict({
+            'name': resp['name'],
+            'email': resp['email'],
+            'versions': resp['versions'],
+        })
+
+    def get_profiles(self, game: str, version: int, idtype: str, ids: List[str]) -> List[Dict[str, Any]]:
+        # Allow remote servers to be disabled
+        if not self.allow_scores:
+            return []
+
+        try:
+            servergame, serverversion = self.__translate(game, version)
+            resp = self.__exchange_data(
+                '{}/{}/{}'.format(self.API_VERSION, servergame, serverversion),
+                {
+                    'ids': ids,
+                    'type': idtype,
+                    'objects': ['profile'],
+                },
+            )
+            return resp['profile']
+        except APIException:
+            # Couldn't talk to server, assume empty profiles
+            return []
+
+    def get_records(
+        self,
+        game: str,
+        version: int,
+        idtype: str,
+        ids: List[str],
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Dict[str, Any]]:
+        # Allow remote servers to be disabled
+        if not self.allow_scores:
+            return []
+
+        try:
+            servergame, serverversion = self.__translate(game, version)
+            data: Dict[str, Any] = {
+                'ids': ids,
+                'type': idtype,
+                'objects': ['records'],
+            }
+            if since is not None:
+                data['since'] = since
+            if until is not None:
+                data['until'] = until
+            resp = self.__exchange_data(
+                '{}/{}/{}'.format(self.API_VERSION, servergame, serverversion),
+                data,
+            )
+            return resp['records']
+        except APIException:
+            # Couldn't talk to server, assume empty records
+            return []
+
+    def get_statistics(self, game: str, version: int, idtype: str, ids: List[str]) -> List[Dict[str, Any]]:
+        # Allow remote servers to be disabled
+        if not self.allow_stats:
+            return []
+
+        try:
+            servergame, serverversion = self.__translate(game, version)
+            resp = self.__exchange_data(
+                '{}/{}/{}'.format(self.API_VERSION, servergame, serverversion),
+                {
+                    'ids': ids,
+                    'type': idtype,
+                    'objects': ['statistics'],
+                },
+            )
+            return resp['statistics']
+        except APIException:
+            # Couldn't talk to server, assume empty statistics
+            return []
+
+    def get_catalog(self, game: str, version: int) -> Dict[str, List[Dict[str, Any]]]:
+        # No point disallowing this, since its only ever used for bootstrapping.
+
+        try:
+            servergame, serverversion = self.__translate(game, version)
+            resp = self.__exchange_data(
+                '{}/{}/{}'.format(self.API_VERSION, servergame, serverversion),
+                {
+                    'ids': [],
+                    'type': 'server',
+                    'objects': ['catalog'],
+                },
+            )
+            return resp['catalog']
+        except APIException:
+            # Couldn't talk to server, assume empty catalog
+            return {}
diff --git a/bemani/data/api/game.py b/bemani/data/api/game.py
new file mode 100644
index 0000000..6d7875a
--- /dev/null
+++ b/bemani/data/api/game.py
@@ -0,0 +1,94 @@
+from typing import List, Optional, Dict, Any, Set
+
+from bemani.common import GameConstants, ValidatedDict, Parallel
+from bemani.data.api.base import BaseGlobalData
+from bemani.data.types import Item
+
+
+class GlobalGameData(BaseGlobalData):
+
+    def __translate_sdvx_song_unlock(self, entry: Dict[str, Any]) -> Item:
+        return Item(
+            "song_unlock",
+            int(entry["catalogid"]),
+            {
+                "musicid": int(entry["song"]),
+                "chart": int(entry["chart"]),
+                "blocks": int(entry["price"]),
+            },
+        )
+
+    def __translate_sdvx_appealcard(self, entry: Dict[str, Any]) -> Item:
+        return Item(
+            "appealcard",
+            int(entry["appealid"]),
+            {},
+        )
+
+    def get_items(self, game: str, version: int) -> List[Item]:
+        """
+        Given a game/userid, find all items in the catalog.
+
+        Parameters:
+            game - String identifier of the game looking up the catalog.
+            version - Integer identifier of the version looking up this catalog.
+
+        Returns:
+            A list of item objects.
+        """
+        catalogs: List[Dict[str, List[Dict[str, Any]]]] = Parallel.call(
+            [client.get_catalog for client in self.clients],
+            game,
+            version
+        )
+        retval: List[Item] = []
+        seen: Set[str] = set()
+        for catalog in catalogs:
+            for catalogtype in catalog:
+                # Simple LUT for now, might need to be complicated later
+                if game == GameConstants.SDVX:
+                    translation = {
+                        "purchases": self.__translate_sdvx_song_unlock,
+                        "appealcards": self.__translate_sdvx_appealcard,
+                    }.get(catalogtype, None)
+                else:
+                    translation = None
+
+                # If we don't have a mapping for this, ignore it
+                if translation is None:
+                    continue
+
+                for entry in catalog[catalogtype]:
+                    # Translate the entry
+                    item = translation(entry)
+
+                    # Now, see if it is unique, and if so, remember it
+                    key = f"{item.type}_{item.id}"
+                    if key in seen:
+                        continue
+
+                    retval.append(item)
+                    seen.add(key)
+        return retval
+
+    def get_item(self, game: str, version: int, catid: int, cattype: str) -> Optional[ValidatedDict]:
+        """
+        Given a game/userid and catalog id/type, find that catalog entry.
+
+        Note that there can be more than one catalog entry with the same ID and game/userid
+        as long as each one is a different type. Essentially, cattype namespaces catalog entry.
+
+        Parameters:
+            game - String identifier of the game looking up this entry.
+            version - Integer identifier of the version looking up this entry.
+            catid - Integer ID, as provided by a game.
+            cattype - The type of catalog entry.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        all_items = self.get_items(game, version)
+        for item in all_items:
+            if item.id == catid and item.type == cattype:
+                return item.data
+        return None
diff --git a/bemani/data/api/music.py b/bemani/data/api/music.py
new file mode 100644
index 0000000..be9dd4d
--- /dev/null
+++ b/bemani/data/api/music.py
@@ -0,0 +1,1045 @@
+from typing import List, Optional, Dict, Any, Tuple, Set
+
+from bemani.common import APIConstants, GameConstants, VersionConstants, DBConstants, Parallel
+from bemani.data.interfaces import APIProviderInterface
+from bemani.data.api.base import BaseGlobalData
+from bemani.data.mysql.user import UserData
+from bemani.data.mysql.music import MusicData
+from bemani.data.remoteuser import RemoteUser
+from bemani.data.types import UserID, Score, Song
+
+
+class GlobalMusicData(BaseGlobalData):
+
+    def __init__(self, api: APIProviderInterface, user: UserData, music: MusicData) -> None:
+        super().__init__(api)
+        self.user = user
+        self.music = music
+
+    def __get_cardids(self, userid: UserID) -> List[str]:
+        if RemoteUser.is_remote(userid):
+            return [RemoteUser.userid_to_card(userid)]
+        else:
+            return self.user.get_cards(userid)
+
+    def __min(self, int1: int, int2: int) -> int:
+        # -1 is used as a 'no value' so it should not overwrite a 0
+        if int1 == -1:
+            return int2
+        if int2 == -1:
+            return int1
+        return min(int1, int2)
+
+    def __max(self, int1: int, int2: int) -> int:
+        return max(int1, int2)
+
+    def __format_ddr_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        halo = {
+            'none': DBConstants.DDR_HALO_NONE,
+            'gfc': DBConstants.DDR_HALO_GOOD_FULL_COMBO,
+            'fc': DBConstants.DDR_HALO_GREAT_FULL_COMBO,
+            'pfc': DBConstants.DDR_HALO_PERFECT_FULL_COMBO,
+            'mfc': DBConstants.DDR_HALO_MARVELOUS_FULL_COMBO,
+        }.get(data.get('halo'), DBConstants.DDR_HALO_NONE)
+        rank = {
+            "AAA": DBConstants.DDR_RANK_AAA,
+            "AA+": DBConstants.DDR_RANK_AA_PLUS,
+            "AA": DBConstants.DDR_RANK_AA,
+            "AA-": DBConstants.DDR_RANK_AA_MINUS,
+            "A+": DBConstants.DDR_RANK_A_PLUS,
+            "A": DBConstants.DDR_RANK_A,
+            "A-": DBConstants.DDR_RANK_A_MINUS,
+            "B+": DBConstants.DDR_RANK_B_PLUS,
+            "B": DBConstants.DDR_RANK_B,
+            "B-": DBConstants.DDR_RANK_B_MINUS,
+            "C+": DBConstants.DDR_RANK_C_PLUS,
+            "C": DBConstants.DDR_RANK_C,
+            "C-": DBConstants.DDR_RANK_C_MINUS,
+            "D+": DBConstants.DDR_RANK_D_PLUS,
+            "D": DBConstants.DDR_RANK_D,
+            "E": DBConstants.DDR_RANK_E,
+        }.get(data.get('rank'), DBConstants.DDR_RANK_E)
+
+        ghost = ''
+        trace: List[int] = []
+
+        if version == VersionConstants.DDR_ACE:
+            # DDR Ace is specia
+            ghost = ''.join([str(x) for x in data.get('ghost', [])])
+        else:
+            trace = [int(x) for x in data.get('ghost', [])]
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'combo': int(data.get('combo', -1)),
+                'rank': rank,
+                'halo': halo,
+                'ghost': ghost,
+                'trace': trace,
+            },
+        )
+
+    def __format_iidx_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        status = {
+            'np': DBConstants.IIDX_CLEAR_STATUS_NO_PLAY,
+            'failed': DBConstants.IIDX_CLEAR_STATUS_FAILED,
+            'ac': DBConstants.IIDX_CLEAR_STATUS_ASSIST_CLEAR,
+            'ec': DBConstants.IIDX_CLEAR_STATUS_EASY_CLEAR,
+            'nc': DBConstants.IIDX_CLEAR_STATUS_CLEAR,
+            'hc': DBConstants.IIDX_CLEAR_STATUS_HARD_CLEAR,
+            'exhc': DBConstants.IIDX_CLEAR_STATUS_EX_HARD_CLEAR,
+            'fc': DBConstants.IIDX_CLEAR_STATUS_FULL_COMBO,
+        }.get(data.get('status'), DBConstants.IIDX_CLEAR_STATUS_NO_PLAY)
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'clear_status': status,
+                'ghost': bytes([int(b) for b in data.get('ghost', [])]),
+                'miss_count': int(data.get('miss', -1)),
+                'pgreats': int(data.get('pgreat', -1)),
+                'greats': int(data.get('great', -1)),
+            },
+        )
+
+    def __format_jubeat_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        status = {
+            'failed': DBConstants.JUBEAT_PLAY_MEDAL_FAILED,
+            'cleared': DBConstants.JUBEAT_PLAY_MEDAL_CLEARED,
+            'nfc': DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_FULL_COMBO,
+            'fc': DBConstants.JUBEAT_PLAY_MEDAL_FULL_COMBO,
+            'nec': DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT,
+            'exc': DBConstants.JUBEAT_PLAY_MEDAL_EXCELLENT,
+        }.get(data.get('status'), DBConstants.JUBEAT_PLAY_MEDAL_FAILED)
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'medal': status,
+                'combo': int(data.get('combo', -1)),
+                'ghost': [int(x) for x in data.get('ghost', [])]
+            },
+        )
+
+    def __format_museca_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        rank = {
+            'death': DBConstants.MUSECA_GRADE_DEATH,
+            'poor': DBConstants.MUSECA_GRADE_POOR,
+            'mediocre': DBConstants.MUSECA_GRADE_MEDIOCRE,
+            'good': DBConstants.MUSECA_GRADE_GOOD,
+            'great': DBConstants.MUSECA_GRADE_GREAT,
+            'excellent': DBConstants.MUSECA_GRADE_EXCELLENT,
+            'superb': DBConstants.MUSECA_GRADE_SUPERB,
+            'masterpiece': DBConstants.MUSECA_GRADE_MASTERPIECE,
+            'perfect': DBConstants.MUSECA_GRADE_PERFECT,
+        }.get(data.get('rank'), DBConstants.MUSECA_GRADE_DEATH)
+        status = {
+            'failed': DBConstants.MUSECA_CLEAR_TYPE_FAILED,
+            'cleared': DBConstants.MUSECA_CLEAR_TYPE_CLEARED,
+            'fc': DBConstants.MUSECA_CLEAR_TYPE_FULL_COMBO,
+        }.get(data.get('status'), DBConstants.MUSECA_CLEAR_TYPE_FAILED)
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'grade': rank,
+                'clear_type': status,
+                'combo': int(data.get('combo', -1)),
+                'stats': {
+                    'btn_rate': int(data.get('buttonrate', -1)),
+                    'long_rate': int(data.get('longrate', -1)),
+                    'vol_rate': int(data.get('volrate', -1)),
+                },
+            },
+        )
+
+    def __format_popn_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        status = {
+            'cf': DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED,
+            'df': DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FAILED,
+            'sf': DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FAILED,
+            'ec': DBConstants.POPN_MUSIC_PLAY_MEDAL_EASY_CLEAR,
+            'cc': DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_CLEARED,
+            'dc': DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_CLEARED,
+            'sc': DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_CLEARED,
+            'cfc': DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FULL_COMBO,
+            'dfc': DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FULL_COMBO,
+            'sfc': DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FULL_COMBO,
+            'p': DBConstants.POPN_MUSIC_PLAY_MEDAL_PERFECT,
+        }.get(data.get('status'), DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED)
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'medal': status,
+                'combo': int(data.get('combo', -1)),
+            },
+        )
+
+    def __format_reflec_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        status = {
+            'np': DBConstants.REFLEC_BEAT_CLEAR_TYPE_NO_PLAY,
+            'failed': DBConstants.REFLEC_BEAT_CLEAR_TYPE_FAILED,
+            'cleared': DBConstants.REFLEC_BEAT_CLEAR_TYPE_CLEARED,
+            'hc': DBConstants.REFLEC_BEAT_CLEAR_TYPE_HARD_CLEARED,
+            'shc': DBConstants.REFLEC_BEAT_CLEAR_TYPE_S_HARD_CLEARED,
+        }.get(data.get('status'), DBConstants.REFLEC_BEAT_CLEAR_TYPE_NO_PLAY)
+        halo = {
+            'none': DBConstants.REFLEC_BEAT_COMBO_TYPE_NONE,
+            'ac': DBConstants.REFLEC_BEAT_COMBO_TYPE_ALMOST_COMBO,
+            'fc': DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO,
+            'fcaj': DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO_ALL_JUST,
+        }.get(data.get('halo'), DBConstants.REFLEC_BEAT_COMBO_TYPE_NONE)
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'achievement_rate': int(data.get('rate', -1)),
+                'clear_type': status,
+                'combo_type': halo,
+                'miss_count': int(data.get('miss', -1)),
+                'combo': int(data.get('combo', -1)),
+            },
+        )
+
+    def __format_sdvx_score(self, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Score:
+        status = {
+            'np': DBConstants.SDVX_CLEAR_TYPE_NO_PLAY,
+            'failed': DBConstants.SDVX_CLEAR_TYPE_FAILED,
+            'cleared': DBConstants.SDVX_CLEAR_TYPE_CLEAR,
+            'hc': DBConstants.SDVX_CLEAR_TYPE_HARD_CLEAR,
+            'uc': DBConstants.SDVX_CLEAR_TYPE_ULTIMATE_CHAIN,
+            'puc': DBConstants.SDVX_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
+        }.get(data.get('status'), DBConstants.SDVX_CLEAR_TYPE_NO_PLAY)
+        rank = {
+            'E': DBConstants.SDVX_GRADE_NO_PLAY,
+            'D': DBConstants.SDVX_GRADE_D,
+            'C': DBConstants.SDVX_GRADE_C,
+            'B': DBConstants.SDVX_GRADE_B,
+            'A': DBConstants.SDVX_GRADE_A,
+            'A+': DBConstants.SDVX_GRADE_A_PLUS,
+            'AA': DBConstants.SDVX_GRADE_AA,
+            'AA+': DBConstants.SDVX_GRADE_AA_PLUS,
+            'AAA': DBConstants.SDVX_GRADE_AAA,
+            'AAA+': DBConstants.SDVX_GRADE_AAA_PLUS,
+            'S': DBConstants.SDVX_GRADE_S,
+        }.get(data.get('rank'), DBConstants.SDVX_GRADE_NO_PLAY)
+
+        return Score(
+            -1,
+            songid,
+            songchart,
+            int(data.get('points', 0)),
+            int(data.get('timestamp', -1)),
+            self.__max(int(data.get('timestamp', -1)), int(data.get('updated', -1))),
+            -1,  # No location for remote play
+            1,  # No play info for remote play
+            {
+                'grade': rank,
+                'clear_type': status,
+                'combo': int(data.get('combo', -1)),
+                'stats': {
+                    'btn_rate': int(data.get('buttonrate', -1)),
+                    'long_rate': int(data.get('longrate', -1)),
+                    'vol_rate': int(data.get('volrate', -1)),
+                },
+            },
+        )
+
+    def __format_score(self, game: str, version: int, songid: int, songchart: int, data: Dict[str, Any]) -> Optional[Score]:
+        if game == GameConstants.DDR:
+            return self.__format_ddr_score(version, songid, songchart, data)
+        if game == GameConstants.IIDX:
+            return self.__format_iidx_score(version, songid, songchart, data)
+        if game == GameConstants.JUBEAT:
+            return self.__format_jubeat_score(version, songid, songchart, data)
+        if game == GameConstants.MUSECA:
+            return self.__format_museca_score(version, songid, songchart, data)
+        if game == GameConstants.POPN_MUSIC:
+            return self.__format_popn_score(version, songid, songchart, data)
+        if game == GameConstants.REFLEC_BEAT:
+            return self.__format_reflec_score(version, songid, songchart, data)
+        if game == GameConstants.SDVX:
+            return self.__format_sdvx_score(version, songid, songchart, data)
+        return None
+
+    def __merge_ddr_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'rank': self.__max(oldscore.data['rank'], newscore.data['rank']),
+                'halo': self.__max(oldscore.data['halo'], newscore.data['halo']),
+                'ghost': oldscore.data.get('ghost') if oldscore.points > newscore.points else newscore.data.get('ghost'),
+                'trace': oldscore.data.get('trace') if oldscore.points > newscore.points else newscore.data.get('trace'),
+                'combo': self.__max(oldscore.data['combo'], newscore.data['combo']),
+            },
+        )
+
+    def __merge_iidx_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'clear_status': self.__max(oldscore.data['clear_status'], newscore.data['clear_status']),
+                'ghost': oldscore.data.get('ghost') if oldscore.points > newscore.points else newscore.data.get('ghost'),
+                'miss_count': self.__min(oldscore.data.get_int('miss_count', -1), newscore.data.get_int('miss_count', -1)),
+                'pgreats': oldscore.data.get_int('pgreats', -1) if oldscore.points > newscore.points else newscore.data.get_int('pgreats', -1),
+                'greats': oldscore.data.get_int('greats', -1) if oldscore.points > newscore.points else newscore.data.get_int('greats', -1),
+            },
+        )
+
+    def __merge_jubeat_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'ghost': oldscore.data.get('ghost') if oldscore.points > newscore.points else newscore.data.get('ghost'),
+                'combo': self.__max(oldscore.data['combo'], newscore.data['combo']),
+                'medal': self.__max(oldscore.data['medal'], newscore.data['medal']),
+            },
+        )
+
+    def __merge_museca_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'grade': self.__max(oldscore.data['grade'], newscore.data['grade']),
+                'clear_type': self.__max(oldscore.data['clear_type'], newscore.data['clear_type']),
+                'combo': self.__max(oldscore.data['combo'], newscore.data['combo']),
+                'stats': oldscore.data['stats'] if oldscore.points > newscore.points else newscore.data['stats'],
+            },
+        )
+
+    def __merge_popn_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'combo': self.__max(oldscore.data['combo'], newscore.data['combo']),
+                'medal': self.__max(oldscore.data['medal'], newscore.data['medal']),
+            },
+        )
+
+    def __merge_reflec_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'clear_type': self.__max(oldscore.data['clear_type'], newscore.data['clear_type']),
+                'combo_type': self.__max(oldscore.data['combo_type'], newscore.data['combo_type']),
+                'miss_count': self.__min(oldscore.data.get_int('miss_count', -1), newscore.data.get_int('miss_count', -1)),
+                'combo': self.__max(oldscore.data['combo'], newscore.data['combo']),
+                'achievement_rate': self.__max(oldscore.data['achievement_rate'], newscore.data['achievement_rate']),
+            },
+        )
+
+    def __merge_sdvx_score(self, version: int, oldscore: Score, newscore: Score) -> Score:
+        return Score(
+            -1,
+            oldscore.id,
+            oldscore.chart,
+            self.__max(oldscore.points, newscore.points),
+            self.__max(oldscore.timestamp, newscore.timestamp),
+            self.__max(self.__max(oldscore.update, newscore.update), self.__max(oldscore.timestamp, newscore.timestamp)),
+            oldscore.location,  # Always propagate location from local setup if possible
+            oldscore.plays + newscore.plays,
+            {
+                'grade': self.__max(oldscore.data['grade'], newscore.data['grade']),
+                'clear_type': self.__max(oldscore.data['clear_type'], newscore.data['clear_type']),
+                'combo': self.__max(oldscore.data.get_int('combo', 1), newscore.data.get_int('combo', -1)),
+                'stats': oldscore.data['stats'] if oldscore.points > newscore.points else newscore.data['stats'],
+            },
+        )
+
+    def __merge_score(self, game: str, version: int, oldscore: Score, newscore: Score) -> Score:
+        if oldscore.id != newscore.id or oldscore.chart != newscore.chart:
+            raise Exception('Logic error! Tried to merge scores from different song/charts!')
+
+        if game == GameConstants.DDR:
+            return self.__merge_ddr_score(version, oldscore, newscore)
+        if game == GameConstants.IIDX:
+            return self.__merge_iidx_score(version, oldscore, newscore)
+        if game == GameConstants.JUBEAT:
+            return self.__merge_jubeat_score(version, oldscore, newscore)
+        if game == GameConstants.MUSECA:
+            return self.__merge_museca_score(version, oldscore, newscore)
+        if game == GameConstants.POPN_MUSIC:
+            return self.__merge_popn_score(version, oldscore, newscore)
+        if game == GameConstants.REFLEC_BEAT:
+            return self.__merge_reflec_score(version, oldscore, newscore)
+        if game == GameConstants.SDVX:
+            return self.__merge_sdvx_score(version, oldscore, newscore)
+
+        return oldscore
+
+    def get_score(self, game: str, version: int, userid: UserID, songid: int, songchart: int) -> Optional[Score]:
+        # Helper function so we can iterate over all servers for a single card
+        def get_scores_for_card(cardid: str) -> List[Score]:
+            return Parallel.flatten(Parallel.call(
+                [client.get_records for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_INSTANCE,
+                [songid, songchart, cardid],
+            ))
+
+        relevant_cards = self.__get_cardids(userid)
+        if RemoteUser.is_remote(userid):
+            # No need to look up local score for this user
+            scores = Parallel.flatten(Parallel.map(
+                get_scores_for_card,
+                relevant_cards,
+            ))
+            localscore = None
+        else:
+            localscore, scores = Parallel.execute([
+                lambda: self.music.get_score(game, version, userid, songid, songchart),
+                lambda: Parallel.flatten(Parallel.map(
+                    get_scores_for_card,
+                    relevant_cards,
+                )),
+            ])
+
+        topscore = localscore
+
+        for score in scores:
+            if int(score['song']) != songid:
+                continue
+            if int(score['chart']) != songchart:
+                continue
+
+            newscore = self.__format_score(game, version, songid, songchart, score)
+
+            if topscore is None:
+                # No merging needed
+                topscore = newscore
+                continue
+
+            topscore = self.__merge_score(game, version, topscore, newscore)
+
+        return topscore
+
+    def get_scores(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Score]:
+        relevant_cards = self.__get_cardids(userid)
+        if RemoteUser.is_remote(userid):
+            # No need to look up local score for this user
+            scores = Parallel.flatten(Parallel.call(
+                [client.get_records for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_CARD,
+                relevant_cards,
+                since,
+                until,
+            ))
+            localscores: List[Score] = []
+        else:
+            localscores, scores = Parallel.execute([
+                lambda: self.music.get_scores(game, version, userid, since, until),
+                lambda: Parallel.flatten(Parallel.call(
+                    [client.get_records for client in self.clients],
+                    game,
+                    version,
+                    APIConstants.ID_TYPE_CARD,
+                    relevant_cards,
+                    since,
+                    until,
+                )),
+            ])
+
+        allscores: Dict[int, Dict[int, Score]] = {}
+
+        def add_score(score: Score) -> None:
+            if score.id not in allscores:
+                allscores[score.id] = {}
+            allscores[score.id][score.chart] = score
+
+        def get_score(songid: int, songchart: int) -> Optional[Score]:
+            return allscores.get(songid, {}).get(songchart)
+
+        # First, seed with local scores
+        for score in localscores:
+            add_score(score)
+
+        # Second, merge in remote scorse
+        for remotescore in scores:
+            songid = int(remotescore['song'])
+            chart = int(remotescore['chart'])
+            newscore = self.__format_score(game, version, songid, chart, remotescore)
+            oldscore = get_score(songid, chart)
+
+            if oldscore is None:
+                add_score(newscore)
+            else:
+                add_score(self.__merge_score(game, version, oldscore, newscore))
+
+        # Finally, flatten and return
+        finalscores: List[Score] = []
+        for songid in allscores:
+            for chart in allscores[songid]:
+                finalscores.append(allscores[songid][chart])
+
+        return finalscores
+
+    def __merge_global_scores(
+        self,
+        game: str,
+        version: int,
+        localcards: List[Tuple[str, UserID]],
+        localscores: List[Tuple[UserID, Score]],
+        remotescores: List[Dict[str, Any]],
+    ) -> List[Tuple[UserID, Score]]:
+        card_to_id = {cardid: userid for (cardid, userid) in localcards}
+        allscores: Dict[UserID, Dict[int, Dict[int, Score]]] = {}
+
+        def add_score(userid: UserID, score: Score) -> None:
+            if userid not in allscores:
+                allscores[userid] = {}
+            if score.id not in allscores[userid]:
+                allscores[userid][score.id] = {}
+            allscores[userid][score.id][score.chart] = score
+
+        def get_score(userid: UserID, songid: int, songchart: int) -> Optional[Score]:
+            return allscores.get(userid, {}).get(songid, {}).get(songchart)
+
+        # First, seed with local scores
+        for (userid, score) in localscores:
+            add_score(userid, score)
+
+        # Second, merge in remote scorse
+        for remotescore in remotescores:
+            # Figure out the userid of this score
+            cardids = sorted([card.upper() for card in remotescore.get('cards', [])])
+            if len(cardids) == 0:
+                continue
+
+            for cardid in cardids:
+                if cardid in card_to_id:
+                    userid = card_to_id[cardid]
+                    break
+            else:
+                userid = RemoteUser.card_to_userid(cardids[0])
+
+            songid = int(remotescore['song'])
+            chart = int(remotescore['chart'])
+            newscore = self.__format_score(game, version, songid, chart, remotescore)
+            oldscore = get_score(userid, songid, chart)
+
+            if oldscore is None:
+                add_score(userid, newscore)
+            else:
+                add_score(userid, self.__merge_score(game, version, oldscore, newscore))
+
+        # Finally, flatten and return
+        finalscores: List[Tuple[UserID, Score]] = []
+        for userid in allscores:
+            for songid in allscores[userid]:
+                for chart in allscores[userid][songid]:
+                    finalscores.append((userid, allscores[userid][songid][chart]))
+
+        return finalscores
+
+    def get_all_scores(
+        self,
+        game: str,
+        version: Optional[int]=None,
+        userid: Optional[UserID]=None,
+        songid: Optional[int]=None,
+        songchart: Optional[int]=None,
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Tuple[UserID, Score]]:
+        # First, pass off to local-only if this was called with parameters we don't support
+        if (
+            version is None or
+            userid is not None or
+            songid is None
+        ):
+            return self.music.get_all_scores(game, version, userid, songid, songchart, since, until)
+
+        # Now, figure out the request key based on passed in parameters
+        if songchart is None:
+            songkey = [songid]
+        else:
+            songkey = [songid, songchart]
+
+        # Now, fetch all the scores remotely and locally
+        localcards, localscores, remotescores = Parallel.execute([
+            self.user.get_all_cards,
+            lambda: self.music.get_all_scores(game, version, userid, songid, songchart, since, until),
+            lambda: Parallel.flatten(Parallel.call(
+                [client.get_records for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_SONG,
+                songkey,
+                since,
+                until,
+            )),
+        ])
+
+        return self.__merge_global_scores(game, version, localcards, localscores, remotescores)
+
+    def get_all_records(
+        self,
+        game: str,
+        version: Optional[int]=None,
+        userlist: Optional[List[UserID]]=None,
+        locationlist: Optional[List[int]]=None,
+    ) -> List[Tuple[UserID, Score]]:
+        # First, pass off to local-only if this was called with parameters we don't support
+        if (
+            version is None or
+            userlist is not None or
+            locationlist is not None
+        ):
+            return self.music.get_all_records(game, version, userlist, locationlist)
+
+        # Now, fetch all records remotely and locally
+        localcards, localscores, remotescores = Parallel.execute([
+            self.user.get_all_cards,
+            lambda: self.music.get_all_records(game, version, userlist, locationlist),
+            lambda: Parallel.flatten(Parallel.call(
+                [client.get_records for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_SERVER,
+                [],
+            )),
+        ])
+
+        return self.__merge_global_scores(game, version, localcards, localscores, remotescores)
+
+    def get_clear_rates(
+        self,
+        game: str,
+        version: int,
+        songid: Optional[int]=None,
+        songchart: Optional[int]=None,
+    ) -> Dict[int, Dict[int, Dict[str, int]]]:
+        """
+        Given an optional songid, or optional songid and songchart, looks up clear rates
+        in remote servers that are connected to us. If neither id or chart is given, looks
+        up global clear rates. If songid is given, looks up clear rates for each chart for
+        the song. If songid and chart is given, looks up clear rates for that song/chart.
+
+        Returns a dictionary keyed by songid, whos values are a dictionary keyed by chart,
+        whos values are a dictionary containing integer counts keyed by 'plays', 'clears',
+        and 'combos'. An example is as follows:
+
+        {
+            musicid: {
+                chart: {
+                    plays: total plays,
+                    clears: total clears,
+                    combos: total full combos,
+                },
+            },
+        }
+        """
+
+        if songid is None and songchart is None:
+            statistics = Parallel.flatten(Parallel.call(
+                [client.get_statistics for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_SERVER,
+                [],
+            ))
+        elif songid is not None:
+            if songchart is None:
+                ids = [songid]
+            else:
+                ids = [songid, songchart]
+            statistics = Parallel.flatten(Parallel.call(
+                [client.get_statistics for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_SONG,
+                ids,
+            ))
+        else:
+            statistics = []
+
+        retval: Dict[int, Dict[int, Dict[str, int]]] = {}
+        for stat in statistics:
+            songid = stat.get('song')
+            songchart = stat.get('chart')
+
+            if songid is None or songchart is None:
+                continue
+            songid = int(songid)
+            songchart = int(songchart)
+
+            if songid not in retval:
+                retval[songid] = {}
+            if songchart not in retval[songid]:
+                retval[songid][songchart] = {
+                    'plays': 0,
+                    'clears': 0,
+                    'combos': 0,
+                }
+
+            def get_val(v: str) -> int:
+                out = stat.get(v, -1)
+                if out < 0:
+                    out = 0
+                return out
+
+            retval[songid][songchart]['plays'] += get_val('plays')
+            retval[songid][songchart]['clears'] += get_val('clears')
+            retval[songid][songchart]['combos'] += get_val('combos')
+
+        return retval
+
+    def __format_ddr_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.DDR,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'groove': {
+                    'air': int(data['groove']['air']),
+                    'chaos': int(data['groove']['chaos']),
+                    'freeze': int(data['groove']['freeze']),
+                    'stream': int(data['groove']['stream']),
+                    'voltage': int(data['groove']['voltage']),
+                },
+                'bpm_min': int(data['bpm_min']),
+                'bpm_max': int(data['bpm_max']),
+                'category': int(data['category']),
+                'difficulty': int(data['difficulty']),
+                'edit_id': int(data['editid']),
+            },
+        )
+
+    def __format_iidx_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.IIDX,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'bpm_min': int(data['bpm_min']),
+                'bpm_max': int(data['bpm_max']),
+                'notecount': int(data['notecount']),
+                'difficulty': int(data['difficulty']),
+            },
+        )
+
+    def __format_jubeat_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.JUBEAT,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'bpm_min': int(data['bpm_min']),
+                'bpm_max': int(data['bpm_max']),
+                'difficulty': int(data['difficulty']),
+            },
+        )
+
+    def __format_museca_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.MUSECA,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'bpm_min': int(data['bpm_min']),
+                'bpm_max': int(data['bpm_max']),
+                'limited': int(data['limited']),
+                'difficulty': int(data['difficulty']),
+            },
+        )
+
+    def __format_popn_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.POPN_MUSIC,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'difficulty': int(data['difficulty']),
+                'category': str(data['category']),
+            },
+        )
+
+    def __format_reflec_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.REFLEC_BEAT,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'difficulty': int(data['difficulty']),
+                'folder': int(data['category']),
+                'chart_id': str(data['musicid']),
+            },
+        )
+
+    def __format_sdvx_song(
+        self,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Song:
+        return Song(
+            game=GameConstants.SDVX,
+            version=version,
+            songid=songid,
+            songchart=songchart,
+            name=name,
+            artist=artist,
+            genre=genre,
+            data={
+                'bpm_min': int(data['bpm_min']),
+                'bpm_max': int(data['bpm_max']),
+                'limited': int(data['limited']),
+                'difficulty': int(data['difficulty']),
+            },
+        )
+
+    def __format_song(
+        self,
+        game: str,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> Optional[Song]:
+        if game == GameConstants.DDR:
+            return self.__format_ddr_song(version, songid, songchart, name, artist, genre, data)
+        if game == GameConstants.IIDX:
+            return self.__format_iidx_song(version, songid, songchart, name, artist, genre, data)
+        if game == GameConstants.JUBEAT:
+            return self.__format_jubeat_song(version, songid, songchart, name, artist, genre, data)
+        if game == GameConstants.MUSECA:
+            return self.__format_museca_song(version, songid, songchart, name, artist, genre, data)
+        if game == GameConstants.POPN_MUSIC:
+            return self.__format_popn_song(version, songid, songchart, name, artist, genre, data)
+        if game == GameConstants.REFLEC_BEAT:
+            return self.__format_reflec_song(version, songid, songchart, name, artist, genre, data)
+        if game == GameConstants.SDVX:
+            return self.__format_sdvx_song(version, songid, songchart, name, artist, genre, data)
+        return None
+
+    def get_all_songs(
+        self,
+        game: str,
+        version: Optional[int]=None,
+    ) -> List[Song]:
+        """
+        Given a game and a version, look up all song/chart combos associated with that game.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+
+        Returns:
+            A list of Song objects detailing the song information for each song.
+        """
+        if version is None:
+            # We could do a ton of work to support this by iterating over all versions
+            # and combining, but this isn't going to be used in that manner, so lets
+            # skip that for now.
+            return []
+
+        catalogs: List[Dict[str, List[Dict[str, Any]]]] = Parallel.call(
+            [client.get_catalog for client in self.clients],
+            game,
+            version
+        )
+        retval: List[Song] = []
+        seen: Set[str] = set()
+        for catalog in catalogs:
+            for entry in catalog.get('songs', []):
+                song = self.__format_song(
+                    game,
+                    version,
+                    int(entry['song']),
+                    int(entry['chart']),
+                    str(entry['title'] if entry['title'] is not None else "") or None,
+                    str(entry['artist'] if entry['artist'] is not None else "") or None,
+                    str(entry['genre'] if entry['genre'] is not None else "") or None,
+                    entry,
+                )
+                if song is None:
+                    continue
+
+                key = f"{song.id}_{song.chart}"
+                if key in seen:
+                    continue
+
+                retval.append(song)
+                seen.add(key)
+        return retval
diff --git a/bemani/data/api/user.py b/bemani/data/api/user.py
new file mode 100644
index 0000000..a25b2b2
--- /dev/null
+++ b/bemani/data/api/user.py
@@ -0,0 +1,292 @@
+import copy
+from typing import List, Tuple, Optional, Dict, Any
+
+from bemani.common import APIConstants, GameConstants, ValidatedDict, Parallel
+from bemani.data.interfaces import APIProviderInterface
+from bemani.data.api.base import BaseGlobalData
+from bemani.data.mysql.user import UserData
+from bemani.data.remoteuser import RemoteUser
+from bemani.data.types import UserID
+
+
+class GlobalUserData(BaseGlobalData):
+
+    def __init__(self, api: APIProviderInterface, user: UserData) -> None:
+        super().__init__(api)
+        self.user = user
+
+    def __format_ddr_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        updates = {}
+
+        area = profile.get_int('area', -1)
+        if area != -1:
+            updates['area'] = area
+
+        return updates
+
+    def __format_iidx_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        updates: Dict[str, Any] = {
+            'qpro': {},
+        }
+
+        area = profile.get_int('area', -1)
+        if area != -1:
+            updates['pid'] = area
+
+        qpro = profile.get_dict('qpro')
+        head = qpro.get_int('head', -1)
+        if head != -1:
+            updates['qpro']['head'] = head
+        hair = qpro.get_int('hair', -1)
+        if hair != -1:
+            updates['qpro']['hair'] = hair
+        face = qpro.get_int('face', -1)
+        if face != -1:
+            updates['qpro']['face'] = face
+        body = qpro.get_int('body', -1)
+        if body != -1:
+            updates['qpro']['body'] = body
+        hand = qpro.get_int('hand', -1)
+        if hand != -1:
+            updates['qpro']['hand'] = hand
+
+        return updates
+
+    def __format_jubeat_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        return {}
+
+    def __format_museca_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        return {}
+
+    def __format_popn_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        updates = {}
+
+        chara = profile.get_int('character', -1)
+        if chara != -1:
+            updates['chara'] = chara
+
+        return updates
+
+    def __format_reflec_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        updates = {}
+
+        icon = profile.get_int('icon', -1)
+        if icon != -1:
+            updates['config'] = {'icon_id': icon}
+
+        return updates
+
+    def __format_sdvx_profile(self, profile: ValidatedDict) -> Dict[str, Any]:
+        return {}
+
+    def __format_profile(self, profile: ValidatedDict) -> ValidatedDict:
+        base = {
+            'name': profile.get('name', ''),
+            'game': profile['game'],
+            'version': profile['version'],
+            'refid': profile['refid'],
+            'extid': profile['extid'],
+        }
+
+        if profile.get('game') == GameConstants.DDR:
+            base.update(self.__format_ddr_profile(profile))
+        if profile.get('game') == GameConstants.IIDX:
+            base.update(self.__format_iidx_profile(profile))
+        if profile.get('game') == GameConstants.JUBEAT:
+            base.update(self.__format_jubeat_profile(profile))
+        if profile.get('game') == GameConstants.MUSECA:
+            base.update(self.__format_museca_profile(profile))
+        if profile.get('game') == GameConstants.POPN_MUSIC:
+            base.update(self.__format_popn_profile(profile))
+        if profile.get('game') == GameConstants.REFLEC_BEAT:
+            base.update(self.__format_reflec_profile(profile))
+        if profile.get('game') == GameConstants.SDVX:
+            base.update(self.__format_sdvx_profile(profile))
+
+        return ValidatedDict(base)
+
+    def __profile_request(self, game: str, version: int, userid: UserID, exact: bool) -> Optional[ValidatedDict]:
+        # First, get or create the extid/refid for this virtual user
+        cardid = RemoteUser.userid_to_card(userid)
+        refid = self.user.get_refid(game, version, userid)
+        extid = self.user.get_extid(game, version, userid)
+
+        profiles = Parallel.flatten(Parallel.call(
+            [client.get_profiles for client in self.clients],
+            game,
+            version,
+            APIConstants.ID_TYPE_CARD,
+            [cardid],
+        ))
+        for profile in profiles:
+            cards = [card.upper() for card in profile.get('cards', [])]
+            if cardid in cards:
+                # Sanitize the returned data
+                profile = copy.deepcopy(profile)
+                del profile['cards']
+
+                exact_match = profile.get('match', 'partial') == 'exact'
+                if exact and (not exact_match):
+                    # This is a partial match, not for this game/version
+                    continue
+
+                if 'match' in profile:
+                    del profile['match']
+
+                # Add in our defaults we always provide
+                profile['game'] = game
+                profile['version'] = version if exact_match else 0
+                profile['refid'] = refid
+                profile['extid'] = extid
+
+                return self.__format_profile(ValidatedDict(profile))
+
+        return None
+
+    def from_cardid(self, cardid: str) -> Optional[UserID]:
+        userid = self.user.from_cardid(cardid)
+        if userid is None:
+            userid = RemoteUser.card_to_userid(cardid)
+        return userid
+
+    def from_refid(self, game: str, version: int, refid: str) -> Optional[UserID]:
+        return self.user.from_refid(game, version, refid)
+
+    def from_extid(self, game: str, version: int, extid: int) -> Optional[UserID]:
+        return self.user.from_extid(game, version, extid)
+
+    def get_profile(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        if RemoteUser.is_remote(userid):
+            return self.__profile_request(game, version, userid, exact=True)
+        else:
+            return self.user.get_profile(game, version, userid)
+
+    def get_any_profile(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        if RemoteUser.is_remote(userid):
+            return self.__profile_request(game, version, userid, exact=False)
+        else:
+            return self.user.get_any_profile(game, version, userid)
+
+    def get_any_profiles(self, game: str, version: int, userids: List[UserID]) -> List[Tuple[UserID, Optional[ValidatedDict]]]:
+        if len(userids) == 0:
+            return []
+
+        remote_ids = [
+            userid for userid in userids
+            if RemoteUser.is_remote(userid)
+        ]
+        local_ids = [
+            userid for userid in userids
+            if not RemoteUser.is_remote(userid)
+        ]
+
+        if len(remote_ids) == 0:
+            # We only have local profiles here, just pass on to the underlying layer
+            return self.user.get_any_profiles(game, version, local_ids)
+        else:
+            # We have to fetch some local profiles and some remote profiles, and then
+            # merge them together
+            card_to_userid = {
+                RemoteUser.userid_to_card(userid): userid
+                for userid in remote_ids
+            }
+
+            local_profiles, remote_profiles = Parallel.execute([
+                lambda: self.user.get_any_profiles(game, version, local_ids),
+                lambda: Parallel.flatten(Parallel.call(
+                    [client.get_profiles for client in self.clients],
+                    game,
+                    version,
+                    APIConstants.ID_TYPE_CARD,
+                    [RemoteUser.userid_to_card(userid) for userid in remote_ids],
+                ))
+            ])
+
+            for profile in remote_profiles:
+                cards = [card.upper() for card in profile.get('cards', [])]
+                for card in cards:
+                    # Map it back to the requested user
+                    userid = card_to_userid.get(card)
+                    if userid is None:
+                        continue
+
+                    # Sanitize the returned data
+                    profile = copy.deepcopy(profile)
+                    del profile['cards']
+
+                    exact_match = profile.get('match', 'partial') == 'exact'
+
+                    if 'match' in profile:
+                        del profile['match']
+
+                    refid = self.user.get_refid(game, version, userid)
+                    extid = self.user.get_extid(game, version, userid)
+
+                    # Add in our defaults we always provide
+                    profile['game'] = game
+                    profile['version'] = version if exact_match else 0
+                    profile['refid'] = refid
+                    profile['extid'] = extid
+
+                    local_profiles.append(
+                        (userid, self.__format_profile(ValidatedDict(profile))),
+                    )
+
+                    # Mark that we saw this card/user
+                    del card_to_userid[card]
+
+            # Finally, mark all missing remote profiles as None
+            for card in card_to_userid:
+                local_profiles.append((card_to_userid[card], None))
+
+            return local_profiles
+
+    def get_all_profiles(self, game: str, version: int) -> List[Tuple[UserID, ValidatedDict]]:
+        # Fetch local and remote profiles, and then merge by adding remote profiles to local
+        # profiles when we don't have a profile for that user ID yet.
+        local_cards, local_profiles, remote_profiles = Parallel.execute([
+            self.user.get_all_cards,
+            lambda: self.user.get_all_profiles(game, version),
+            lambda: Parallel.flatten(Parallel.call(
+                [client.get_profiles for client in self.clients],
+                game,
+                version,
+                APIConstants.ID_TYPE_SERVER,
+                [],
+            )),
+        ])
+
+        card_to_id = {cardid: userid for (cardid, userid) in local_cards}
+        id_to_profile = {userid: profile for (userid, profile) in local_profiles}
+
+        for profile in remote_profiles:
+            cardids = sorted([card.upper() for card in profile.get('cards', [])])
+            if len(cardids) == 0:
+                # We don't care about anonymous profiles
+                continue
+
+            local_cards = [cardid for cardid in cardids if cardid in card_to_id]
+            if len(local_cards) > 0:
+                # We have a local version of this profile!
+                continue
+
+            # Create a fake user with this profile
+            del profile['cards']
+
+            exact_match = profile.get('match', 'partial') == 'exact'
+            if not exact_match:
+                continue
+
+            userid = RemoteUser.card_to_userid(cardids[0])
+            refid = self.user.get_refid(game, version, userid)
+            extid = self.user.get_extid(game, version, userid)
+
+            # Add in our defaults we always provide
+            profile['game'] = game
+            profile['version'] = version
+            profile['refid'] = refid
+            profile['extid'] = extid
+
+            id_to_profile[userid] = self.__format_profile(ValidatedDict(profile))
+
+        return [(userid, id_to_profile[userid]) for userid in id_to_profile]
diff --git a/bemani/data/data.py b/bemani/data/data.py
new file mode 100644
index 0000000..8b35607
--- /dev/null
+++ b/bemani/data/data.py
@@ -0,0 +1,219 @@
+import os
+from typing import Dict, Any
+
+import alembic.config  # type: ignore
+from alembic.migration import MigrationContext  # type: ignore
+from alembic.autogenerate import compare_metadata  # type: ignore
+from sqlalchemy import create_engine  # type: ignore
+from sqlalchemy.orm import scoped_session  # type: ignore
+from sqlalchemy.orm import sessionmaker  # type: ignore
+from sqlalchemy.engine import Engine  # type: ignore
+from sqlalchemy.sql import text  # type: ignore
+from sqlalchemy.exc import ProgrammingError  # type: ignore
+
+from bemani.data.api.user import GlobalUserData
+from bemani.data.api.game import GlobalGameData
+from bemani.data.api.music import GlobalMusicData
+from bemani.data.mysql.base import metadata
+from bemani.data.mysql.user import UserData
+from bemani.data.mysql.music import MusicData
+from bemani.data.mysql.machine import MachineData
+from bemani.data.mysql.game import GameData
+from bemani.data.mysql.network import NetworkData
+from bemani.data.mysql.lobby import LobbyData
+from bemani.data.mysql.api import APIData
+
+
+class DBCreateException(Exception):
+    pass
+
+
+class LocalProvider:
+    """
+    A wrapper object for implementing local data operations only. Right
+    now this goes to the MySQL classes and talks to the backend DB.
+    """
+
+    def __init__(
+        self,
+        user: UserData,
+        music: MusicData,
+        machine: MachineData,
+        game: GameData,
+        network: NetworkData,
+        lobby: LobbyData,
+        api: APIData,
+    ) -> None:
+        self.user = user
+        self.music = music
+        self.machine = machine
+        self.game = game
+        self.network = network
+        self.lobby = lobby
+        self.api = api
+
+
+class GlobalProvider:
+    """
+    A class that handles fetching data locally and from remote data APIs.
+    This means combining data fetched from local MySQL with data fetched
+    from remote servers that support BEMAPI.
+    """
+
+    def __init__(
+        self,
+        local: LocalProvider,
+    ) -> None:
+        self.user = GlobalUserData(
+            local.api,
+            local.user,
+        )
+        self.music = GlobalMusicData(
+            local.api,
+            local.user,
+            local.music,
+        )
+        self.game = GlobalGameData(
+            local.api,
+        )
+
+
+class Data:
+    """
+    An object that is meant to be used as a singleton, in order to hold
+    DB configuration info and provide a set of functions for querying
+    and storing data.
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        """
+        Initializes the data object.
+
+        Parameters:
+            config - A config structure with a 'database' section which is used
+                     to initialize an internal DB connection.
+        """
+        session_factory = sessionmaker(
+            bind=config['database']['engine'],
+            autoflush=True,
+            autocommit=True,
+        )
+        self.__config = config
+        self.__session = scoped_session(session_factory)
+        self.__url = Data.sqlalchemy_url(config)
+        self.__user = UserData(config, self.__session)
+        self.__music = MusicData(config, self.__session)
+        self.__machine = MachineData(config, self.__session)
+        self.__game = GameData(config, self.__session)
+        self.__network = NetworkData(config, self.__session)
+        self.__lobby = LobbyData(config, self.__session)
+        self.__api = APIData(config, self.__session)
+        self.local = LocalProvider(
+            self.__user,
+            self.__music,
+            self.__machine,
+            self.__game,
+            self.__network,
+            self.__lobby,
+            self.__api,
+        )
+        self.remote = GlobalProvider(self.local)
+
+    @classmethod
+    def sqlalchemy_url(cls, config: Dict[str, Any]) -> str:
+        return "mysql://{}:{}@{}/{}?charset=utf8mb4".format(
+            config['database']['user'],
+            config['database']['password'],
+            config['database']['address'],
+            config['database']['database'],
+        )
+
+    @classmethod
+    def create_engine(cls, config: Dict[str, Any]) -> Engine:
+        return create_engine(  # type: ignore
+            Data.sqlalchemy_url(config),
+            pool_recycle=3600,
+        )
+
+    def __exists(self) -> bool:
+        # See if the DB was already created
+        try:
+            cursor = self.__session.execute(text('SELECT COUNT(version_num) AS count FROM alembic_version'))
+            return (cursor.fetchone()['count'] == 1)
+        except ProgrammingError:
+            return False
+
+    def __alembic_cmd(self, command: str, *args: str) -> None:
+        base_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'migrations/')
+        alembicArgs = [
+            '-c',
+            os.path.join(base_dir, 'alembic.ini'),
+            '-x',
+            'script_location={}'.format(base_dir),
+            '-x',
+            'sqlalchemy.url={}'.format(self.__url),
+            command,
+        ]
+        alembicArgs.extend(args)
+        os.chdir(base_dir)
+        alembic.config.main(argv=alembicArgs)
+
+    def create(self) -> None:
+        """
+        Create any tables that need to be created.
+        """
+        if self.__exists():
+            # Cowardly refused to do anything, we should be using the upgrade path instead.
+            raise DBCreateException('Tables already created, use upgrade to upgrade schema!')
+
+        metadata.create_all(  # type: ignore
+            self.__config['database']['engine'].connect(),
+            checkfirst=True,
+        )
+
+        # Stamp the end revision as if alembic had created it, so it can take off after this.
+        self.__alembic_cmd(
+            'stamp',
+            'head',
+        )
+
+    def generate(self, message: str, allow_empty: bool) -> None:
+        """
+        Generate upgrade scripts using alembic.
+        """
+        if not self.__exists():
+            raise DBCreateException('Tables have not been created yet, use create to create them!')
+
+        # Verify that there are actual changes, and refuse to create empty migration scripts
+        context = MigrationContext.configure(self.__config['database']['engine'].connect(), opts={'compare_type': True})
+        diff = compare_metadata(context, metadata)
+        if (not allow_empty) and (len(diff) == 0):
+            raise DBCreateException('There is nothing different between code and the DB, refusing to create migration!')
+
+        self.__alembic_cmd(
+            'revision',
+            '--autogenerate',
+            '-m',
+            message,
+        )
+
+    def upgrade(self) -> None:
+        """
+        Upgrade an existing DB to the current model.
+        """
+        if not self.__exists():
+            raise DBCreateException('Tables have not been created yet, use create to create them!')
+
+        self.__alembic_cmd(
+            'upgrade',
+            'head',
+        )
+
+    def close(self) -> None:
+        """
+        Close any open data connection.
+        """
+        # Make sure we don't leak connections between web requests
+        if self.__session is not None:
+            self.__session.close()
+            self.__session = None
diff --git a/bemani/data/exceptions.py b/bemani/data/exceptions.py
new file mode 100644
index 0000000..9f957be
--- /dev/null
+++ b/bemani/data/exceptions.py
@@ -0,0 +1,2 @@
+class ScoreSaveException(Exception):
+    pass
diff --git a/bemani/data/interfaces.py b/bemani/data/interfaces.py
new file mode 100644
index 0000000..5af858e
--- /dev/null
+++ b/bemani/data/interfaces.py
@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+from bemani.data.types import Server
+
+
+class APIProviderInterface(ABC):
+
+    @abstractmethod
+    def get_all_servers(self) -> List[Server]:
+        """
+        Grab all authorized servers in the system.
+
+        Returns:
+            A list of Server objects sorted by add time.
+        """
diff --git a/bemani/data/migrations/alembic.ini b/bemani/data/migrations/alembic.ini
new file mode 100644
index 0000000..26b89ea
--- /dev/null
+++ b/bemani/data/migrations/alembic.ini
@@ -0,0 +1,64 @@
+# A generic, single database configuration.
+
+[alembic]
+script_location=.
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# max length of characters to apply to the
+# "slug" field
+#truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; this defaults
+# to migrations//versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path
+# version_locations = %(here)s/bar %(here)s/bat migrations//versions
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
diff --git a/bemani/data/migrations/env.py b/bemani/data/migrations/env.py
new file mode 100644
index 0000000..3bfa16e
--- /dev/null
+++ b/bemani/data/migrations/env.py
@@ -0,0 +1,81 @@
+from __future__ import with_statement
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+from logging.config import fileConfig
+
+from bemani.data.mysql.base import metadata
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    raise Exception('Not implemented or configured!')
+
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url, target_metadata=target_metadata, literal_binds=True)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    ini_section = config.get_section(config.config_ini_section)
+    overrides = context.get_x_argument(as_dictionary=True)
+    for override in overrides:
+        ini_section[override] = overrides[override]
+
+    connectable = engine_from_config(
+        ini_section,
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool)
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            compare_type=True,
+            compare_server_default=True,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
diff --git a/bemani/data/migrations/script.py.mako b/bemani/data/migrations/script.py.mako
new file mode 100644
index 0000000..2c01563
--- /dev/null
+++ b/bemani/data/migrations/script.py.mako
@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}
diff --git a/bemani/data/migrations/versions/04f3eab9ae7a_add_audit_table_for_audit_entries.py b/bemani/data/migrations/versions/04f3eab9ae7a_add_audit_table_for_audit_entries.py
new file mode 100644
index 0000000..fb6109d
--- /dev/null
+++ b/bemani/data/migrations/versions/04f3eab9ae7a_add_audit_table_for_audit_entries.py
@@ -0,0 +1,37 @@
+"""Add audit table for audit entries.
+
+Revision ID: 04f3eab9ae7a
+Revises: b517e37877c8
+Create Date: 2017-04-11 18:40:04.195180
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '04f3eab9ae7a'
+down_revision = 'b517e37877c8'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('audit',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('timestamp', sa.Integer(), nullable=False),
+    sa.Column('type', sa.String(length=64), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    mysql_charset='utf8mb4'
+    )
+    op.create_index(op.f('ix_audit_timestamp'), 'audit', ['timestamp'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_audit_timestamp'), table_name='audit')
+    op.drop_table('audit')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/0df7f3dc4d23_add_client_and_server_tables_for_.py b/bemani/data/migrations/versions/0df7f3dc4d23_add_client_and_server_tables_for_.py
new file mode 100644
index 0000000..55cf219
--- /dev/null
+++ b/bemani/data/migrations/versions/0df7f3dc4d23_add_client_and_server_tables_for_.py
@@ -0,0 +1,48 @@
+"""Add client and server tables for managing API connections.
+
+Revision ID: 0df7f3dc4d23
+Revises: d041922684eb
+Create Date: 2018-01-31 14:35:26.640344
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '0df7f3dc4d23'
+down_revision = 'd041922684eb'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('client',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('timestamp', sa.Integer(), nullable=False),
+    sa.Column('name', sa.String(length=255), nullable=False),
+    sa.Column('token', sa.String(length=36), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    mysql_charset='utf8mb4'
+    )
+    op.create_index(op.f('ix_client_timestamp'), 'client', ['timestamp'], unique=False)
+    op.create_table('server',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('timestamp', sa.Integer(), nullable=False),
+    sa.Column('uri', sa.String(length=1024), nullable=False),
+    sa.Column('token', sa.String(length=36), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    mysql_charset='utf8mb4'
+    )
+    op.create_index(op.f('ix_server_timestamp'), 'server', ['timestamp'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_server_timestamp'), table_name='server')
+    op.drop_table('server')
+    op.drop_index(op.f('ix_client_timestamp'), table_name='client')
+    op.drop_table('client')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/21c19a671b3b_add_user_link_table.py b/bemani/data/migrations/versions/21c19a671b3b_add_user_link_table.py
new file mode 100644
index 0000000..60205e6
--- /dev/null
+++ b/bemani/data/migrations/versions/21c19a671b3b_add_user_link_table.py
@@ -0,0 +1,37 @@
+"""Add user link table.
+
+Revision ID: 21c19a671b3b
+Revises: f1fe9fce9ace
+Create Date: 2017-02-09 20:28:01.361801
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '21c19a671b3b'
+down_revision = 'f1fe9fce9ace'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('link',
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('userid', sa.Integer(), nullable=False),
+    sa.Column('type', sa.String(length=64), nullable=False),
+    sa.Column('other_userid', sa.Integer(), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.UniqueConstraint('game', 'version', 'userid', 'type', 'other_userid', name='game_version_userid_type_other_uuserid'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('link')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/23a589a1785c_create_lobby_table.py b/bemani/data/migrations/versions/23a589a1785c_create_lobby_table.py
new file mode 100644
index 0000000..f46b329
--- /dev/null
+++ b/bemani/data/migrations/versions/23a589a1785c_create_lobby_table.py
@@ -0,0 +1,40 @@
+"""Create lobby table.
+
+Revision ID: 23a589a1785c
+Revises: 56dd21b994fe
+Create Date: 2017-12-04 22:19:12.612743
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '23a589a1785c'
+down_revision = '56dd21b994fe'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('lobby',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('userid', sa.Integer(), nullable=False),
+    sa.Column('time', sa.Integer(), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
+    mysql_charset='utf8mb4'
+    )
+    op.create_index(op.f('ix_lobby_time'), 'lobby', ['time'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_lobby_time'), table_name='lobby')
+    op.drop_table('lobby')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/25e9f367b137_biginteger_for_userid_so_we_can_store_.py b/bemani/data/migrations/versions/25e9f367b137_biginteger_for_userid_so_we_can_store_.py
new file mode 100644
index 0000000..ba788bd
--- /dev/null
+++ b/bemani/data/migrations/versions/25e9f367b137_biginteger_for_userid_so_we_can_store_.py
@@ -0,0 +1,137 @@
+"""BigInteger for UserID so we can store virtual IDs (cards).
+
+Revision ID: 25e9f367b137
+Revises: d02f0bf59400
+Create Date: 2018-02-18 22:42:11.013666
+
+"""
+from alembic import op
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = '25e9f367b137'
+down_revision = 'd02f0bf59400'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('arcade_owner', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('audit', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=True)
+    op.alter_column('balance', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('card', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('extid', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('game_settings', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('link', 'other_userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('link', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('lobby', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('playsession', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('refid', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('score', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('score_history', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    op.alter_column('series_achievement', 'userid',
+               existing_type=mysql.INTEGER(display_width=11),
+               type_=mysql.BIGINT(unsigned=True),
+               existing_nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('series_achievement', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('score_history', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('score', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('refid', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('playsession', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('lobby', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('link', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('link', 'other_userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('game_settings', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('extid', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('card', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('balance', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    op.alter_column('audit', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=True)
+    op.alter_column('arcade_owner', 'userid',
+               existing_type=mysql.BIGINT(unsigned=True),
+               type_=mysql.INTEGER(display_width=11),
+               existing_nullable=False)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/26dcace5d5d4_add_time_sensitive_game_settings_table.py b/bemani/data/migrations/versions/26dcace5d5d4_add_time_sensitive_game_settings_table.py
new file mode 100644
index 0000000..179842e
--- /dev/null
+++ b/bemani/data/migrations/versions/26dcace5d5d4_add_time_sensitive_game_settings_table.py
@@ -0,0 +1,37 @@
+"""Add time-sensitive game settings table.
+
+Revision ID: 26dcace5d5d4
+Revises: d764dd3489e6
+Create Date: 2016-12-22 20:31:22.574245
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '26dcace5d5d4'
+down_revision = 'd764dd3489e6'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('time_sensitive_settings',
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('name', sa.String(length=32), nullable=False),
+    sa.Column('start_time', sa.Integer(), nullable=False),
+    sa.Column('end_time', sa.Integer(), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.UniqueConstraint('game', 'version', 'name', 'start_time', name='game_version_name_start_time'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('time_sensitive_settings')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/2a3ebcd7d840_add_time_based_achievements.py b/bemani/data/migrations/versions/2a3ebcd7d840_add_time_based_achievements.py
new file mode 100644
index 0000000..08a5f82
--- /dev/null
+++ b/bemani/data/migrations/versions/2a3ebcd7d840_add_time_based_achievements.py
@@ -0,0 +1,38 @@
+"""Add time-based achievements.
+
+Revision ID: 2a3ebcd7d840
+Revises: bc7d717a37d6
+Create Date: 2017-04-27 16:28:15.365526
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '2a3ebcd7d840'
+down_revision = 'bc7d717a37d6'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('time_based_achievement',
+    sa.Column('refid', sa.String(length=16), nullable=False),
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('type', sa.String(length=64), nullable=False),
+    sa.Column('timestamp', sa.Integer(), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.UniqueConstraint('refid', 'id', 'type', 'timestamp', name='refid_id_type_timestamp'),
+    mysql_charset='utf8mb4'
+    )
+    op.create_index(op.f('ix_time_based_achievement_timestamp'), 'time_based_achievement', ['timestamp'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_time_based_achievement_timestamp'), table_name='time_based_achievement')
+    op.drop_table('time_based_achievement')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/314f97567294_index_type_column_for_audit_events.py b/bemani/data/migrations/versions/314f97567294_index_type_column_for_audit_events.py
new file mode 100644
index 0000000..9f2fb0f
--- /dev/null
+++ b/bemani/data/migrations/versions/314f97567294_index_type_column_for_audit_events.py
@@ -0,0 +1,27 @@
+"""Index type column for audit events.
+
+Revision ID: 314f97567294
+Revises: 36b54cc0bd09
+Create Date: 2017-04-14 19:25:51.711211
+
+"""
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = '314f97567294'
+down_revision = '36b54cc0bd09'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_index(op.f('ix_audit_type'), 'audit', ['type'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_audit_type'), table_name='audit')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/3308af0e619f_add_game_column_to_machine.py b/bemani/data/migrations/versions/3308af0e619f_add_game_column_to_machine.py
new file mode 100644
index 0000000..8144f3d
--- /dev/null
+++ b/bemani/data/migrations/versions/3308af0e619f_add_game_column_to_machine.py
@@ -0,0 +1,28 @@
+"""Add game column to machine.
+
+Revision ID: 3308af0e619f
+Revises: 38ad3e2db188
+Create Date: 2017-08-17 20:08:27.228540
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '3308af0e619f'
+down_revision = '38ad3e2db188'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('machine', sa.Column('game', sa.String(length=20), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('machine', 'game')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/36b54cc0bd09_make_pin_field_non_nullable.py b/bemani/data/migrations/versions/36b54cc0bd09_make_pin_field_non_nullable.py
new file mode 100644
index 0000000..6eff2ad
--- /dev/null
+++ b/bemani/data/migrations/versions/36b54cc0bd09_make_pin_field_non_nullable.py
@@ -0,0 +1,31 @@
+"""Make pin field non-nullable.
+
+Revision ID: 36b54cc0bd09
+Revises: b86fe18bfbd3
+Create Date: 2017-04-14 18:02:47.780985
+
+"""
+from alembic import op
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = '36b54cc0bd09'
+down_revision = 'b86fe18bfbd3'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('arcade', 'pin',
+               existing_type=mysql.VARCHAR(length=8),
+               nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('arcade', 'pin',
+               existing_type=mysql.VARCHAR(length=8),
+               nullable=True)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/36dff3ac15a3_hydrate_ddr_and_reflec_beat_song_db_for_.py b/bemani/data/migrations/versions/36dff3ac15a3_hydrate_ddr_and_reflec_beat_song_db_for_.py
new file mode 100644
index 0000000..9317319
--- /dev/null
+++ b/bemani/data/migrations/versions/36dff3ac15a3_hydrate_ddr_and_reflec_beat_song_db_for_.py
@@ -0,0 +1,68 @@
+"""Hydrate DDR and Reflec Beat song DB for catalog BEMAPI support.
+
+Revision ID: 36dff3ac15a3
+Revises: a522b9e42df4
+Create Date: 2019-12-07 03:39:55.137275
+
+"""
+import json
+from alembic import op
+from sqlalchemy.sql import text
+from typing import Dict, Any
+
+
+# revision identifiers, used by Alembic.
+revision = '36dff3ac15a3'
+down_revision = 'a522b9e42df4'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # Grab reflec beat LUT
+    sql = "SELECT id, genre FROM music WHERE game = 'reflec' AND version = 0"
+    results = conn.execute(text(sql), {})
+    reflec_todo: Dict[int, str] = {}
+    for result in results:
+        reflec_todo[result['id']] = result['genre']
+
+    # Now, hydrate the existing data
+    sql = "SELECT id, version, data FROM music WHERE game = 'reflec'"
+    results = conn.execute(text(sql), {})
+    for result in results:
+        data = json.loads(result['data'])
+        data = {**data, 'chart_id': reflec_todo[result['id']]}
+
+        sql = "UPDATE music SET data = :data WHERE game = 'reflec' AND id = :id AND version = :version"
+        conn.execute(
+            text(sql),
+            {
+                'data': json.dumps(data),
+                'id': result['id'],
+                'version': result['version'],
+            }
+        )
+
+    # Grab DDR LUT
+    sql = "SELECT id, songid, data FROM music WHERE game = 'ddr' AND version = 0"
+    results = conn.execute(text(sql), {})
+    for result in results:
+        data = json.loads(result['data'])
+        data = {**data, 'edit_id': result['songid']}
+
+        sql = "UPDATE music SET data = :data WHERE game = 'ddr' AND id = :id"
+        conn.execute(
+            text(sql),
+            {
+                'data': json.dumps(data),
+                'id': result['id'],
+            }
+        )
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/38ad3e2db188_add_catalog_table.py b/bemani/data/migrations/versions/38ad3e2db188_add_catalog_table.py
new file mode 100644
index 0000000..9770c27
--- /dev/null
+++ b/bemani/data/migrations/versions/38ad3e2db188_add_catalog_table.py
@@ -0,0 +1,36 @@
+"""Add catalog table.
+
+Revision ID: 38ad3e2db188
+Revises: 2a3ebcd7d840
+Create Date: 2017-07-20 19:36:46.537670
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '38ad3e2db188'
+down_revision = '2a3ebcd7d840'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('catalog',
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('type', sa.String(length=64), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.UniqueConstraint('game', 'version', 'id', 'type', name='game_version_id_type'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('catalog')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/3e1cda9a853f_add_description_column_for_machine.py b/bemani/data/migrations/versions/3e1cda9a853f_add_description_column_for_machine.py
new file mode 100644
index 0000000..744bd38
--- /dev/null
+++ b/bemani/data/migrations/versions/3e1cda9a853f_add_description_column_for_machine.py
@@ -0,0 +1,28 @@
+"""Add description column for machine.
+
+Revision ID: 3e1cda9a853f
+Revises: 26dcace5d5d4
+Create Date: 2017-01-03 23:19:47.702107
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '3e1cda9a853f'
+down_revision = '26dcace5d5d4'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('machine', sa.Column('description', sa.String(length=255), nullable=False))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('machine', 'description')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/3f621cef0a71_adding_timestamp_column_to_records_to_.py b/bemani/data/migrations/versions/3f621cef0a71_adding_timestamp_column_to_records_to_.py
new file mode 100644
index 0000000..fd5823f
--- /dev/null
+++ b/bemani/data/migrations/versions/3f621cef0a71_adding_timestamp_column_to_records_to_.py
@@ -0,0 +1,43 @@
+"""Adding timestamp column to records to implement king-of-the-hill scoring.
+
+Revision ID: 3f621cef0a71
+Revises: f270dd360519
+Create Date: 2017-03-21 20:29:38.813890
+
+"""
+import calendar
+from datetime import datetime
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import text
+
+
+# revision identifiers, used by Alembic.
+revision = '3f621cef0a71'
+down_revision = 'f270dd360519'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('score', sa.Column('timestamp', sa.Integer(), nullable=True))
+    op.create_index(op.f('ix_score_points'), 'score', ['points'], unique=False)
+    op.create_index(op.f('ix_score_timestamp'), 'score', ['timestamp'], unique=False)
+    # ### end Alembic commands ###
+
+    # Set a default timestamp for all existing scores
+    now = datetime.utcnow()
+    timestamp = calendar.timegm(now.utctimetuple())
+    sql = "UPDATE score SET timestamp = :timestamp WHERE timestamp IS null"
+    conn.execute(text(sql), {'timestamp': timestamp})
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_score_timestamp'), table_name='score')
+    op.drop_index(op.f('ix_score_points'), table_name='score')
+    op.drop_column('score', 'timestamp')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/428e24dea6f3_create_data_column_so_machines_can_.py b/bemani/data/migrations/versions/428e24dea6f3_create_data_column_so_machines_can_.py
new file mode 100644
index 0000000..1178049
--- /dev/null
+++ b/bemani/data/migrations/versions/428e24dea6f3_create_data_column_so_machines_can_.py
@@ -0,0 +1,28 @@
+"""Create data column so machines can include extra settings.
+
+Revision ID: 428e24dea6f3
+Revises: 23a589a1785c
+Create Date: 2017-12-18 22:43:42.133159
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '428e24dea6f3'
+down_revision = '23a589a1785c'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('machine', sa.Column('data', sa.JSON(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('machine', 'data')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/437a91b37583_get_rid_of_plays_column_use_count_of_.py b/bemani/data/migrations/versions/437a91b37583_get_rid_of_plays_column_use_count_of_.py
new file mode 100644
index 0000000..b45ed31
--- /dev/null
+++ b/bemani/data/migrations/versions/437a91b37583_get_rid_of_plays_column_use_count_of_.py
@@ -0,0 +1,28 @@
+"""Get rid of plays column, use count of columns in score_history instead.
+
+Revision ID: 437a91b37583
+Revises: 3e1cda9a853f
+Create Date: 2017-01-17 23:17:42.514334
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = '437a91b37583'
+down_revision = '3e1cda9a853f'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('score', 'plays')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('score', sa.Column('plays', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False))
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/45438cc39f6d_add_userid_arcadeid_columns_to_audit_.py b/bemani/data/migrations/versions/45438cc39f6d_add_userid_arcadeid_columns_to_audit_.py
new file mode 100644
index 0000000..565692e
--- /dev/null
+++ b/bemani/data/migrations/versions/45438cc39f6d_add_userid_arcadeid_columns_to_audit_.py
@@ -0,0 +1,34 @@
+"""Add userid/arcadeid columns to audit logs for PASELI audits.
+
+Revision ID: 45438cc39f6d
+Revises: 04f3eab9ae7a
+Create Date: 2017-04-12 18:08:47.521622
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '45438cc39f6d'
+down_revision = '04f3eab9ae7a'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('audit', sa.Column('arcadeid', sa.Integer(), nullable=True))
+    op.add_column('audit', sa.Column('userid', sa.Integer(), nullable=True))
+    op.create_index(op.f('ix_audit_arcadeid'), 'audit', ['arcadeid'], unique=False)
+    op.create_index(op.f('ix_audit_userid'), 'audit', ['userid'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_audit_userid'), table_name='audit')
+    op.drop_index(op.f('ix_audit_arcadeid'), table_name='audit')
+    op.drop_column('audit', 'userid')
+    op.drop_column('audit', 'arcadeid')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/56dd21b994fe_create_play_session_table.py b/bemani/data/migrations/versions/56dd21b994fe_create_play_session_table.py
new file mode 100644
index 0000000..2610b91
--- /dev/null
+++ b/bemani/data/migrations/versions/56dd21b994fe_create_play_session_table.py
@@ -0,0 +1,40 @@
+"""Create play session table.
+
+Revision ID: 56dd21b994fe
+Revises: 8666c2253770
+Create Date: 2017-12-04 21:47:30.701495
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '56dd21b994fe'
+down_revision = '8666c2253770'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('playsession',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('userid', sa.Integer(), nullable=False),
+    sa.Column('time', sa.Integer(), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
+    mysql_charset='utf8mb4'
+    )
+    op.create_index(op.f('ix_playsession_time'), 'playsession', ['time'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_playsession_time'), table_name='playsession')
+    op.drop_table('playsession')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/5c927879651b_fix_sdvx_song_display_issue_in_music_.py b/bemani/data/migrations/versions/5c927879651b_fix_sdvx_song_display_issue_in_music_.py
new file mode 100644
index 0000000..659a110
--- /dev/null
+++ b/bemani/data/migrations/versions/5c927879651b_fix_sdvx_song_display_issue_in_music_.py
@@ -0,0 +1,65 @@
+# vim: set fileencoding=utf-8
+
+"""Fix SDVX song display issue in music data.
+
+Revision ID: 5c927879651b
+Revises: 5fb631197b27
+Create Date: 2019-09-08 06:12:56.681720
+
+"""
+from alembic import op
+from sqlalchemy.sql import text
+
+
+# revision identifiers, used by Alembic.
+revision = '5c927879651b'
+down_revision = '5fb631197b27'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    sql = "SELECT id, name, artist FROM music WHERE game = 'sdvx'"
+    results = conn.execute(text(sql), {})
+    for result in results:
+        musicid = result['id']
+        new_title = title = result['name']
+        new_artist = artist = result['artist']
+
+        # Fix accent issues with title/artist
+        accent_lut: Dict[str, str] = {
+            '驩': 'Ø',
+            '齲': '♥',
+            '齶': '♡',
+            '趁': 'Ǣ',
+            '騫': 'á',
+            '曦': 'à',
+            '驫': 'ā',
+            '齷': 'é',
+            '曩': 'è',
+            '䧺': 'ê',
+            '骭': 'ü',
+        }
+
+        for orig, rep in accent_lut.items():
+            new_title = new_title.replace(orig, rep)
+            new_artist = new_artist.replace(orig, rep)
+
+        if new_title != title or new_artist != artist:
+            sql = "UPDATE music SET name = :name, artist = :artist WHERE id = :id AND game = 'sdvx'"
+            conn.execute(
+                text(sql),
+                {
+                    'id': musicid,
+                    'name': new_title,
+                    'artist': new_artist,
+                },
+            )
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/5fb631197b27_config_for_what_info_to_pull_from_.py b/bemani/data/migrations/versions/5fb631197b27_config_for_what_info_to_pull_from_.py
new file mode 100644
index 0000000..8659889
--- /dev/null
+++ b/bemani/data/migrations/versions/5fb631197b27_config_for_what_info_to_pull_from_.py
@@ -0,0 +1,28 @@
+"""Config for what info to pull from remote servers.
+
+Revision ID: 5fb631197b27
+Revises: 25e9f367b137
+Create Date: 2018-03-20 21:38:34.023921
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '5fb631197b27'
+down_revision = '25e9f367b137'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('server', sa.Column('config', sa.Integer(), nullable=False))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('server', 'config')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/691d49925c52_allow_multiple_owners_of_arcades.py b/bemani/data/migrations/versions/691d49925c52_allow_multiple_owners_of_arcades.py
new file mode 100644
index 0000000..5470a34
--- /dev/null
+++ b/bemani/data/migrations/versions/691d49925c52_allow_multiple_owners_of_arcades.py
@@ -0,0 +1,35 @@
+"""Allow multiple owners of arcades.
+
+Revision ID: 691d49925c52
+Revises: afd66ee7c0e0
+Create Date: 2016-12-07 17:00:19.943809
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = '691d49925c52'
+down_revision = 'afd66ee7c0e0'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('arcade_owner',
+    sa.Column('userid', sa.Integer(), nullable=False),
+    sa.Column('arcadeid', sa.Integer(), nullable=False),
+    sa.UniqueConstraint('userid', 'arcadeid', name='userid_arcadeid'),
+    mysql_charset='utf8mb4'
+    )
+    op.drop_column('arcade', 'userid')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('arcade', sa.Column('userid', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True))
+    op.drop_table('arcade_owner')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/693fadb665ba_migration_for_ddr_ace_common_options.py b/bemani/data/migrations/versions/693fadb665ba_migration_for_ddr_ace_common_options.py
new file mode 100644
index 0000000..b9e4f3e
--- /dev/null
+++ b/bemani/data/migrations/versions/693fadb665ba_migration_for_ddr_ace_common_options.py
@@ -0,0 +1,63 @@
+"""Migration for DDR Ace common options.
+
+Revision ID: 693fadb665ba
+Revises: ad911b666f22
+Create Date: 2018-02-18 12:10:29.357996
+
+"""
+import json
+from alembic import op
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = '693fadb665ba'
+down_revision = 'ad911b666f22'
+branch_labels = None
+depends_on = None
+
+
+GAME_COMMON_AREA_OFFSET = 1
+GAME_COMMON_WEIGHT_DISPLAY_OFFSET = 3
+GAME_COMMON_CHARACTER_OFFSET = 4
+GAME_COMMON_WEIGHT_OFFSET = 17
+GAME_COMMON_NAME_OFFSET = 25
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    sql = "SELECT refid, data FROM profile WHERE refid IN (SELECT refid FROM refid WHERE game = 'ddr' AND version = 16)"
+    results = conn.execute(text(sql), {})
+    for result in results:
+        refid = result['refid']
+        profile = json.loads(result['data'])
+
+        if (
+            'usergamedata' in profile and
+            'COMMON' in profile['usergamedata'] and
+            'strdata' in profile['usergamedata']['COMMON']
+        ):
+            common = bytes(profile['usergamedata']['COMMON']['strdata'][1:]).split(b',')
+            if 'name' not in profile:
+                profile['name'] = common[GAME_COMMON_NAME_OFFSET].decode('ascii')
+            if 'area' not in profile:
+                profile['area'] = int(common[GAME_COMMON_AREA_OFFSET].decode('ascii'), 16)
+            if 'workout_mode' not in profile:
+                profile['workout_mode'] = int(common[GAME_COMMON_WEIGHT_DISPLAY_OFFSET].decode('ascii'), 16) != 0
+            if 'weight' not in profile:
+                profile['weight'] = int(float(common[GAME_COMMON_WEIGHT_OFFSET].decode('ascii')) * 10)
+            if 'character' not in profile:
+                profile['character'] = int(common[GAME_COMMON_CHARACTER_OFFSET].decode('ascii'), 16)
+
+        sql = "UPDATE profile SET data = :data WHERE refid = :refid"
+        conn.execute(
+            text(sql),
+            {
+                'refid': refid,
+                'data': json.dumps(profile),
+            },
+        )
+
+
+def downgrade():
+    pass
diff --git a/bemani/data/migrations/versions/6c3db80175f1_adding_news_table.py b/bemani/data/migrations/versions/6c3db80175f1_adding_news_table.py
new file mode 100644
index 0000000..29caba6
--- /dev/null
+++ b/bemani/data/migrations/versions/6c3db80175f1_adding_news_table.py
@@ -0,0 +1,35 @@
+"""Adding news table.
+
+Revision ID: 6c3db80175f1
+Revises: 691d49925c52
+Create Date: 2016-12-07 22:39:53.768438
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '6c3db80175f1'
+down_revision = '691d49925c52'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('news',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('timestamp', sa.Integer(), nullable=False),
+    sa.Column('title', sa.String(length=255), nullable=False),
+    sa.Column('body', sa.Text(), nullable=False),
+    sa.PrimaryKeyConstraint('id'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('news')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/6e2a520d2782_make_session_table_generic.py b/bemani/data/migrations/versions/6e2a520d2782_make_session_table_generic.py
new file mode 100644
index 0000000..69ff46c
--- /dev/null
+++ b/bemani/data/migrations/versions/6e2a520d2782_make_session_table_generic.py
@@ -0,0 +1,39 @@
+"""Make session table generic.
+
+Revision ID: 6e2a520d2782
+Revises: 45438cc39f6d
+Create Date: 2017-04-13 21:16:03.808257
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = '6e2a520d2782'
+down_revision = '45438cc39f6d'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('session', sa.Column('id', sa.Integer(), nullable=False))
+    op.add_column('session', sa.Column('type', sa.String(length=32), nullable=False))
+
+    sql = "UPDATE session SET id = userid, type = 'userid'"
+    conn.execute(text(sql), {})
+
+    op.drop_column('session', 'userid')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('session', sa.Column('userid', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False))
+    op.drop_column('session', 'type')
+    op.drop_column('session', 'id')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/6e2ac7400610_rename_extid_table_to_refid.py b/bemani/data/migrations/versions/6e2ac7400610_rename_extid_table_to_refid.py
new file mode 100644
index 0000000..329c1e8
--- /dev/null
+++ b/bemani/data/migrations/versions/6e2ac7400610_rename_extid_table_to_refid.py
@@ -0,0 +1,26 @@
+"""Rename extid table to refid.
+
+Revision ID: 6e2ac7400610
+Revises: 314f97567294
+Create Date: 2017-04-20 22:51:16.284843
+
+"""
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = '6e2ac7400610'
+down_revision = '314f97567294'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.rename_table('extid', 'refid')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.rename_table('refid', 'extid')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/717a525b2193_add_indexes_to_some_tables.py b/bemani/data/migrations/versions/717a525b2193_add_indexes_to_some_tables.py
new file mode 100644
index 0000000..6db690b
--- /dev/null
+++ b/bemani/data/migrations/versions/717a525b2193_add_indexes_to_some_tables.py
@@ -0,0 +1,43 @@
+"""Add indexes to some tables.
+
+Revision ID: 717a525b2193
+Revises: d5b228dcb625
+Create Date: 2017-03-03 23:31:42.062641
+
+"""
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = '717a525b2193'
+down_revision = 'd5b228dcb625'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_index(op.f('ix_card_userid'), 'card', ['userid'], unique=False)
+    op.create_index(op.f('ix_music_game'), 'music', ['game'], unique=False)
+    op.create_index(op.f('ix_music_version'), 'music', ['version'], unique=False)
+    op.create_index(op.f('ix_news_timestamp'), 'news', ['timestamp'], unique=False)
+    op.create_index(op.f('ix_score_musicid'), 'score', ['musicid'], unique=False)
+    op.create_index(op.f('ix_score_history_musicid'), 'score_history', ['musicid'], unique=False)
+    op.create_index(op.f('ix_score_history_timestamp'), 'score_history', ['timestamp'], unique=False)
+    op.create_index(op.f('ix_time_sensitive_settings_end_time'), 'time_sensitive_settings', ['end_time'], unique=False)
+    op.create_index(op.f('ix_time_sensitive_settings_start_time'), 'time_sensitive_settings', ['start_time'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_time_sensitive_settings_start_time'), table_name='time_sensitive_settings')
+    op.drop_index(op.f('ix_time_sensitive_settings_end_time'), table_name='time_sensitive_settings')
+    op.drop_index(op.f('ix_score_history_timestamp'), table_name='score_history')
+    op.drop_index(op.f('ix_score_history_musicid'), table_name='score_history')
+    op.drop_index(op.f('ix_score_musicid'), table_name='score')
+    op.drop_index(op.f('ix_news_timestamp'), table_name='news')
+    op.drop_index(op.f('ix_music_version'), table_name='music')
+    op.drop_index(op.f('ix_music_game'), table_name='music')
+    op.drop_index(op.f('ix_card_userid'), table_name='card')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/7e87f51ab94d_add_primary_key_to_score_and_history_.py b/bemani/data/migrations/versions/7e87f51ab94d_add_primary_key_to_score_and_history_.py
new file mode 100644
index 0000000..ce94708
--- /dev/null
+++ b/bemani/data/migrations/versions/7e87f51ab94d_add_primary_key_to_score_and_history_.py
@@ -0,0 +1,33 @@
+"""Add primary key to score and history table for DDR Ace ghost ID.
+
+Revision ID: 7e87f51ab94d
+Revises: 428e24dea6f3
+Create Date: 2018-01-19 23:19:07.408309
+
+"""
+from alembic import op
+from sqlalchemy.sql import text
+
+
+# revision identifiers, used by Alembic.
+revision = '7e87f51ab94d'
+down_revision = '428e24dea6f3'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Alembic doesn't seem to be able to add auto-increment columns properly, so
+    # lets do it ourselves.
+    conn = op.get_bind()
+    sql = 'alter table score add column `id` int auto_increment primary key first'
+    results = conn.execute(text(sql), {})
+    sql = 'alter table score_history add column `id` int auto_increment primary key first'
+    results = conn.execute(text(sql), {})
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('score_history', 'id')
+    op.drop_column('score', 'id')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/8666c2253770_add_game_version_to_pcbid_settings.py b/bemani/data/migrations/versions/8666c2253770_add_game_version_to_pcbid_settings.py
new file mode 100644
index 0000000..5309192
--- /dev/null
+++ b/bemani/data/migrations/versions/8666c2253770_add_game_version_to_pcbid_settings.py
@@ -0,0 +1,28 @@
+"""Add game version to PCBID settings.
+
+Revision ID: 8666c2253770
+Revises: 3308af0e619f
+Create Date: 2017-08-19 12:05:36.923453
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '8666c2253770'
+down_revision = '3308af0e619f'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('machine', sa.Column('version', sa.Integer(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('machine', 'version')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/a522b9e42df4_fix_pop_n_music_song_display_issue_in_.py b/bemani/data/migrations/versions/a522b9e42df4_fix_pop_n_music_song_display_issue_in_.py
new file mode 100644
index 0000000..5119613
--- /dev/null
+++ b/bemani/data/migrations/versions/a522b9e42df4_fix_pop_n_music_song_display_issue_in_.py
@@ -0,0 +1,78 @@
+"""Fix Pop'n Music song display issue in music data.
+
+Revision ID: a522b9e42df4
+Revises: 5c927879651b
+Create Date: 2019-09-08 19:54:01.499243
+
+"""
+from alembic import op
+from sqlalchemy.sql import text
+
+
+# revision identifiers, used by Alembic.
+revision = 'a522b9e42df4'
+down_revision = '5c927879651b'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    sql = "SELECT id, name, artist, genre FROM music WHERE game = 'pnm'"
+    results = conn.execute(text(sql), {})
+    for result in results:
+        musicid = result['id']
+        new_title = title = result['name']
+        new_artist = artist = result['artist']
+        new_genre = genre = result['genre']
+
+        # Fix accent issues with title/artist
+        accent_lut: Dict[str, str] = {
+            "鵝": "7",
+            "圄": "à",
+            "圉": "ä",
+            "鵤": "Ä",
+            "鵑": "👁 ",
+            "鶤": "©",
+            "圈": "é",
+            "鵐": "ê",
+            "鵙": "Ə",
+            "鵲": "ë",
+            "！": "!",
+            "囿": "♥",
+            "鶚": "㊙",
+            "鶉": "ó",
+            "鶇": "ö",
+            "鶲": "Ⓟ",
+            "鶫": "²",
+            "圍": "@",
+            "圖": "ţ",
+            "鵺": "Ü",
+            "囎": ":",
+            "囂": "♡",
+            "釁": "🐾",
+        }
+
+        for orig, rep in accent_lut.items():
+            new_title = new_title.replace(orig, rep)
+            new_artist = new_artist.replace(orig, rep)
+            new_genre = new_genre.replace(orig, rep)
+
+        if new_title != title or new_artist != artist or new_genre != genre:
+            sql = "UPDATE music SET name = :name, artist = :artist, genre = :genre WHERE id = :id AND game = 'pnm'"
+            conn.execute(
+                text(sql),
+                {
+                    'id': musicid,
+                    'name': new_title,
+                    'artist': new_artist,
+                    'genre': new_genre,
+                },
+            )
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/ad911b666f22_create_a_last_updated_time_column_for_.py b/bemani/data/migrations/versions/ad911b666f22_create_a_last_updated_time_column_for_.py
new file mode 100644
index 0000000..8986fbc
--- /dev/null
+++ b/bemani/data/migrations/versions/ad911b666f22_create_a_last_updated_time_column_for_.py
@@ -0,0 +1,49 @@
+"""Create a last updated time column for scores.
+
+Revision ID: ad911b666f22
+Revises: b09f1e39c951
+Create Date: 2018-02-15 21:29:02.735626
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = 'ad911b666f22'
+down_revision = 'b09f1e39c951'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('score', sa.Column('update', sa.Integer(), nullable=False))
+    op.create_index(op.f('ix_score_update'), 'score', ['update'], unique=False)
+    # ### end Alembic commands ###
+
+    sql = 'SELECT userid, musicid, timestamp FROM score'
+    results = conn.execute(text(sql), {})
+    for result in results:
+        sql = (
+            'UPDATE score SET `update` = ' +
+            '(SELECT IFNULL(MAX(timestamp), :timestamp) FROM score_history WHERE score_history.userid = :userid AND score_history.musicid = :musicid) ' +
+            'WHERE score.userid = :userid AND score.musicid = :musicid'
+        )
+        conn.execute(
+            text(sql),
+            {
+                'userid': result['userid'],
+                'musicid': result['musicid'],
+                'timestamp': result['timestamp'],
+            },
+        )
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_score_update'), table_name='score')
+    op.drop_column('score', 'update')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/afd66ee7c0e0_remove_defaults_for_columns.py b/bemani/data/migrations/versions/afd66ee7c0e0_remove_defaults_for_columns.py
new file mode 100644
index 0000000..9f7498f
--- /dev/null
+++ b/bemani/data/migrations/versions/afd66ee7c0e0_remove_defaults_for_columns.py
@@ -0,0 +1,66 @@
+"""Remove defaults for columns.
+
+Revision ID: afd66ee7c0e0
+Revises: 
+Create Date: 2016-12-07 16:32:31.153995
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = 'afd66ee7c0e0'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('arcade', 'paseli_enabled',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=None,
+               existing_nullable=True)
+    op.alter_column('arcade', 'paseli_infinite',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=None,
+               existing_nullable=True)
+    op.alter_column('score', 'plays',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=None,
+               existing_nullable=False)
+    op.alter_column('score_history', 'new_record',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=None,
+               existing_nullable=False)
+    op.alter_column('user', 'admin',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=None,
+               existing_nullable=True)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('user', 'admin',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=sa.text("'0'"),
+               existing_nullable=True)
+    op.alter_column('score_history', 'new_record',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=sa.text("'0'"),
+               existing_nullable=False)
+    op.alter_column('score', 'plays',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=sa.text("'0'"),
+               existing_nullable=False)
+    op.alter_column('arcade', 'paseli_infinite',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=sa.text("'0'"),
+               existing_nullable=True)
+    op.alter_column('arcade', 'paseli_enabled',
+               existing_type=mysql.INTEGER(display_width=11),
+               server_default=sa.text("'0'"),
+               existing_nullable=True)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/b09f1e39c951_respect_ability_for_other_servers_to_.py b/bemani/data/migrations/versions/b09f1e39c951_respect_ability_for_other_servers_to_.py
new file mode 100644
index 0000000..e50aceb
--- /dev/null
+++ b/bemani/data/migrations/versions/b09f1e39c951_respect_ability_for_other_servers_to_.py
@@ -0,0 +1,34 @@
+"""Respect ability for other servers to have <= 64 character tokens.
+
+Revision ID: b09f1e39c951
+Revises: 0df7f3dc4d23
+Create Date: 2018-01-31 15:42:15.013060
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = 'b09f1e39c951'
+down_revision = '0df7f3dc4d23'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('server', 'token',
+               existing_type=mysql.VARCHAR(length=36),
+               type_=sa.String(length=64),
+               existing_nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('server', 'token',
+               existing_type=sa.String(length=64),
+               type_=mysql.VARCHAR(length=36),
+               existing_nullable=False)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/b517e37877c8_make_score_timestamp_non_nullable.py b/bemani/data/migrations/versions/b517e37877c8_make_score_timestamp_non_nullable.py
new file mode 100644
index 0000000..b1f1bf4
--- /dev/null
+++ b/bemani/data/migrations/versions/b517e37877c8_make_score_timestamp_non_nullable.py
@@ -0,0 +1,31 @@
+"""Make score timestamp non-nullable.
+
+Revision ID: b517e37877c8
+Revises: 3f621cef0a71
+Create Date: 2017-03-21 20:36:11.425736
+
+"""
+from alembic import op
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = 'b517e37877c8'
+down_revision = '3f621cef0a71'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('score', 'timestamp',
+               existing_type=mysql.INTEGER(display_width=11),
+               nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('score', 'timestamp',
+               existing_type=mysql.INTEGER(display_width=11),
+               nullable=True)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/b86fe18bfbd3_add_pin_field_for_arcades.py b/bemani/data/migrations/versions/b86fe18bfbd3_add_pin_field_for_arcades.py
new file mode 100644
index 0000000..5e9edc6
--- /dev/null
+++ b/bemani/data/migrations/versions/b86fe18bfbd3_add_pin_field_for_arcades.py
@@ -0,0 +1,33 @@
+"""Add pin field for arcades.
+
+Revision ID: b86fe18bfbd3
+Revises: 6e2a520d2782
+Create Date: 2017-04-14 17:59:18.488816
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = 'b86fe18bfbd3'
+down_revision = '6e2a520d2782'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('arcade', sa.Column('pin', sa.String(length=8), nullable=True))
+    # ### end Alembic commands ###
+
+    sql = "UPDATE arcade SET pin = '00000000'"
+    conn.execute(text(sql), {})
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('arcade', 'pin')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/bc7d717a37d6_remove_extid_column_from_refid_table.py b/bemani/data/migrations/versions/bc7d717a37d6_remove_extid_column_from_refid_table.py
new file mode 100644
index 0000000..6898ec2
--- /dev/null
+++ b/bemani/data/migrations/versions/bc7d717a37d6_remove_extid_column_from_refid_table.py
@@ -0,0 +1,30 @@
+"""Remove extid column from refid table.
+
+Revision ID: bc7d717a37d6
+Revises: e918fab0402d
+Create Date: 2017-04-20 23:26:01.459118
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = 'bc7d717a37d6'
+down_revision = 'e918fab0402d'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index('extid', table_name='refid')
+    op.drop_column('refid', 'extid')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('refid', sa.Column('extid', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False))
+    op.create_index('extid', 'refid', ['extid'], unique=True)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/d02f0bf59400_migration_for_ddr_ace_frontend_options.py b/bemani/data/migrations/versions/d02f0bf59400_migration_for_ddr_ace_frontend_options.py
new file mode 100644
index 0000000..0607973
--- /dev/null
+++ b/bemani/data/migrations/versions/d02f0bf59400_migration_for_ddr_ace_frontend_options.py
@@ -0,0 +1,63 @@
+"""Migration for DDR Ace frontend options.
+
+Revision ID: d02f0bf59400
+Revises: 693fadb665ba
+Create Date: 2018-02-18 13:01:01.497029
+
+"""
+import json
+from alembic import op
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = 'd02f0bf59400'
+down_revision = '693fadb665ba'
+branch_labels = None
+depends_on = None
+
+
+GAME_OPTION_ARROW_SKIN_OFFSET = 11
+GAME_OPTION_FILTER_OFFSET = 12
+GAME_OPTION_GUIDELINE_OFFSET = 13
+GAME_OPTION_COMBO_POSITION_OFFSET = 15
+GAME_OPTION_FAST_SLOW_OFFSET = 16
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    sql = "SELECT refid, data FROM profile WHERE refid IN (SELECT refid FROM refid WHERE game = 'ddr' AND version = 16)"
+    results = conn.execute(text(sql), {})
+    for result in results:
+        refid = result['refid']
+        profile = json.loads(result['data'])
+
+        if (
+            'usergamedata' in profile and
+            'OPTION' in profile['usergamedata'] and
+            'strdata' in profile['usergamedata']['OPTION']
+        ):
+            option = bytes(profile['usergamedata']['OPTION']['strdata'][1:]).split(b',')
+            if 'combo' not in profile:
+                profile['combo'] = int(option[GAME_OPTION_COMBO_POSITION_OFFSET].decode('ascii'), 16)
+            if 'early_late' not in profile:
+                profile['early_late'] = int(option[GAME_OPTION_FAST_SLOW_OFFSET].decode('ascii'), 16)
+            if 'arrowskin' not in profile:
+                profile['arrowskin'] = int(option[GAME_OPTION_ARROW_SKIN_OFFSET].decode('ascii'), 16)
+            if 'guidelines' not in profile:
+                profile['guidelines'] = int(option[GAME_OPTION_GUIDELINE_OFFSET].decode('ascii'), 16)
+            if 'filter' not in profile:
+                profile['filter'] = int(option[GAME_OPTION_FILTER_OFFSET].decode('ascii'), 16)
+
+        sql = "UPDATE profile SET data = :data WHERE refid = :refid"
+        conn.execute(
+            text(sql),
+            {
+                'refid': refid,
+                'data': json.dumps(profile),
+            },
+        )
+
+
+def downgrade():
+    pass
diff --git a/bemani/data/migrations/versions/d041922684eb_add_lid_column_to_scores_so_we_can_.py b/bemani/data/migrations/versions/d041922684eb_add_lid_column_to_scores_so_we_can_.py
new file mode 100644
index 0000000..d23e268
--- /dev/null
+++ b/bemani/data/migrations/versions/d041922684eb_add_lid_column_to_scores_so_we_can_.py
@@ -0,0 +1,34 @@
+"""Add LID column to scores so we can track where a score was earned.
+
+Revision ID: d041922684eb
+Revises: 7e87f51ab94d
+Create Date: 2018-01-21 20:13:25.210940
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'd041922684eb'
+down_revision = '7e87f51ab94d'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('score', sa.Column('lid', sa.Integer(), nullable=False))
+    op.create_index(op.f('ix_score_lid'), 'score', ['lid'], unique=False)
+    op.add_column('score_history', sa.Column('lid', sa.Integer(), nullable=False))
+    op.create_index(op.f('ix_score_history_lid'), 'score_history', ['lid'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_score_history_lid'), table_name='score_history')
+    op.drop_column('score_history', 'lid')
+    op.drop_index(op.f('ix_score_lid'), table_name='score')
+    op.drop_column('score', 'lid')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/d5b228dcb625_converting_arcade_paseli_settings_to_.py b/bemani/data/migrations/versions/d5b228dcb625_converting_arcade_paseli_settings_to_.py
new file mode 100644
index 0000000..cbc1b1c
--- /dev/null
+++ b/bemani/data/migrations/versions/d5b228dcb625_converting_arcade_paseli_settings_to_.py
@@ -0,0 +1,45 @@
+"""Converting arcade paseli settings to dict like other tables.
+
+Revision ID: d5b228dcb625
+Revises: d7602d586661
+Create Date: 2017-02-19 11:32:27.077094
+
+"""
+import json
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = 'd5b228dcb625'
+down_revision = 'd7602d586661'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # Add new column
+    op.add_column('arcade', sa.Column('data', sa.JSON(), nullable=True))
+
+    # Migrate current settings
+    sql = 'SELECT id, paseli_enabled, paseli_infinite FROM arcade'
+    results = conn.execute(text(sql), {})
+    for result in results:
+        sql = 'UPDATE arcade SET data = :data WHERE id = :id'
+        conn.execute(text(sql), {
+            'data': json.dumps({'paseli_enabled': result['paseli_enabled'] == 1, 'paseli_infinite': result['paseli_infinite'] == 1}),
+            'id': result['id'],
+        })
+
+    # Drop old columns
+    op.drop_column('arcade', 'paseli_enabled')
+    op.drop_column('arcade', 'paseli_infinite')
+
+
+def downgrade():
+    op.add_column('arcade', sa.Column('paseli_infinite', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True))
+    op.add_column('arcade', sa.Column('paseli_enabled', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True))
+    op.drop_column('arcade', 'data')
diff --git a/bemani/data/migrations/versions/d7602d586661_add_settings_table_for_game_version.py b/bemani/data/migrations/versions/d7602d586661_add_settings_table_for_game_version.py
new file mode 100644
index 0000000..a421be7
--- /dev/null
+++ b/bemani/data/migrations/versions/d7602d586661_add_settings_table_for_game_version.py
@@ -0,0 +1,36 @@
+"""Add settings table for game/version.
+
+Revision ID: d7602d586661
+Revises: 21c19a671b3b
+Create Date: 2017-02-18 16:52:22.594299
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'd7602d586661'
+down_revision = '21c19a671b3b'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('arcade_settings',
+    sa.Column('arcadeid', sa.Integer(), nullable=False),
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('type', sa.String(length=64), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.UniqueConstraint('arcadeid', 'game', 'version', 'type', name='arcadeid_game_version_type'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('arcade_settings')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/d764dd3489e6_add_scheduled_work_table.py b/bemani/data/migrations/versions/d764dd3489e6_add_scheduled_work_table.py
new file mode 100644
index 0000000..b7e82b5
--- /dev/null
+++ b/bemani/data/migrations/versions/d764dd3489e6_add_scheduled_work_table.py
@@ -0,0 +1,37 @@
+"""Add scheduled work table.
+
+Revision ID: d764dd3489e6
+Revises: ef6b27f2fcc5
+Create Date: 2016-12-21 23:27:07.138501
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'd764dd3489e6'
+down_revision = 'ef6b27f2fcc5'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('scheduled_work',
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('version', sa.Integer(), nullable=False),
+    sa.Column('name', sa.String(length=32), nullable=False),
+    sa.Column('schedule', sa.String(length=32), nullable=False),
+    sa.Column('year', sa.Integer(), nullable=True),
+    sa.Column('day', sa.Integer(), nullable=True),
+    sa.UniqueConstraint('game', 'version', 'name', 'schedule', name='game_version_name_schedule'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('scheduled_work')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/e918fab0402d_create_table_for_extids.py b/bemani/data/migrations/versions/e918fab0402d_create_table_for_extids.py
new file mode 100644
index 0000000..5ececbf
--- /dev/null
+++ b/bemani/data/migrations/versions/e918fab0402d_create_table_for_extids.py
@@ -0,0 +1,53 @@
+"""Create table for extids.
+
+Revision ID: e918fab0402d
+Revises: 6e2ac7400610
+Create Date: 2017-04-20 23:04:11.042442
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import text
+
+
+# revision identifiers, used by Alembic.
+revision = 'e918fab0402d'
+down_revision = '6e2ac7400610'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('extid',
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('extid', sa.Integer(), nullable=False),
+    sa.Column('userid', sa.Integer(), nullable=False),
+    sa.UniqueConstraint('extid'),
+    sa.UniqueConstraint('game', 'userid', name='game_userid'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+    # Now, move over extid from the refid table for each user/game series.
+    sql = 'SELECT userid, game, extid FROM refid ORDER BY version DESC'
+    results = conn.execute(text(sql), {})
+    updates = {}
+    for result in results:
+        sql = 'INSERT INTO extid (userid, game, extid) VALUES (:userid, :game, :extid)'
+        try:
+            conn.execute(text(sql), {
+                'userid': result['userid'],
+                'game': result['game'],
+                'extid': result['extid'],
+            })
+        except sa.exc.IntegrityError:
+            pass
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('extid')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/ee447dd6bfa8_move_scores_out_of_db_data_blobs_and_.py b/bemani/data/migrations/versions/ee447dd6bfa8_move_scores_out_of_db_data_blobs_and_.py
new file mode 100644
index 0000000..f471737
--- /dev/null
+++ b/bemani/data/migrations/versions/ee447dd6bfa8_move_scores_out_of_db_data_blobs_and_.py
@@ -0,0 +1,78 @@
+"""Move scores out of DB data blobs and into column.
+
+Revision ID: ee447dd6bfa8
+Revises: 717a525b2193
+Create Date: 2017-03-06 20:03:25.983637
+
+"""
+import json
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import text
+
+# revision identifiers, used by Alembic.
+revision = 'ee447dd6bfa8'
+down_revision = '717a525b2193'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('score', sa.Column('points', sa.Integer(), nullable=True))
+    op.add_column('score_history', sa.Column('points', sa.Integer(), nullable=True))
+    # ### end Alembic commands ###
+
+    # Migrate scores
+    sql = 'SELECT userid, musicid, data FROM score'
+    results = conn.execute(text(sql), {})
+    for result in results:
+        data = json.loads(result['data'])
+        if 'points' in data:
+            points = data['points']
+            del data['points']
+        if 'ex_score' in data:
+            points = data['ex_score']
+            del data['ex_score']
+        sql = 'UPDATE score SET points = :points, data = :data WHERE userid = :userid AND musicid = :musicid'
+        conn.execute(
+            text(sql),
+            {
+                'data': json.dumps(data),
+                'points': points,
+                'userid': result['userid'],
+                'musicid': result['musicid'],
+            },
+        )
+
+    # Migrate score histories
+    sql = 'SELECT userid, musicid, timestamp, data FROM score_history'
+    results = conn.execute(text(sql), {})
+    for result in results:
+        data = json.loads(result['data'])
+        if 'points' in data:
+            points = data['points']
+            del data['points']
+        if 'ex_score' in data:
+            points = data['ex_score']
+            del data['ex_score']
+        sql = 'UPDATE score_history SET points = :points, data = :data WHERE userid = :userid AND musicid = :musicid AND timestamp = :timestamp'
+        conn.execute(
+            text(sql),
+            {
+                'data': json.dumps(data),
+                'points': points,
+                'userid': result['userid'],
+                'musicid': result['musicid'],
+                'timestamp': result['timestamp'],
+            },
+        )
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('score_history', 'points')
+    op.drop_column('score', 'points')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/ef6b27f2fcc5_adding_game_series_achievements.py b/bemani/data/migrations/versions/ef6b27f2fcc5_adding_game_series_achievements.py
new file mode 100644
index 0000000..275e135
--- /dev/null
+++ b/bemani/data/migrations/versions/ef6b27f2fcc5_adding_game_series_achievements.py
@@ -0,0 +1,36 @@
+"""Adding game series achievements.
+
+Revision ID: ef6b27f2fcc5
+Revises: 6c3db80175f1
+Create Date: 2016-12-18 23:09:23.805875
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'ef6b27f2fcc5'
+down_revision = '6c3db80175f1'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('series_achievement',
+    sa.Column('game', sa.String(length=32), nullable=False),
+    sa.Column('userid', sa.Integer(), nullable=False),
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('type', sa.String(length=64), nullable=False),
+    sa.Column('data', sa.JSON(), nullable=False),
+    sa.UniqueConstraint('game', 'userid', 'id', 'type', name='game_userid_id_type'),
+    mysql_charset='utf8mb4'
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('series_achievement')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/f1fe9fce9ace_drop_category_column_add_general_column_.py b/bemani/data/migrations/versions/f1fe9fce9ace_drop_category_column_add_general_column_.py
new file mode 100644
index 0000000..2ad1fc0
--- /dev/null
+++ b/bemani/data/migrations/versions/f1fe9fce9ace_drop_category_column_add_general_column_.py
@@ -0,0 +1,30 @@
+"""Drop category column, add general column to music.
+
+Revision ID: f1fe9fce9ace
+Revises: f35b7dbdb672
+Create Date: 2017-02-02 22:27:26.633758
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = 'f1fe9fce9ace'
+down_revision = 'f35b7dbdb672'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('music', sa.Column('data', sa.JSON(), nullable=True))
+    op.drop_column('music', 'category')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('music', sa.Column('category', mysql.VARCHAR(length=63), nullable=True))
+    op.drop_column('music', 'data')
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/f270dd360519_make_points_column_nullable.py b/bemani/data/migrations/versions/f270dd360519_make_points_column_nullable.py
new file mode 100644
index 0000000..da38e08
--- /dev/null
+++ b/bemani/data/migrations/versions/f270dd360519_make_points_column_nullable.py
@@ -0,0 +1,37 @@
+"""Make points column nullable.
+
+Revision ID: f270dd360519
+Revises: ee447dd6bfa8
+Create Date: 2017-03-06 20:33:58.380331
+
+"""
+from alembic import op
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = 'f270dd360519'
+down_revision = 'ee447dd6bfa8'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('score', 'points',
+               existing_type=mysql.INTEGER(display_width=11),
+               nullable=False)
+    op.alter_column('score_history', 'points',
+               existing_type=mysql.INTEGER(display_width=11),
+               nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('score_history', 'points',
+               existing_type=mysql.INTEGER(display_width=11),
+               nullable=True)
+    op.alter_column('score', 'points',
+               existing_type=mysql.INTEGER(display_width=11),
+               nullable=True)
+    # ### end Alembic commands ###
diff --git a/bemani/data/migrations/versions/f35b7dbdb672_add_index_to_music_to_speed_up_play_.py b/bemani/data/migrations/versions/f35b7dbdb672_add_index_to_music_to_speed_up_play_.py
new file mode 100644
index 0000000..61d942a
--- /dev/null
+++ b/bemani/data/migrations/versions/f35b7dbdb672_add_index_to_music_to_speed_up_play_.py
@@ -0,0 +1,27 @@
+"""Add index to music to speed up play count queries.
+
+Revision ID: f35b7dbdb672
+Revises: 437a91b37583
+Create Date: 2017-01-17 23:43:20.525727
+
+"""
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = 'f35b7dbdb672'
+down_revision = '437a91b37583'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_index(op.f('ix_music_id'), 'music', ['id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_music_id'), table_name='music')
+    # ### end Alembic commands ###
diff --git a/bemani/data/mysql/__init__.py b/bemani/data/mysql/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/bemani/data/mysql/api.py b/bemani/data/mysql/api.py
new file mode 100644
index 0000000..fffc8e9
--- /dev/null
+++ b/bemani/data/mysql/api.py
@@ -0,0 +1,236 @@
+import uuid
+from sqlalchemy import Table, Column  # type: ignore
+from sqlalchemy.types import String, Integer  # type: ignore
+from typing import Any, Dict, List, Optional
+
+from bemani.common import Time
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.interfaces import APIProviderInterface
+from bemani.data.types import Client, Server
+
+"""
+Table for storing registered clients to a data exchange API, as added
+by an admin.
+"""
+client = Table(  # type: ignore
+    'client',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('name', String(255), nullable=False),
+    Column('token', String(36), nullable=False),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing remote servers to a data exchange API, as added
+by an admin.
+"""
+server = Table(  # type: ignore
+    'server',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('uri', String(1024), nullable=False),
+    Column('token', String(64), nullable=False),
+    Column('config', Integer, nullable=False),
+    mysql_charset='utf8mb4',
+)
+
+
+class APIData(APIProviderInterface, BaseData):
+
+    def get_all_clients(self) -> List[Client]:
+        """
+        Grab all authorized clients in the system.
+
+        Returns:
+            A list of Client objects sorted by add time.
+        """
+        sql = "SELECT id, timestamp, name, token FROM client ORDER BY timestamp ASC"
+        cursor = self.execute(sql)
+        return [
+            Client(
+                result['id'],
+                result['timestamp'],
+                result['name'],
+                result['token'],
+            ) for result in cursor.fetchall()
+        ]
+
+    def validate_client(self, token: str) -> bool:
+        """
+        Given a client ID, return whether this client is authorized or not.
+
+        Parameters:
+            token - String that a client passes to us.
+
+        Returns:
+            True if the client is authorized, False otherwise.
+        """
+        sql = "SELECT count(*) AS count FROM client WHERE token = :token"
+        cursor = self.execute(sql, {'token': token})
+        return cursor.fetchone()['count'] == 1
+
+    def create_client(self, name: str) -> int:
+        """
+        Given a name, create a new client and generate an authorization token.
+
+        Parameters:
+            name - String name of the client.
+
+        Returns:
+            The ID of the newly created client.
+        """
+        sql = "INSERT INTO client (timestamp, name, token) VALUES (:timestamp, :name, :token)"
+        cursor = self.execute(
+            sql,
+            {
+                'timestamp': int(Time.now()),
+                'name': name,
+                'token': str(uuid.uuid4()),
+            },
+        )
+        return cursor.lastrowid
+
+    def get_client(self, clientid: int) -> Optional[Client]:
+        """
+        Given a client ID, grab that client from the DB.
+
+        Parameters:
+            clientid - Integer specifying client ID.
+
+        Returns:
+            A Client object if the client entry was found or None otherwise.
+        """
+        sql = "SELECT timestamp, name, token FROM client WHERE id = :id"
+        cursor = self.execute(sql, {'id': clientid})
+        if cursor.rowcount != 1:
+            # Couldn't find an entry with this ID
+            return None
+
+        result = cursor.fetchone()
+        return Client(
+            clientid,
+            result['timestamp'],
+            result['name'],
+            result['token'],
+        )
+
+    def put_client(self, client: Client) -> None:
+        """
+        Given a client object, store it back into the DB.
+
+        Parameters:
+            client - A Client object to be updated.
+        """
+        sql = "UPDATE client SET name = :name WHERE id = :id"
+        self.execute(sql, {'id': client.id, 'name': client.name})
+
+    def destroy_client(self, clientid: int) -> None:
+        """
+        Given a client ID, remove that client from the DB.
+
+        Parameters:
+            clientid - Integer specifying client ID.
+        """
+        sql = "DELETE FROM client WHERE id = :id LIMIT 1"
+        self.execute(sql, {'id': clientid})
+
+    def get_all_servers(self) -> List[Server]:
+        """
+        Grab all authorized servers in the system.
+
+        Returns:
+            A list of Server objects sorted by add time.
+        """
+        def format_result(result: Dict[str, Any]) -> Server:
+            allow_stats = (result['config'] & 0x1) == 0
+            allow_scores = (result['config'] & 0x2) == 0
+            return Server(
+                result['id'],
+                result['timestamp'],
+                result['uri'],
+                result['token'],
+                allow_stats,
+                allow_scores,
+            )
+
+        sql = "SELECT id, timestamp, uri, token, config FROM server ORDER BY timestamp ASC"
+        cursor = self.execute(sql)
+        return [format_result(result) for result in cursor.fetchall()]
+
+    def create_server(self, uri: str, token: str) -> int:
+        """
+        Given a uri and a token, create a new server.
+
+        Parameters:
+            uri - String name of the server.
+            token - Authorization token we will use when talking to the server.
+
+        Returns:
+            The ID of the newly created server.
+        """
+        sql = "INSERT INTO server (timestamp, uri, token, config) VALUES (:timestamp, :uri, :token, 0)"
+        cursor = self.execute(
+            sql,
+            {
+                'timestamp': int(Time.now()),
+                'uri': uri,
+                'token': token,
+            },
+        )
+        return cursor.lastrowid
+
+    def get_server(self, serverid: int) -> Optional[Server]:
+        """
+        Given a server ID, grab that server from the DB.
+
+        Parameters:
+            serverid - Integer specifying server ID.
+
+        Returns:
+            A Server object if the server entry was found or None otherwise.
+        """
+        sql = "SELECT timestamp, uri, token, config FROM server WHERE id = :id"
+        cursor = self.execute(sql, {'id': serverid})
+        if cursor.rowcount != 1:
+            # Couldn't find an entry with this ID
+            return None
+
+        result = cursor.fetchone()
+        allow_stats = (result['config'] & 0x1) == 0
+        allow_scores = (result['config'] & 0x2) == 0
+        return Server(
+            serverid,
+            result['timestamp'],
+            result['uri'],
+            result['token'],
+            allow_stats,
+            allow_scores,
+        )
+
+    def put_server(self, server: Server) -> None:
+        """
+        Given a server object, store it back into the DB.
+
+        Parameters:
+            server - A Server object to be updated.
+        """
+        config = 0
+        if not server.allow_stats:
+            config = config | 0x1
+        if not server.allow_scores:
+            config = config | 0x2
+        sql = "UPDATE server SET uri = :uri, token = :token, config = :config WHERE id = :id"
+        self.execute(sql, {'id': server.id, 'uri': server.uri, 'token': server.token, 'config': config})
+
+    def destroy_server(self, serverid: int) -> None:
+        """
+        Given a server ID, remove that server from the DB.
+
+        Parameters:
+            serverid - Integer specifying server ID.
+        """
+        sql = "DELETE FROM server WHERE id = :id LIMIT 1"
+        self.execute(sql, {'id': serverid})
diff --git a/bemani/data/mysql/base.py b/bemani/data/mysql/base.py
new file mode 100644
index 0000000..1798aea
--- /dev/null
+++ b/bemani/data/mysql/base.py
@@ -0,0 +1,185 @@
+import json
+import random
+from typing import Dict, Any, Optional
+
+from bemani.common import Time
+
+from sqlalchemy.engine.base import Connection  # type: ignore
+from sqlalchemy.engine.result import ResultProxy  # type: ignore
+from sqlalchemy.sql import text  # type: ignore
+from sqlalchemy.types import String, Integer  # type: ignore
+from sqlalchemy import Table, Column, MetaData  # type: ignore
+
+metadata = MetaData()  # type: ignore
+
+"""
+Table for storing session IDs, so a session ID can be used to look up an arbitrary ID.
+This is currently used for user logins, user and arcade PASELI sessions.
+"""
+session = Table(  # type: ignore
+    'session',
+    metadata,
+    Column('id', Integer, nullable=False),
+    Column('type', String(32), nullable=False),
+    Column('session', String(32), nullable=False, unique=True),
+    Column('expiration', Integer),
+    mysql_charset='utf8mb4',
+)
+
+
+class _BytesEncoder(json.JSONEncoder):
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, bytes):
+            # We're abusing lists here, we have a mixed type
+            return ['__bytes__'] + [b for b in obj]  # type: ignore
+        return json.JSONEncoder.default(self, obj)
+
+
+class BaseData:
+
+    SESSION_LENGTH = 32
+
+    def __init__(self, config: Dict[str, Any], conn: Connection) -> None:
+        """
+        Initialize any DB singleton.
+
+        Should only ever be called by Data.
+
+        Parameters:
+            config - config structure which is provided in case any function here
+                     needs to look up configuration.
+            conn - An established connection to the DB which will be used for all
+                   queries.
+        """
+        self.__config = config
+        self.__conn = conn
+
+    def execute(self, sql: str, params: Optional[Dict[str, Any]]=None, safe_write_operation: bool=False) -> ResultProxy:
+        """
+        Given a SQL string and some parameters, execute the query and return the result.
+
+        Parameters:
+            sql - The SQL statement to execute.
+            params - Dictionary of parameters which will be substituted into the sql string.
+
+        Returns:
+            A SQLAlchemy ResultProxy object.
+        """
+        if self.__config['database'].get('read_only', False):
+            # See if this is an insert/update/delete
+            for write_statement in [
+                "insert into ",
+                "update ",
+                "delete from ",
+            ]:
+                if write_statement in sql.lower() and not safe_write_operation:
+                    raise Exception('Read-only mode is active!')
+        return self.__conn.execute(  # type: ignore
+            text(sql),
+            params if params is not None else {},
+        )
+
+    def serialize(self, data: Dict[str, Any]) -> str:
+        """
+        Given an arbitrary dict, serialize it to JSON.
+        """
+        return json.dumps(data, cls=_BytesEncoder)
+
+    def deserialize(self, data: Optional[str]) -> Dict[str, Any]:
+        """
+        Given a string, deserialize it from JSON.
+        """
+        if data is None:
+            return {}
+
+        def fix(jd: Any) -> Any:
+            if type(jd) == dict:
+                # Fix each element in the dictionary.
+                for key in jd:
+                    jd[key] = fix(jd[key])
+                return jd
+
+            if type(jd) == list:
+                # Could be serialized by us, could be a normal list.
+                if len(jd) >= 1 and jd[0] == '__bytes__':
+                    # This is a serialized bytestring
+                    return bytes(jd[1:])
+
+                # Possibly one of these is a dictionary/list/serialized.
+                for i in range(len(jd)):
+                    jd[i] = fix(jd[i])
+                return jd
+
+            # Normal value, its deserialized version is itself.
+            return jd
+
+        return fix(json.loads(data))
+
+    def _from_session(self, session: str, sesstype: str) -> Optional[int]:
+        """
+        Given a previously-opened session, look up an ID.
+
+        Parameters:
+            session - String identifying a session that was opened by create_session.
+            sesstype - Arbitrary string identifying the session type.
+
+        Returns:
+            ID as an integer if found, or None if the session is expired or doesn't exist.
+        """
+        # Look up the user account, making sure to expire old sessions
+        sql = "SELECT id FROM session WHERE session = :session AND type = :type AND expiration > :timestamp"
+        cursor = self.execute(sql, {'session': session, 'type': sesstype, 'timestamp': Time.now()})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this session
+            return None
+
+        result = cursor.fetchone()
+        return result['id']
+
+    def _create_session(self, opid: int, optype: str, expiration: int=(30 * 86400)) -> str:
+        """
+        Given an ID, create a session string.
+
+        Parameters:
+            opid - ID we wish to start a session for.
+            expiration - Number of seconds before this session is invalid.
+
+        Returns:
+            A string that can be used as a session ID.
+        """
+        # Create a new session that is unique
+        while True:
+            session = ''.join(random.choice('0123456789ABCDEF') for _ in range(BaseData.SESSION_LENGTH))
+            sql = "SELECT session FROM session WHERE session = :session"
+            cursor = self.execute(sql, {'session': session})
+            if cursor.rowcount == 0:
+                # Make sure sessions expire in a reasonable amount of time
+                expiration = Time.now() + expiration
+
+                # Use that session
+                sql = (
+                    "INSERT INTO session (id, session, type, expiration) " +
+                    "VALUES (:id, :session, :optype, :expiration)"
+                )
+                cursor = self.execute(
+                    sql,
+                    {'id': opid, 'session': session, 'optype': optype, 'expiration': expiration},
+                    safe_write_operation=True,
+                )
+                if cursor.rowcount == 1:
+                    return session
+
+    def _destroy_session(self, session: str, sesstype: str) -> None:
+        """
+        Destroy a previously-created session.
+
+        Parameters:
+            session - A session string as returned from create_session.
+        """
+        # Remove the session token
+        sql = "DELETE FROM session WHERE session = :session AND type = :sesstype"
+        self.execute(sql, {'session': session, 'sesstype': sesstype}, safe_write_operation=True)
+
+        # Also weed out any other defunct sessions
+        sql = "DELETE FROM session WHERE expiration < :timestamp"
+        self.execute(sql, {'timestamp': Time.now()}, safe_write_operation=True)
diff --git a/bemani/data/mysql/game.py b/bemani/data/mysql/game.py
new file mode 100644
index 0000000..1b0b1a4
--- /dev/null
+++ b/bemani/data/mysql/game.py
@@ -0,0 +1,376 @@
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.types import String, Integer, JSON  # type: ignore
+from sqlalchemy.dialects.mysql import BIGINT as BigInteger  # type: ignore
+from typing import Any, Dict, List, Optional
+
+from bemani.common import ValidatedDict, Time
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.types import Achievement, Item, UserID
+
+"""
+Table for storing game settings that span multiple versions of the same
+game, such as play statistics. This table intentionally doesn't have a
+key on game version, just game string and userid.
+"""
+game_settings = Table(  # type: ignore
+    'game_settings',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'userid', name='game_userid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing shop items that are server-side verified.
+"""
+catalog = Table(  # type: ignore
+    'catalog',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('id', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'version', 'id', 'type', name='game_version_id_type'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing series achievements that span multiple versions of the same
+game, such as course scores. This table intentionally doesn't have a
+key on game version, just game string and userid.
+"""
+series_achievement = Table(  # type: ignore
+    'series_achievement',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('id', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'userid', 'id', 'type', name='game_userid_id_type'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing time-based game settings that aren't tied to a user
+account, such as dailies, weeklies, etc.
+"""
+time_sensitive_settings = Table(  # type: ignore
+    'time_sensitive_settings',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('name', String(32), nullable=False),
+    Column('start_time', Integer, nullable=False, index=True),
+    Column('end_time', Integer, nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'version', 'name', 'start_time', name='game_version_name_start_time'),
+    mysql_charset='utf8mb4',
+)
+
+
+class GameData(BaseData):
+
+    def get_settings(self, game: str, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game and a user ID, look up game-wide settings as a dictionary.
+
+        It is expected that game classes call this function, and provide a consistent
+        game name from version to version, so game settings can be looked up across
+        all versions in a game series.
+
+        Parameters:
+            game - String identifying a game series.
+            userid - Integer identifying a user, as possibly looked up by UserData.
+
+        Returns:
+            A dictionary representing game settings stored by a game class, or None
+            if there are no settings for this game/user.
+        """
+        sql = "SELECT data FROM game_settings WHERE game = :game AND userid = :userid"
+        cursor = self.execute(sql, {'game': game, 'userid': userid})
+
+        if cursor.rowcount != 1:
+            # Settings doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def put_settings(self, game: str, userid: UserID, settings: Dict[str, Any]) -> None:
+        """
+        Given a game and a user ID, save game-wide settings to the DB.
+
+        Parameters:
+            game - String identifying a game series.
+            userid - Integer identifying a user.
+            settings - A dictionary of settings that a game wishes to retrieve later.
+        """
+        # Add settings json to game settings
+        sql = (
+            "INSERT INTO game_settings (game, userid, data) " +
+            "VALUES (:game, :userid, :data) " +
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'game': game, 'userid': userid, 'data': self.serialize(settings)})
+
+    def get_achievement(self, game: str, userid: UserID, achievementid: int, achievementtype: str) -> Optional[ValidatedDict]:
+        """
+        Given a game/userid and achievement id/type, find that achievement.
+
+        Note that there can be more than one achievement with the same ID and game/userid
+        as long as each one is a different type. Essentially, achievementtype namespaces achievements.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        sql = (
+            "SELECT data FROM series_achievement "
+            "WHERE game = :game AND userid = :userid AND id = :id AND type = :type"
+        )
+        cursor = self.execute(sql, {'game': game, 'userid': userid, 'id': achievementid, 'type': achievementtype})
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def get_achievements(self, game: str, userid: UserID) -> List[Achievement]:
+        """
+        Given a game/userid, find all achievements
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of Achievement objects.
+        """
+        sql = "SELECT id, type, data FROM series_achievement WHERE game = :game AND userid = :userid"
+        cursor = self.execute(sql, {'game': game, 'userid': userid})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                Achievement(
+                    result['id'],
+                    result['type'],
+                    None,
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return achievements
+
+    def put_achievement(self, game: str, userid: UserID, achievementid: int, achievementtype: str, data: Dict[str, Any]) -> None:
+        """
+        Given a game/userid and achievement id/type, save an achievement.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        # Add achievement JSON to achievements
+        sql = (
+            "INSERT INTO series_achievement (game, userid, id, type, data) " +
+            "VALUES (:game, :userid, :id, :type, :data) " +
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'game': game, 'userid': userid, 'id': achievementid, 'type': achievementtype, 'data': self.serialize(data)})
+
+    def get_time_sensitive_settings(self, game: str, version: int, name: str) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/name, look up the current time-sensitive settings for this game.
+
+        Parameters:
+            game - String identifier of the game we want settings for.
+            version - Integer identifying the game version we want settings for.
+            name - The name of the setting we are concerned with.
+
+        Returns:
+            A ValidatedDict of stored settings if the current setting is found, or None otherwise.
+            If settings were found, they are guaranteed to include the attributes 'start_time' and
+            'end_time' which will both be seconds since the unix epoch (UTC).
+        """
+        sql = (
+            "SELECT data, start_time, end_time FROM time_sensitive_settings WHERE "
+            "game = :game AND version = :version AND name = :name AND start_time <= :time AND end_time > :time"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'name': name, 'time': Time.now()})
+        if cursor.rowcount != 1:
+            # setting doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        retval = ValidatedDict(self.deserialize(result['data']))
+        retval['start_time'] = result['start_time']
+        retval['end_time'] = result['end_time']
+        return retval
+
+    def get_all_time_sensitive_settings(self, game: str, version: int, name: str) -> List[ValidatedDict]:
+        """
+        Given a game/version/name, look up all of the time-sensitive settings for this game.
+
+        Parameters:
+            game - String identifier of the game we want settings for.
+            version - Integer identifying the game version we want settings for.
+            name - The name of the setting we are concerned with.
+
+        Returns:
+            A list of ValidatedDict of stored settings if there were settings found, or [] otherwise.
+            If settings were found, they are guaranteed to include the attributes 'start_time' and
+            'end_time' which will both be seconds since the unix epoch (UTC).
+        """
+        sql = (
+            "SELECT data, start_time, end_time FROM time_sensitive_settings WHERE "
+            "game = :game AND version = :version AND name = :name"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'name': name})
+        if cursor.rowcount == 0:
+            # setting doesn't exist
+            return []
+
+        settings = []
+        for result in cursor.fetchall():
+            retval = ValidatedDict(self.deserialize(result['data']))
+            retval['start_time'] = result['start_time']
+            retval['end_time'] = result['end_time']
+            settings.append(retval)
+        return settings
+
+    def put_time_sensitive_settings(self, game: str, version: int, name: str, settings: Dict[str, Any]) -> None:
+        """
+        Given a game/version/name and a settings dictionary that contains 'start_time' and 'end_time',
+        as seconds since the unix epoch (UTC), update the DB to store or update this time-sensitive
+        setting. Verifies that start time comes before end time, that there is at least one second in
+        the setting duration, and that this setting doesn't overlap any other setting already present.
+
+        Parameters:
+            game - String identifier of the game we want settings for.
+            version - Integer identifying the game version we want settings for.
+            name - The name of the setting we are concerned with.
+            settings - A dictionary containing at least 'start_time' and 'end_time'.
+        """
+        start_time = settings['start_time']
+        end_time = settings['end_time']
+        del settings['start_time']
+        del settings['end_time']
+
+        if start_time > end_time:
+            raise Exception('Start time is greater than end time!')
+        if start_time == end_time:
+            raise Exception('This setting spans zero seconds!')
+
+        # Verify that this isn't overlapping some event.
+        sql = """
+            SELECT start_time, end_time FROM time_sensitive_settings WHERE
+            game = :game AND version = :version AND name = :name AND
+            (
+              (start_time >= :start_time AND start_time < :end_time) OR
+              (end_time > :start_time AND end_time <= :end_time) OR
+              (start_time < :start_time AND end_time > :end_time)
+            )
+        """
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'name': name,
+                'start_time': start_time,
+                'end_time': end_time,
+            },
+        )
+        for result in cursor.fetchall():
+            if result['start_time'] == start_time and result['end_time'] == end_time:
+                # This is just this event being updated, that's fine.
+                continue
+            raise Exception('This event overlaps an existing one with start time {} and end time {}'.format(
+                result['start_time'],
+                result['end_time'],
+            ))
+
+        # Insert or update this setting
+        sql = (
+            "INSERT INTO time_sensitive_settings (game, version, name, start_time, end_time, data) "
+            "VALUES (:game, :version, :name, :start_time, :end_time, :data) "
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'name': name,
+                'start_time': start_time,
+                'end_time': end_time,
+                'data': self.serialize(settings),
+            },
+        )
+
+    def get_item(self, game: str, version: int, catid: int, cattype: str) -> Optional[ValidatedDict]:
+        """
+        Given a game/userid and catalog id/type, find that catalog entry.
+
+        Note that there can be more than one catalog entry with the same ID and game/userid
+        as long as each one is a different type. Essentially, cattype namespaces catalog entry.
+
+        Parameters:
+            game - String identifier of the game looking up this entry.
+            version - Integer identifier of the version looking up this entry.
+            catid - Integer ID, as provided by a game.
+            cattype - The type of catalog entry.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        sql = (
+            "SELECT data FROM catalog "
+            "WHERE game = :game AND version = :version AND id = :id AND type = :type"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'id': catid, 'type': cattype})
+        if cursor.rowcount != 1:
+            # entry doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def get_items(self, game: str, version: int) -> List[Item]:
+        """
+        Given a game/userid, find all items in the catalog.
+
+        Parameters:
+            game - String identifier of the game looking up the catalog.
+            version - Integer identifier of the version looking up this catalog.
+
+        Returns:
+            A list of Item objects.
+        """
+        sql = "SELECT id, type, data FROM catalog WHERE game = :game AND version = :version"
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        catalog = []
+        for result in cursor.fetchall():
+            catalog.append(
+                Item(
+                    result['type'],
+                    result['id'],
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return catalog
diff --git a/bemani/data/mysql/lobby.py b/bemani/data/mysql/lobby.py
new file mode 100644
index 0000000..1423e01
--- /dev/null
+++ b/bemani/data/mysql/lobby.py
@@ -0,0 +1,294 @@
+import copy
+
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.types import String, Integer, JSON  # type: ignore
+from sqlalchemy.dialects.mysql import BIGINT as BigInteger  # type: ignore
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.common import ValidatedDict, Time
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.types import UserID
+
+"""
+Table for storing logistical information about a player who's session is
+live. Mostly, this is used to store IP addresses and such for players that
+could potentially match.
+"""
+playsession = Table(  # type: ignore
+    'playsession',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('time', Integer, nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing open lobbies for matching between games.
+"""
+lobby = Table(  # type: ignore
+    'lobby',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('time', Integer, nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
+    mysql_charset='utf8mb4',
+)
+
+
+class LobbyData(BaseData):
+
+    def get_play_session_info(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game, version and a user ID, look up play session information for that user.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+            userid - Integer identifying a user, as possibly looked up by UserData.
+
+        Returns:
+            A dictionary representing play session info stored by a game class, or None
+            if there is no active session for this game/version/user. The dictionary will
+            always contain an 'id' field which is the play session ID, and a 'time' field
+            which represents the timestamp when the play session began.
+        """
+        sql = (
+            "SELECT id, time, data FROM playsession "
+            "WHERE game = :game AND version = :version AND userid = :userid "
+            "AND time > :time"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'userid': userid,
+                'time': Time.now() - Time.SECONDS_IN_HOUR,
+            },
+        )
+
+        if cursor.rowcount != 1:
+            # Settings doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        data = ValidatedDict(self.deserialize(result['data']))
+        data['id'] = result['id']
+        data['time'] = result['time']
+        return data
+
+    def get_all_play_session_infos(self, game: str, version: int) -> List[Tuple[UserID, ValidatedDict]]:
+        """
+        Given a game and version, look up all play session information.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+
+        Returns:
+            A list of Tuples, consisting of a UserID and the dictionary that would be
+            returned for that user if get_play_session_info() was called for that user.
+        """
+        sql = (
+            "SELECT id, time, userid, data FROM playsession "
+            "WHERE game = :game AND version = :version "
+            "AND time > :time"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'time': Time.now() - Time.SECONDS_IN_HOUR,
+            },
+        )
+
+        ret = []
+        for result in cursor.fetchall():
+            data = ValidatedDict(self.deserialize(result['data']))
+            data['id'] = result['id']
+            data['time'] = result['time']
+            ret.append((UserID(result['userid']), data))
+        return ret
+
+    def put_play_session_info(self, game: str, version: int, userid: UserID, data: Dict[str, Any]) -> None:
+        """
+        Given a game, version and a user ID, save play session information for that user.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+            userid - Integer identifying a user.
+            data - A dictionary of play session information to store.
+        """
+        data = copy.deepcopy(data)
+        if 'id' in data:
+            del data['id']
+
+        # Add json to player session
+        sql = (
+            "INSERT INTO playsession (game, version, userid, time, data) " +
+            "VALUES (:game, :version, :userid, :time, :data) " +
+            "ON DUPLICATE KEY UPDATE time=VALUES(time), data=VALUES(data)"
+        )
+        self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'userid': userid,
+                'time': Time.now(),
+                'data': self.serialize(data),
+            },
+        )
+
+    def destroy_play_session_info(self, game: str, version: int, userid: UserID) -> None:
+        """
+        Given a game, version and a user ID, throw away session info for that play session.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+            userid - Integer identifying a user, as possibly looked up by UserData.
+        """
+        # Kill this play session
+        sql = (
+            "DELETE FROM playsession WHERE game = :game AND version = :version AND userid = :userid"
+        )
+        self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'userid': userid,
+            },
+        )
+        # Prune any orphaned lobbies too
+        sql = "DELETE FROM playsession WHERE time <= :time"
+        self.execute(sql, {'time': Time.now() - Time.SECONDS_IN_HOUR})
+
+    def get_lobby(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game, version and a user ID, look up lobby information for that user.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+            userid - Integer identifying a user, as possibly looked up by UserData.
+
+        Returns:
+            A dictionary representing lobby info stored by a game class, or None
+            if there is no active session for this game/version/user. The dictionary will
+            always contain an 'id' field which is the lobby ID, and a 'time' field representing
+            the timestamp the lobby was created.
+        """
+        sql = (
+            "SELECT id, time, data FROM lobby "
+            "WHERE game = :game AND version = :version AND userid = :userid "
+            "AND time > :time"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'userid': userid,
+                'time': Time.now() - Time.SECONDS_IN_HOUR,
+            },
+        )
+
+        if cursor.rowcount != 1:
+            # Settings doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        data = ValidatedDict(self.deserialize(result['data']))
+        data['id'] = result['id']
+        data['time'] = result['time']
+        return data
+
+    def get_all_lobbies(self, game: str, version: int) -> List[Tuple[UserID, ValidatedDict]]:
+        """
+        Given a game and version, look up all active lobbies.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+
+        Returns:
+            A list of dictionaries representing lobby info stored by a game class.
+        """
+        sql = (
+            "SELECT userid, id, data FROM lobby "
+            "WHERE game = :game AND version = :version AND time > :time"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'time': Time.now() - Time.SECONDS_IN_HOUR,
+            },
+        )
+
+        ret = []
+        for result in cursor.fetchall():
+            data = ValidatedDict(self.deserialize(result['data']))
+            data['id'] = result['id']
+            ret.append((UserID(result['userid']), data))
+        return ret
+
+    def put_lobby(self, game: str, version: int, userid: UserID, data: Dict[str, Any]) -> None:
+        """
+        Given a game, version and a user ID, save lobby information for that user.
+
+        Parameters:
+            game - String identifying a game series.
+            version - Integer identifying the version of the game in the series.
+            userid - Integer identifying a user.
+            data - A dictionary of lobby information to store.
+        """
+        data = copy.deepcopy(data)
+        if 'id' in data:
+            del data['id']
+
+        # Add json to lobby
+        sql = (
+            "INSERT INTO lobby (game, version, userid, time, data) " +
+            "VALUES (:game, :version, :userid, :time, :data) " +
+            "ON DUPLICATE KEY UPDATE time=VALUES(time), data=VALUES(data)"
+        )
+        self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'userid': userid,
+                'time': Time.now(),
+                'data': self.serialize(data),
+            },
+        )
+
+    def destroy_lobby(self, lobbyid: int) -> None:
+        """
+        Given a lobby ID, destroy the lobby. The lobby ID can be obtained by reading
+        the 'id' field of the get_lobby response.
+
+        Parameters:
+            lobbyid: Integer identifying a lobby.
+        """
+        # Delete this lobby
+        sql = "DELETE FROM lobby WHERE id = :id"
+        self.execute(sql, {'id': lobbyid})
+        # Prune any orphaned lobbies too
+        sql = "DELETE FROM lobby WHERE time <= :time"
+        self.execute(sql, {'time': Time.now() - Time.SECONDS_IN_HOUR})
diff --git a/bemani/data/mysql/machine.py b/bemani/data/mysql/machine.py
new file mode 100644
index 0000000..85803de
--- /dev/null
+++ b/bemani/data/mysql/machine.py
@@ -0,0 +1,505 @@
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.types import String, Integer, JSON  # type: ignore
+from sqlalchemy.dialects.mysql import BIGINT as BigInteger  # type: ignore
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.common import ValidatedDict
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.types import Machine, Arcade, UserID, ArcadeID
+
+"""
+Table for storing recognized machines on the network. This is used in conjunction
+with PCBID enforcement to ensure machines not authorized on the network are denied
+a connection. It is also used for settings such as port forwarding and which arcade
+a machine belongs to for the purpose of PASELI balance.
+"""
+machine = Table(  # type: ignore
+    'machine',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('pcbid', String(20), nullable=False, unique=True),
+    Column('name', String(255), nullable=False),
+    Column('description', String(255), nullable=False),
+    Column('arcadeid', Integer),
+    Column('port', Integer, nullable=False, unique=True),
+    Column('game', String(20)),
+    Column('version', Integer),
+    Column('data', JSON),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing an arcade, to which zero or more machines may belong. This allows
+an arcade to override some global settings such as PASELI enabled and infinite.
+"""
+arcade = Table(  # type: ignore
+    'arcade',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('name', String(255), nullable=False),
+    Column('description', String(255), nullable=False),
+    Column('pin', String(8), nullable=False),
+    Column('data', JSON),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing arcade ownership. This allows for more than one owner to own an arcade.
+"""
+arcade_owner = Table(  # type: ignore
+    'arcade_owner',
+    metadata,
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('arcadeid', Integer, nullable=False),
+    UniqueConstraint('userid', 'arcadeid', name='userid_arcadeid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing arcade settings for a particular game/version. This allows the arcade
+owner to change settings related to a particular game, such as the events active or the
+shop ranking courses.
+"""
+arcade_settings = Table(  # type: ignore
+    'arcade_settings',
+    metadata,
+    Column('arcadeid', Integer, nullable=False),
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('arcadeid', 'game', 'version', 'type', name='arcadeid_game_version_type'),
+    mysql_charset='utf8mb4',
+)
+
+
+class ArcadeCreationException(Exception):
+    pass
+
+
+class MachineData(BaseData):
+
+    def from_port(self, port: int) -> Optional[str]:
+        """
+        Given a port, look up the PCBID attached to that port.
+
+        Parameters:
+            port - Integer specifying the port we are interested in.
+
+        Returns:
+            A string representing the PCBID of a machine attached to a port, or None if
+            there is no machine matching this port.
+        """
+        sql = "SELECT pcbid FROM machine WHERE port = :port LIMIT 1"
+        cursor = self.execute(sql, {'port': port})
+        if cursor.rowcount != 1:
+            # Machine doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return result['pcbid']
+
+    def from_machine_id(self, machine_id: int) -> Optional[str]:
+        """
+        Given a machine ID, look up the PCBID attached to that ID.
+
+        Parameters:
+            machine_id - Integer specifying the machine ID we are interested in.
+
+        Returns:
+            A string representing the PCBID of a machine attached to that ID, or None if
+            there is no machine matching this ID.
+        """
+        sql = "SELECT pcbid FROM machine WHERE id = :id LIMIT 1"
+        cursor = self.execute(sql, {'id': machine_id})
+        if cursor.rowcount != 1:
+            # Machine doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return result['pcbid']
+
+    def from_userid(self, userid: UserID) -> List[ArcadeID]:
+        """
+        Given a user ID, look up the arcades that this user owns.
+
+        Parameters:
+            userid - Integer specifying the user we are interested in.
+
+        Returns:
+            A list of integer IDs of the arcades this user owns.
+        """
+        sql = "SELECT arcadeid FROM arcade_owner WHERE userid = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        return [ArcadeID(result['arcadeid']) for result in cursor.fetchall()]
+
+    def from_session(self, session: str) -> Optional[ArcadeID]:
+        """
+        Given a previously-opened session, look up a user ID.
+
+        Parameters:
+            session - String identifying a session that was opened by create_session.
+
+        Returns:
+            User ID as an integer if found, or None if the session is expired or doesn't exist.
+        """
+        arcadeid = self._from_session(session, 'arcadeid')
+        if arcadeid is None:
+            return None
+        return ArcadeID(arcadeid)
+
+    def get_machine(self, pcbid: str) -> Optional[Machine]:
+        """
+        Given a PCBID, look up a machine.
+
+        Parameters:
+            pcbid - The PCBID as returned from a game.
+
+        Returns:
+            A Machine object representing a machine, or None if not found.
+        """
+        sql = "SELECT name, description, arcadeid, id, port, game, version, data FROM machine WHERE pcbid = :pcbid"
+        cursor = self.execute(sql, {'pcbid': pcbid})
+        if cursor.rowcount != 1:
+            # Machine doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return Machine(
+            result['id'],
+            pcbid,
+            result['name'],
+            result['description'],
+            result['arcadeid'],
+            result['port'],
+            result['game'],
+            result['version'],
+            self.deserialize(result['data']),
+        )
+
+    def get_all_machines(self, arcade: Optional[ArcadeID]=None) -> List[Machine]:
+        """
+        Look up all machines on the network.
+
+        Returns:
+            A list of Machine objects representing a machine.
+        """
+        sql = "SELECT pcbid, name, description, arcadeid, id, port, game, version, data FROM machine"
+        data = {}
+        if arcade is not None:
+            sql = sql + ' WHERE arcadeid = :arcade'
+            data['arcade'] = arcade
+
+        cursor = self.execute(sql, data)
+        return [
+            Machine(
+                result['id'],
+                result['pcbid'],
+                result['name'],
+                result['description'],
+                result['arcadeid'],
+                result['port'],
+                result['game'],
+                result['version'],
+                self.deserialize(result['data']),
+            ) for result in cursor.fetchall()
+        ]
+
+    def put_machine(self, machine: Machine) -> None:
+        """
+        Given a Machine object, update the database with new information.
+
+        Parameters:
+            machine - A Machine object representing a machine.
+        """
+        # Update machine name based on game
+        sql = (
+            "UPDATE `machine` SET name = :name, description = :description, arcadeid = :arcadeid, " +
+            "port = :port, game = :game, version = :version, data = :data WHERE pcbid = :pcbid LIMIT 1"
+        )
+        self.execute(
+            sql,
+            {
+                'name': machine.name,
+                'description': machine.description,
+                'arcadeid': machine.arcade,
+                'port': machine.port,
+                'game': machine.game,
+                'version': machine.version,
+                'pcbid': machine.pcbid,
+                'data': self.serialize(machine.data)
+            },
+        )
+
+    def create_machine(self, pcbid: str, name: str='なし', description: str='', arcade: Optional[ArcadeID]=None) -> Machine:
+        """
+        Given a PCBID, create a new machine entry.
+
+        Parameters:
+            pcbid - The PCBID as returned from a game.
+            name - String specifying the name of the machine. Defaults to
+                   なし which means nothing in japanese.
+            description - String specifying a description of the machine. Defaults to blank.
+            arcade - Optional integer specifying the ID of the arcade owning
+                     this machine.
+
+        Returns:
+            A Machine object representing the newly-created machine.
+        """
+        while True:
+            # Grab next available port
+            sql = "SELECT MAX(port) AS port FROM machine"
+            cursor = self.execute(sql)
+            if cursor.rowcount != 1:
+                # No machines yet
+                port = None
+            else:
+                # Grab highest port
+                result = cursor.fetchone()
+                port = result['port']
+                if port is not None:
+                    port = port + 1
+            # Default if we didn't get a port
+            if port is None:
+                port = 10000
+
+            # Add new machine
+            try:
+                sql = (
+                    "INSERT INTO `machine` (pcbid, name, description, port, arcadeid) " +
+                    "VALUES (:pcbid, :name, :description, :port, :arcadeid)"
+                )
+                self.execute(sql, {'pcbid': pcbid, 'name': name, 'description': description, 'port': port, 'arcadeid': arcade})
+            except Exception:
+                # Failed to add machine, try with new port
+                continue
+
+            machine = self.get_machine(pcbid)
+            if machine is not None:
+                return machine
+
+    def destroy_machine(self, pcbid: str) -> None:
+        """
+        Given an PCBID, destroy the machine associated with this PCBID.
+
+        Parameters:
+            pcbid - The PCBID as returned from a game.
+        """
+        sql = "DELETE FROM `machine` WHERE pcbid = :pcbid LIMIT 1"
+        self.execute(sql, {'pcbid': pcbid})
+
+    def create_arcade(self, name: str, description: str, data: Dict[str, Any], owners: List[int]) -> Arcade:
+        """
+        Given a set of values, create a new arcade and return the ID of that arcade.
+
+        Returns:
+            An Arcade object representing this arcade
+        """
+        sql = (
+            "INSERT INTO arcade (name, description, data, pin) " +
+            "VALUES (:name, :desc, :data, '00000000')"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'name': name,
+                'desc': description,
+                'data': self.serialize(data),
+            },
+        )
+        if cursor.rowcount != 1:
+            raise ArcadeCreationException('Failed to create arcade!')
+        arcadeid = cursor.lastrowid
+        for owner in owners:
+            sql = "INSERT INTO arcade_owner (userid, arcadeid) VALUES(:userid, :arcadeid)"
+            self.execute(sql, {'userid': owner, 'arcadeid': arcadeid})
+        return self.get_arcade(arcadeid)
+
+    def get_arcade(self, arcadeid: ArcadeID) -> Optional[Arcade]:
+        """
+        Given an arcade ID, look up the arcade.
+
+        Parameters:
+            arcadeid - The integer arcade ID, most likely returned from a get_machine query.
+
+        Returns:
+            An Arcade object if this arcade was found, or None otherwise.
+        """
+        sql = (
+            "SELECT name, description, pin, data FROM arcade WHERE id = :id"
+        )
+        cursor = self.execute(sql, {'id': arcadeid})
+        if cursor.rowcount != 1:
+            # Arcade doesn't exist
+            return None
+
+        result = cursor.fetchone()
+
+        sql = "SELECT userid FROM arcade_owner WHERE arcadeid = :id"
+        cursor = self.execute(sql, {'id': arcadeid})
+
+        return Arcade(
+            arcadeid,
+            result['name'],
+            result['description'],
+            result['pin'],
+            self.deserialize(result['data']),
+            [owner['userid'] for owner in cursor.fetchall()],
+        )
+
+    def put_arcade(self, arcade: Arcade) -> None:
+        """
+        Given an arcade, update the DB to match the new values
+
+        Parameters:
+            arcade - An Arcade object that should be updated.
+        """
+        # Update machine name based on game
+        sql = (
+            "UPDATE `arcade` " +
+            "SET name = :name, description = :desc, pin = :pin, data = :data " +
+            "WHERE id = :arcadeid"
+        )
+        self.execute(
+            sql,
+            {
+                'name': arcade.name,
+                'desc': arcade.description,
+                'pin': arcade.pin,
+                'data': self.serialize(arcade.data),
+                'arcadeid': arcade.id,
+            },
+        )
+        sql = "DELETE FROM `arcade_owner` WHERE arcadeid = :arcadeid"
+        self.execute(sql, {'arcadeid': arcade.id})
+        for owner in arcade.owners:
+            sql = "INSERT INTO arcade_owner (userid, arcadeid) VALUES(:userid, :arcadeid)"
+            self.execute(sql, {'userid': owner, 'arcadeid': arcade.id})
+
+    def destroy_arcade(self, arcadeid: ArcadeID) -> None:
+        """
+        Given an arcade ID, remove the arcade from the DB and unlink any PCBIDs
+        associated with it.
+
+        Parameters:
+            arcadeid - Integer specifying the arcade to delete.
+        """
+        sql = "DELETE FROM `arcade` WHERE id = :arcadeid LIMIT 1"
+        self.execute(sql, {'arcadeid': arcadeid})
+        sql = "DELETE FROM `arcade_owner` WHERE arcadeid = :arcadeid"
+        self.execute(sql, {'arcadeid': arcadeid})
+        sql = "UPDATE `machine` SET arcadeid = NULL WHERE arcadeid = :arcadeid"
+        self.execute(sql, {'arcadeid': arcadeid})
+
+    def get_all_arcades(self) -> List[Arcade]:
+        """
+        List all known arcades in the system.
+
+        Returns:
+            A list of Arcade objects.
+        """
+        sql = "SELECT userid, arcadeid FROM arcade_owner"
+        cursor = self.execute(sql)
+        arcade_to_owners: Dict[int, List[UserID]] = {}
+        for row in cursor.fetchall():
+            arcade = row['arcadeid']
+            owner = UserID(row['userid'])
+            if arcade not in arcade_to_owners:
+                arcade_to_owners[arcade] = []
+            arcade_to_owners[arcade].append(owner)
+
+        sql = "SELECT id, name, description, pin, data FROM arcade"
+        cursor = self.execute(sql)
+        return [
+            Arcade(
+                ArcadeID(result['id']),
+                result['name'],
+                result['description'],
+                result['pin'],
+                self.deserialize(result['data']),
+                arcade_to_owners.get(result['id'], []),
+            ) for result in cursor.fetchall()
+        ]
+
+    def get_settings(self, arcadeid: ArcadeID, game: str, version: int, setting: str) -> Optional[ValidatedDict]:
+        """
+        Given an arcade and a game/version combo, look up this particular setting.
+
+        Parameters:
+            arcadeid - Integer specifying the arcade to delete.
+            game - String identifying a game series.
+            version - String identifying a game version.
+            setting - String identifying the particular setting we're interestsed in.
+
+        Returns:
+            A dictionary representing game settings, or None if there are no settings for this game/user.
+        """
+        sql = "SELECT data FROM arcade_settings WHERE arcadeid = :id AND game = :game AND version = :version AND type = :type"
+        cursor = self.execute(sql, {'id': arcadeid, 'game': game, 'version': version, 'type': setting})
+
+        if cursor.rowcount != 1:
+            # Settings doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def put_settings(self, arcadeid: ArcadeID, game: str, version: int, setting: str, data: Dict[str, Any]) -> None:
+        """
+        Given an arcade and a game/version combo, update the particular setting.
+
+        Parameters:
+            arcadeid - Integer specifying the arcade to delete.
+            game - String identifying a game series.
+            version - String identifying a game version.
+            setting - String identifying the particular setting we're interestsed in.
+            data - A dictionary that should be saved for this setting.
+        """
+        sql = (
+            "INSERT INTO arcade_settings (arcadeid, game, version, type, data) " +
+            "VALUES (:id, :game, :version, :type, :data) "
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'id': arcadeid, 'game': game, 'version': version, 'type': setting, 'data': self.serialize(data)})
+
+    def get_balances(self, arcadeid: ArcadeID) -> List[Tuple[UserID, int]]:
+        """
+        Given an arcade ID, look up all user's PASELI balances for that arcade.
+
+        Parameters:
+            arcadeid - The arcade in question.
+
+        Returns:
+            The PASELI balance for each user at this arcade.
+        """
+        sql = "SELECT userid, balance FROM balance WHERE arcadeid = :arcadeid"
+        cursor = self.execute(sql, {'arcadeid': arcadeid})
+        balances = []
+        for entry in cursor.fetchall():
+            balances.append((
+                UserID(entry['userid']),
+                entry['balance'],
+            ))
+        return balances
+
+    def create_session(self, arcadeid: ArcadeID, expiration: int=(30 * 86400)) -> str:
+        """
+        Given a user ID, create a session string.
+
+        Parameters:
+            arcadeid - Arcade ID we wish to start a session for.
+            expiration - Number of seconds before this session is invalid.
+
+        Returns:
+            A string that can be used as a session ID.
+        """
+        return self._create_session(arcadeid, 'arcadeid', expiration)
+
+    def destroy_session(self, session: str) -> None:
+        """
+        Destroy a previously-created session.
+
+        Parameters:
+            session - A session string as returned from create_session.
+        """
+        self._destroy_session(session, 'arcadeid')
diff --git a/bemani/data/mysql/music.py b/bemani/data/mysql/music.py
new file mode 100644
index 0000000..5c906ca
--- /dev/null
+++ b/bemani/data/mysql/music.py
@@ -0,0 +1,949 @@
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.exc import IntegrityError  # type: ignore
+from sqlalchemy.types import String, Integer, JSON  # type: ignore
+from sqlalchemy.dialects.mysql import BIGINT as BigInteger  # type: ignore
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.common import Time
+from bemani.data.exceptions import ScoreSaveException
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.types import Score, Attempt, Song, UserID
+
+"""
+Table for storing a score for a particular game. This is keyed by userid and
+musicid, as a user can only have one score for a particular song/chart combo.
+This has a JSON blob for any data the game wishes to store, such as points, medals,
+ghost, etc.
+
+Note that this is NOT keyed by game song id and chart, but by an internal musicid
+managed by the music table. This is so we can support keeping the same score across
+multiple games, even if the game changes the ID it refers to the song by.
+"""
+score = Table(  # type: ignore
+    'score',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('musicid', Integer, nullable=False, index=True),
+    Column('points', Integer, nullable=False, index=True),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('update', Integer, nullable=False, index=True),
+    Column('lid', Integer, nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('userid', 'musicid', name='userid_musicid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing score history for a particular game. Every entry that is stored
+or updated in score will be written into this table as well, for looking up history
+over time.
+"""
+score_history = Table(  # type: ignore
+    'score_history',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('musicid', Integer, nullable=False, index=True),
+    Column('points', Integer, nullable=False),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('lid', Integer, nullable=False, index=True),
+    Column('new_record', Integer, nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('userid', 'musicid', 'timestamp', name='userid_musicid_timestamp'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing the mapping between game songid/chart and musicid for the score
+and score_history table. To find scores, you will want to join this table with
+the score table where id = score.musicid and game/version/songid/chart matches.
+
+NOTE that it is expected to see the same songid/chart present multiple times as long
+as the game version changes. In this way, a song which is in multiple versions of
+the game can be found when playing each version.
+"""
+music = Table(  # type: ignore
+    'music',
+    metadata,
+    Column('id', Integer, nullable=False, index=True),
+    Column('songid', Integer, nullable=False),
+    Column('chart', Integer, nullable=False),
+    Column('game', String(32), nullable=False, index=True),
+    Column('version', Integer, nullable=False, index=True),
+    Column('name', String(255)),
+    Column('artist', String(255)),
+    Column('genre', String(255)),
+    Column('data', JSON),
+    UniqueConstraint('songid', 'chart', 'game', 'version', name='songid_chart_game_version'),
+    mysql_charset='utf8mb4',
+)
+
+
+class MusicData(BaseData):
+
+    def __get_musicid(self, game: str, version: int, songid: int, songchart: int) -> int:
+        """
+        Given a game/version/songid/chart, look up the unique music ID for this song.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            songid - ID of the song according to the game.
+            songchart - Chart number according to the game.
+
+        Returns:
+            Integer representing music ID if found or raises an exception otherwise.
+        """
+        sql = (
+            "SELECT id FROM music WHERE songid = :songid AND chart = :chart AND game = :game AND version = :version"
+        )
+        cursor = self.execute(sql, {'songid': songid, 'chart': songchart, 'game': game, 'version': version})
+        if cursor.rowcount != 1:
+            # music doesn't exist
+            raise Exception('Song {} chart {} doesn\'t exist for game {} version {}'.format(
+                songid,
+                songchart,
+                game,
+                version,
+            ))
+        result = cursor.fetchone()
+        return result['id']
+
+    def put_score(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        songid: int,
+        songchart: int,
+        location: int,
+        points: int,
+        data: Dict[str, Any],
+        new_record: bool,
+        timestamp: Optional[int]=None,
+    ) -> None:
+        """
+        Given a game/version/song/chart and user ID, save a new/updated high score.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userid - Integer representing a user. Usually looked up with UserData.
+            songid - ID of the song according to the game.
+            songchart - Chart number according to the game.
+            location - Machine ID where this score was earned.
+            points - Points obtained on this song.
+            data - Data that the game wishes to record along with the score.
+            new_record - Whether this score was a new record or not.
+            timestamp - Optional integer specifying when the high score happened.
+        """
+        # First look up the song/chart from the music DB
+        musicid = self.__get_musicid(game, version, songid, songchart)
+        ts = timestamp if timestamp is not None else Time.now()
+
+        # Add to user score
+        if new_record:
+            # We want to update the timestamp/location to now if its a new record.
+            sql = (
+                "INSERT INTO `score` (`userid`, `musicid`, `points`, `data`, `timestamp`, `update`, `lid`) " +
+                "VALUES (:userid, :musicid, :points, :data, :timestamp, :update, :location) " +
+                "ON DUPLICATE KEY UPDATE data = VALUES(data), points = VALUES(points), " +
+                "timestamp = VALUES(timestamp), `update` = VALUES(`update`), lid = VALUES(lid)"
+            )
+        else:
+            # We only want to add the timestamp if it is new.
+            sql = (
+                "INSERT INTO `score` (`userid`, `musicid`, `points`, `data`, `timestamp`, `update`, `lid`) " +
+                "VALUES (:userid, :musicid, :points, :data, :timestamp, :update, :location) " +
+                "ON DUPLICATE KEY UPDATE data = VALUES(data), points = VALUES(points), `update` = VALUES(`update`)"
+            )
+        self.execute(
+            sql,
+            {
+                'userid': userid,
+                'musicid': musicid,
+                'points': points,
+                'data': self.serialize(data),
+                'timestamp': ts,
+                'update': ts,
+                'location': location,
+            }
+        )
+
+    def put_attempt(
+        self,
+        game: str,
+        version: int,
+        userid: Optional[UserID],
+        songid: int,
+        songchart: int,
+        location: int,
+        points: int,
+        data: Dict[str, Any],
+        new_record: bool,
+        timestamp: Optional[int]=None,
+    ) -> None:
+        """
+        Given a game/version/song/chart and user ID, save a single score attempt.
+
+        Note that this is different than put_score above, because a user may have only one score
+        per song/chart in a given game, but they can have as many history entries as times played.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userid - Integer representing a user. Usually looked up with UserData.
+            songid - ID of the song according to the game.
+            songchart - Chart number according to the game.
+            location - Machine ID where this score was earned.
+            points - Points obtained on this song.
+            data - Optional data that the game wishes to record along with the score.
+            new_record - Whether this score was a new record or not.
+            timestamp - Optional integer specifying when the attempt happened.
+        """
+        # First look up the song/chart from the music DB
+        musicid = self.__get_musicid(game, version, songid, songchart)
+        ts = timestamp if timestamp is not None else Time.now()
+
+        # Add to score history
+        sql = (
+            "INSERT INTO `score_history` (userid, musicid, timestamp, lid, new_record, points, data) " +
+            "VALUES (:userid, :musicid, :timestamp, :location, :new_record, :points, :data)"
+        )
+        try:
+            self.execute(
+                sql,
+                {
+                    'userid': userid if userid is not None else 0,
+                    'musicid': musicid,
+                    'timestamp': ts,
+                    'location': location,
+                    'new_record': 1 if new_record else 0,
+                    'points': points,
+                    'data': self.serialize(data),
+                },
+            )
+        except IntegrityError:
+            raise ScoreSaveException(
+                'There is already an attempt by {} for music id {} at {}'.format(
+                    userid if userid is not None else 0,
+                    musicid,
+                    ts,
+                )
+            )
+
+    def get_score(self, game: str, version: int, userid: UserID, songid: int, songchart: int) -> Optional[Score]:
+        """
+        Look up a user's previous high score.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userid - Integer representing a user. Usually looked up with UserData.
+            songid - ID of the song according to the game.
+            songchart - Chart number according to the game.
+
+        Returns:
+            The optional data stored by the game previously, or None if no score exists.
+        """
+        sql = (
+            "SELECT music.songid AS songid, music.chart AS chart, score.id AS scorekey, score.timestamp AS timestamp, score.update AS `update`, score.lid AS lid, " +
+            "(select COUNT(score_history.timestamp) FROM score_history WHERE score_history.musicid = music.id AND score_history.userid = :userid) AS plays, " +
+            "score.points AS points, score.data AS data FROM score, music WHERE score.userid = :userid AND score.musicid = music.id " +
+            "AND music.game = :game AND music.version = :version AND music.songid = :songid AND music.chart = :songchart"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'userid': userid,
+                'game': game,
+                'version': version,
+                'songid': songid,
+                'songchart': songchart,
+            },
+        )
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return Score(
+            result['scorekey'],
+            result['songid'],
+            result['chart'],
+            result['points'],
+            result['timestamp'],
+            result['update'],
+            result['lid'],
+            result['plays'],
+            self.deserialize(result['data']),
+        )
+
+    def get_score_by_key(self, game: str, version: int, key: int) -> Optional[Tuple[UserID, Score]]:
+        """
+        Look up previous high score by key.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            key - Integer representing a unique key fetched in a previous Score lookup.
+
+        Returns:
+            The optional data stored by the game previously, or None if no score exists.
+        """
+        sql = (
+            "SELECT music.songid AS songid, music.chart AS chart, score.id AS scorekey, score.timestamp AS timestamp, score.update AS `update`, " +
+            "score.userid AS userid, score.lid AS lid, " +
+            "(select COUNT(score_history.timestamp) FROM score_history WHERE score_history.musicid = music.id AND score_history.userid = score.userid) AS plays, " +
+            "score.points AS points, score.data AS data FROM score, music WHERE score.id = :scorekey AND score.musicid = music.id " +
+            "AND music.game = :game AND music.version = :version"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'scorekey': key,
+            },
+        )
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return (
+            UserID(result['userid']),
+            Score(
+                result['scorekey'],
+                result['songid'],
+                result['chart'],
+                result['points'],
+                result['timestamp'],
+                result['update'],
+                result['lid'],
+                result['plays'],
+                self.deserialize(result['data']),
+            )
+        )
+
+    def get_scores(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Score]:
+        """
+        Look up all of a user's previous high scores.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userid - Integer representing a user. Usually looked up with UserData.
+
+        Returns:
+            A list of Score objects representing all high scores for a game.
+        """
+        sql = (
+            "SELECT music.songid AS songid, music.chart AS chart, score.id AS scorekey, score.timestamp AS timestamp, score.update AS `update`, score.lid AS lid, " +
+            "(select COUNT(score_history.timestamp) FROM score_history WHERE score_history.musicid = music.id AND score_history.userid = :userid) AS plays, " +
+            "score.points AS points, score.data AS data FROM score, music WHERE score.userid = :userid AND score.musicid = music.id " +
+            "AND music.game = :game AND music.version = :version"
+        )
+        if since is not None:
+            sql = sql + ' AND score.update >= :since'
+        if until is not None:
+            sql = sql + ' AND score.update < :until'
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version, 'since': since, 'until': until})
+
+        scores = []
+        for result in cursor.fetchall():
+            scores.append(
+                Score(
+                    result['scorekey'],
+                    result['songid'],
+                    result['chart'],
+                    result['points'],
+                    result['timestamp'],
+                    result['update'],
+                    result['lid'],
+                    result['plays'],
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return scores
+
+    def get_most_played(self, game: str, version: int, userid: UserID, count: int) -> List[Tuple[int, int]]:
+        """
+        Look up a user's most played songs.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userid - Integer representing a user. Usually looked up with UserData.
+            count - Number of scores to look up.
+
+        Returns:
+            A list of tuples, containing the songid and the number of plays across all charts for that song.
+        """
+        sql = (
+            "SELECT music.songid AS songid, COUNT(score_history.timestamp) AS plays FROM score_history, music " +
+            "WHERE score_history.userid = :userid AND score_history.musicid = music.id " +
+            "AND music.game = :game AND music.version = :version " +
+            "GROUP BY songid ORDER BY plays DESC LIMIT :count"
+        )
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version, 'count': count})
+
+        most_played = []
+        for result in cursor.fetchall():
+            most_played.append(
+                (result['songid'], result['plays'])
+            )
+
+        return most_played
+
+    def get_last_played(self, game: str, version: int, userid: UserID, count: int) -> List[Tuple[int, int]]:
+        """
+        Look up a user's last played songs.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userid - Integer representing a user. Usually looked up with UserData.
+            count - Number of scores to look up.
+
+        Returns:
+            A list of tuples, containing the songid and the last played time for this song.
+        """
+        sql = (
+            "SELECT DISTINCT(music.songid) AS songid, score_history.timestamp AS timestamp FROM score_history, music " +
+            "WHERE score_history.userid = :userid AND score_history.musicid = music.id " +
+            "AND music.game = :game AND music.version = :version " +
+            "ORDER BY timestamp DESC LIMIT :count"
+        )
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version, 'count': count})
+
+        last_played = []
+        for result in cursor.fetchall():
+            last_played.append(
+                (result['songid'], result['timestamp'])
+            )
+
+        return last_played
+
+    def get_hit_chart(
+        self,
+        game: str,
+        version: int,
+        count: int,
+        days: Optional[int]=None,
+    ) -> List[Tuple[int, int]]:
+        """
+        Look up a game's most played songs.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            count - Number of scores to look up.
+
+        Returns:
+            A list of tuples, containing the songid and the number of plays across all charts for that song.
+        """
+        sql = (
+            "SELECT music.songid AS songid, COUNT(score_history.timestamp) AS plays FROM score_history, music " +
+            "WHERE score_history.musicid = music.id AND music.game = :game AND music.version = :version "
+        )
+        if days is not None:
+            # Only select the last X days of hit chart
+            sql = sql + "AND score_history.timestamp > :timestamp "
+            timestamp = Time.now() - (Time.SECONDS_IN_DAY * days)
+        else:
+            timestamp = None
+
+        sql = sql + "GROUP BY songid ORDER BY plays DESC LIMIT :count"
+        cursor = self.execute(sql, {'game': game, 'version': version, 'count': count, 'timestamp': timestamp})
+
+        most_played = []
+        for result in cursor.fetchall():
+            most_played.append(
+                (result['songid'], result['plays'])
+            )
+
+        return most_played
+
+    def get_song(
+        self,
+        game: str,
+        version: int,
+        songid: int,
+        songchart: int,
+    ) -> Optional[Song]:
+        """
+        Given a game/version/songid/chart, look up the name, artist and genre of that song.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            songid - Integer representing the ID (from the game) for this song.
+            songchart - Integer representing the chart for this song.
+
+        Returns:
+            A Song object representing the song details
+        """
+        sql = (
+            "SELECT music.name AS name, music.artist AS artist, music.genre AS genre, music.data AS data " +
+            "FROM music WHERE music.game = :game AND music.version = :version AND " +
+            "music.songid = :songid AND music.chart = :songchart"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'songid': songid, 'songchart': songchart})
+        if cursor.rowcount != 1:
+            # music doesn't exist
+            return None
+        result = cursor.fetchone()
+        return Song(
+            game,
+            version,
+            songid,
+            songchart,
+            result['name'],
+            result['artist'],
+            result['genre'],
+            self.deserialize(result['data']),
+        )
+
+    def get_all_songs(
+        self,
+        game: str,
+        version: Optional[int]=None,
+    ) -> List[Song]:
+        """
+        Given a game and a version, look up all song/chart combos associated with that game.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+
+        Returns:
+            A list of Song objects detailing the song information for each song.
+        """
+        sql = (
+            "SELECT version, songid, chart, name, artist, genre, data FROM music "
+            "WHERE music.game = :game"
+        )
+        params: Dict[str, Any] = {'game': game}
+        if version is not None:
+            sql += " AND music.version = :version"
+            params['version'] = version
+        else:
+            sql += " ORDER BY music.version DESC"
+        cursor = self.execute(sql, params)
+
+        all_songs = []
+        for result in cursor.fetchall():
+            all_songs.append(
+                Song(
+                    game,
+                    result['version'],
+                    result['songid'],
+                    result['chart'],
+                    result['name'],
+                    result['artist'],
+                    result['genre'],
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return all_songs
+
+    def get_all_versions_of_song(
+        self,
+        game: str,
+        version: int,
+        songid: int,
+        songchart: int,
+        interested_versions: Optional[List[int]] = None,
+    ) -> List[Song]:
+        """
+        Given a game/version/songid/chart, look up all versions of that song across all game versions.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            songid - Integer representing the ID (from the game) for this song.
+            songchart - Integer representing the chart for this song.
+
+        Returns:
+            A list of Song objects representing all song versions.
+        """
+        musicid = self.__get_musicid(game, version, songid, songchart)
+        sql = (
+            "SELECT version, songid, chart, name, artist, genre, data FROM music "
+            "WHERE music.id = :musicid"
+        )
+        if interested_versions is not None:
+            sql += " AND music.version in ({})".format(",".join(str(int(v)) for v in interested_versions))
+        cursor = self.execute(sql, {'musicid': musicid})
+        all_songs = []
+        for result in cursor.fetchall():
+            all_songs.append(
+                Song(
+                    game,
+                    result['version'],
+                    result['songid'],
+                    result['chart'],
+                    result['name'],
+                    result['artist'],
+                    result['genre'],
+                    self.deserialize(result['data']),
+                )
+            )
+        return all_songs
+
+    def get_all_scores(
+        self,
+        game: str,
+        version: Optional[int]=None,
+        userid: Optional[UserID]=None,
+        songid: Optional[int]=None,
+        songchart: Optional[int]=None,
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Tuple[UserID, Score]]:
+        """
+        Look up all of a game's high scores for all users.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+
+        Returns:
+            A list of UserID, Score objects representing all high scores for a game.
+        """
+        # First, construct the queries for grabbing the songid/chart
+        if version is not None:
+            songidquery = (
+                'SELECT songid FROM music WHERE music.id = score.musicid AND game = :game AND version = :version'
+            )
+            chartquery = (
+                'SELECT chart FROM music WHERE music.id = score.musicid AND game = :game AND version = :version'
+            )
+        else:
+            songidquery = (
+                'SELECT songid FROM music WHERE music.id = score.musicid AND game = :game ORDER BY version DESC LIMIT 1'
+            )
+            chartquery = (
+                'SELECT chart FROM music WHERE music.id = score.musicid AND game = :game ORDER BY version DESC LIMIT 1'
+            )
+
+        # Select statement for getting play count
+        playselect = (
+            'SELECT COUNT(timestamp) FROM score_history WHERE score_history.musicid = score.musicid AND score_history.userid = score.userid'
+        )
+
+        # Now, construct the inner select statement so we can choose which scores we care about
+        innerselect = (
+            'SELECT DISTINCT(id) FROM music WHERE game = :game'
+        )
+        if version is not None:
+            innerselect = innerselect + ' AND version = :version'
+        if songid is not None:
+            innerselect = innerselect + ' AND songid = :songid'
+        if songchart is not None:
+            innerselect = innerselect + ' AND chart = :songchart'
+
+        # Finally, construct the full query
+        sql = (
+            "SELECT ({}) AS songid, ({}) AS chart, id AS scorekey, points, timestamp, `update`, lid, data, userid, ({}) AS plays "
+            "FROM score WHERE musicid IN ({})"
+        ).format(songidquery, chartquery, playselect, innerselect)
+
+        # Now, limit the query
+        if userid is not None:
+            sql = sql + ' AND userid = :userid'
+        if since is not None:
+            sql = sql + ' AND score.update >= :since'
+        if until is not None:
+            sql = sql + ' AND score.update < :until'
+
+        # Now, query itself
+        cursor = self.execute(sql, {
+            'game': game,
+            'version': version,
+            'userid': userid,
+            'songid': songid,
+            'songchart': songchart,
+            'since': since,
+            'until': until,
+        })
+
+        # Objectify result
+        scores = []
+        for result in cursor.fetchall():
+            scores.append(
+                (
+                    UserID(result['userid']),
+                    Score(
+                        result['scorekey'],
+                        result['songid'],
+                        result['chart'],
+                        result['points'],
+                        result['timestamp'],
+                        result['update'],
+                        result['lid'],
+                        result['plays'],
+                        self.deserialize(result['data']),
+                    )
+                )
+            )
+
+        return scores
+
+    def get_all_records(
+        self,
+        game: str,
+        version: Optional[int]=None,
+        userlist: Optional[List[UserID]]=None,
+        locationlist: Optional[List[int]]=None,
+    ) -> List[Tuple[UserID, Score]]:
+        """
+        Look up all of a game's records, only returning the top score for each song. For score ties,
+        king-of-the-hill rules are in effect, so for two players with an identical top score, the player
+        that got the score last wins. If a list of user IDs is given, we will only look up records pertaining
+        to those users. So if another user has a higher record, we will ignore this. This can be used to
+        display area-local high scores, etc.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            userlist - List of UserIDs to limit the search to.
+            locationlist - A list of location IDs to limit searches to.
+
+        Returns:
+            A list of UserID, Score objects representing all high scores for a game.
+        """
+        # First, construct the queries for grabbing the songid/chart
+        if version is not None:
+            songidquery = (
+                'SELECT songid FROM music WHERE music.id = score.musicid AND game = :game AND version = :version'
+            )
+            chartquery = (
+                'SELECT chart FROM music WHERE music.id = score.musicid AND game = :game AND version = :version'
+            )
+        else:
+            songidquery = (
+                'SELECT songid FROM music WHERE music.id = score.musicid AND game = :game ORDER BY version DESC LIMIT 1'
+            )
+            chartquery = (
+                'SELECT chart FROM music WHERE music.id = score.musicid AND game = :game ORDER BY version DESC LIMIT 1'
+            )
+
+        # Next, get a list of all songs that were played given the input criteria
+        musicid_sql = (
+            "SELECT DISTINCT(score.musicid) FROM score, music WHERE score.musicid = music.id AND music.game = :game"
+        )
+        params: Dict[str, Any] = {'game': game}
+        if version is not None:
+            musicid_sql = musicid_sql + ' AND music.version = :version'
+            params['version'] = version
+
+        # Figure out where the record was earned
+        if locationlist is not None:
+            if len(locationlist) == 0:
+                # We don't have any locations, but SQL will shit the bed, so lets add a default one.
+                locationlist.append(-1)
+            location_sql = "AND score.lid IN :locationlist"
+            params['locationlist'] = tuple(locationlist)
+        else:
+            location_sql = ""
+
+        # Figure out who got the record
+        if userlist is not None:
+            if len(userlist) == 0:
+                # We don't have any users, but SQL will shit the bed, so lets add a fake one.
+                userlist.append(UserID(-1))
+            user_sql = (
+                "SELECT userid FROM score WHERE score.musicid = played.musicid AND score.userid IN :userlist {} ORDER BY points DESC, timestamp DESC LIMIT 1"
+            ).format(location_sql)
+            params['userlist'] = tuple(userlist)
+        else:
+            user_sql = (
+                "SELECT userid FROM score WHERE score.musicid = played.musicid {} ORDER BY points DESC, timestamp DESC LIMIT 1"
+            ).format(location_sql)
+        records_sql = (
+            "SELECT ({}) AS userid, musicid FROM ({}) played"
+        ).format(user_sql, musicid_sql)
+
+        # Now, join it up against the score and music table to grab the info we need
+        sql = (
+            "SELECT ({}) AS songid, ({}) AS chart, score.points AS points, score.userid AS userid, score.id AS scorekey, score.data AS data, " +
+            "score.timestamp AS timestamp, score.update AS `update`, " +
+            "score.lid AS lid, (select COUNT(score_history.timestamp) FROM score_history WHERE score_history.musicid = score.musicid) AS plays " +
+            "FROM score, ({}) records WHERE records.userid = score.userid AND records.musicid = score.musicid"
+        ).format(songidquery, chartquery, records_sql)
+        cursor = self.execute(sql, params)
+
+        scores = []
+        for result in cursor.fetchall():
+            scores.append(
+                (
+                    UserID(result['userid']),
+                    Score(
+                        result['scorekey'],
+                        result['songid'],
+                        result['chart'],
+                        result['points'],
+                        result['timestamp'],
+                        result['update'],
+                        result['lid'],
+                        result['plays'],
+                        self.deserialize(result['data']),
+                    )
+                )
+            )
+
+        return scores
+
+    def get_attempt_by_key(self, game: str, version: int, key: int) -> Optional[Tuple[UserID, Attempt]]:
+        """
+        Look up a previous attempt by key.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+            key - Integer representing a unique key fetched in a previous Attempt lookup.
+
+        Returns:
+            The optional data stored by the game previously, or None if no score exists.
+        """
+        sql = (
+            "SELECT music.songid AS songid, music.chart AS chart, score_history.id AS scorekey, score_history.timestamp AS timestamp, score_history.userid AS userid, " +
+            "score_history.lid AS lid, score_history.new_record AS new_record, score_history.points AS points, score_history.data AS data FROM score_history, music " +
+            "WHERE score_history.id = :scorekey AND score_history.musicid = music.id AND music.game = :game AND music.version = :version"
+        )
+        cursor = self.execute(
+            sql,
+            {
+                'game': game,
+                'version': version,
+                'scorekey': key,
+            },
+        )
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return (
+            UserID(result['userid']),
+            Attempt(
+                result['scorekey'],
+                result['songid'],
+                result['chart'],
+                result['points'],
+                result['timestamp'],
+                result['lid'],
+                True if result['new_record'] == 1 else False,
+                self.deserialize(result['data']),
+            )
+        )
+
+    def get_all_attempts(
+        self,
+        game: str,
+        version: Optional[int]=None,
+        userid: Optional[UserID]=None,
+        songid: Optional[int]=None,
+        songchart: Optional[int]=None,
+        timelimit: Optional[int]=None,
+        limit: Optional[int]=None,
+        offset: Optional[int]=None,
+    ) -> List[Tuple[Optional[UserID], Attempt]]:
+        """
+        Look up all of the attempts to score for a particular game.
+
+        Parameters:
+            game - String representing a game series.
+            version - Integer representing which version of the game.
+
+        Returns:
+            A list of UserID, Attempt objects representing all score attempts for a game, sorted newest to oldest attempts.
+        """
+        # First, construct the queries for grabbing the songid/chart
+        if version is not None:
+            songidquery = (
+                'SELECT songid FROM music WHERE music.id = score_history.musicid AND game = :game AND version = :version'
+            )
+            chartquery = (
+                'SELECT chart FROM music WHERE music.id = score_history.musicid AND game = :game AND version = :version'
+            )
+        else:
+            songidquery = (
+                'SELECT songid FROM music WHERE music.id = score_history.musicid AND game = :game ORDER BY version DESC LIMIT 1'
+            )
+            chartquery = (
+                'SELECT chart FROM music WHERE music.id = score_history.musicid AND game = :game ORDER BY version DESC LIMIT 1'
+            )
+
+        # Now, construct the inner select statement so we can choose which scores we care about
+        innerselect = (
+            'SELECT DISTINCT(id) FROM music WHERE game = :game'
+        )
+        if version is not None:
+            innerselect = innerselect + ' AND version = :version'
+        if songid is not None:
+            innerselect = innerselect + ' AND songid = :songid'
+        if songchart is not None:
+            innerselect = innerselect + ' AND chart = :songchart'
+
+        # Finally, construct the full query
+        sql = (
+            "SELECT ({}) AS songid, ({}) AS chart, id AS scorekey, timestamp, points, new_record, lid, data, userid "
+            "FROM score_history WHERE musicid IN ({})"
+        ).format(songidquery, chartquery, innerselect)
+
+        # Now, limit the query
+        if userid is not None:
+            sql = sql + ' AND userid = :userid'
+        if timelimit is not None:
+            sql = sql + ' AND timestamp >= :timestamp'
+        sql = sql + ' ORDER BY timestamp DESC'
+        if limit is not None:
+            sql = sql + ' LIMIT :limit'
+        if offset is not None:
+            sql = sql + ' OFFSET :offset'
+
+        # Now, query itself
+        cursor = self.execute(sql, {
+            'game': game,
+            'version': version,
+            'userid': userid,
+            'songid': songid,
+            'songchart': songchart,
+            'timestamp': timelimit,
+            'limit': limit,
+            'offset': offset,
+        })
+
+        # Now objectify the attempts
+        attempts = []
+        for result in cursor.fetchall():
+            attempts.append(
+                (
+                    UserID(result['userid']) if result['userid'] > 0 else None,
+                    Attempt(
+                        result['scorekey'],
+                        result['songid'],
+                        result['chart'],
+                        result['points'],
+                        result['timestamp'],
+                        result['lid'],
+                        True if result['new_record'] == 1 else False,
+                        self.deserialize(result['data']),
+                    )
+                )
+            )
+
+        return attempts
diff --git a/bemani/data/mysql/network.py b/bemani/data/mysql/network.py
new file mode 100644
index 0000000..3bccaca
--- /dev/null
+++ b/bemani/data/mysql/network.py
@@ -0,0 +1,300 @@
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.types import String, Integer, Text, JSON  # type: ignore
+from sqlalchemy.dialects.mysql import BIGINT as BigInteger  # type: ignore
+from typing import Optional, Dict, List, Tuple, Any
+
+from bemani.common import Time
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.types import News, Event, UserID, ArcadeID
+
+"""
+Table for storing network news, as edited by an admin. This is displayed
+on the front page of the frontend of the network.
+"""
+news = Table(  # type: ignore
+    'news',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('title', String(255), nullable=False),
+    Column('body', Text, nullable=False),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing scheduled work history, so that individual game code
+can determine if it should run scheduled work or not.
+"""
+scheduled_work = Table(  # type: ignore
+    'scheduled_work',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('name', String(32), nullable=False),
+    Column('schedule', String(32), nullable=False),
+    Column('year', Integer),
+    Column('day', Integer),
+    UniqueConstraint('game', 'version', 'name', 'schedule', name='game_version_name_schedule'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing audit entries, such as crashes, PCBID denials, daily
+song selection, etc. Anything that could be inspected later to verify
+correct operation of the network.
+"""
+audit = Table(  # type: ignore
+    'audit',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('userid', BigInteger(unsigned=True), index=True),
+    Column('arcadeid', Integer, index=True),
+    Column('type', String(64), nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    mysql_charset='utf8mb4',
+)
+
+
+class NetworkData(BaseData):
+
+    def get_all_news(self) -> List[News]:
+        """
+        Grab all news in the system.
+
+        Returns:
+            A list of News objects sorted by timestamp.
+        """
+        sql = "SELECT id, timestamp, title, body FROM news ORDER BY timestamp DESC"
+        cursor = self.execute(sql)
+        return [
+            News(
+                result['id'],
+                result['timestamp'],
+                result['title'],
+                result['body'],
+            ) for result in cursor.fetchall()
+        ]
+
+    def create_news(self, title: str, body: str) -> int:
+        """
+        Given a title and body, create a new news entry.
+
+        Parameters:
+            title - String title of the entry.
+            body - String body of the entry, may contain HTML.
+
+        Returns:
+            The ID of the newly created entry.
+        """
+        sql = "INSERT INTO news (timestamp, title, body) VALUES (:timestamp, :title, :body)"
+        cursor = self.execute(sql, {'timestamp': int(Time.now()), 'title': title, 'body': body})
+        return cursor.lastrowid
+
+    def get_news(self, newsid: int) -> Optional[News]:
+        """
+        Given a news ID, grab that news entry from the DB.
+
+        Parameters:
+            newsid - Integer specifying news ID.
+
+        Returns:
+            A News object if the news entry was found or None otherwise.
+        """
+        sql = "SELECT timestamp, title, body FROM news WHERE id = :id"
+        cursor = self.execute(sql, {'id': newsid})
+        if cursor.rowcount != 1:
+            # Couldn't find an entry with this ID
+            return None
+
+        result = cursor.fetchone()
+        return News(
+            newsid,
+            result['timestamp'],
+            result['title'],
+            result['body'],
+        )
+
+    def put_news(self, news: News) -> None:
+        """
+        Given a news object, store it back into the DB.
+
+        Parameters:
+            news - A News object to be updated.
+        """
+        sql = "UPDATE news SET title = :title, body = :body WHERE id = :id"
+        self.execute(sql, {'id': news.id, 'title': news.title, 'body': news.body})
+
+    def destroy_news(self, newsid: int) -> None:
+        """
+        Given a news ID, remove that news entry from the DB.
+
+        Parameters:
+            newsid - Integer specifying news ID.
+        """
+        sql = "DELETE FROM news WHERE id = :id LIMIT 1"
+        self.execute(sql, {'id': newsid})
+
+    def get_schedule_duration(self, schedule: str) -> Tuple[int, int]:
+        """
+        Given a schedule type, returns the timestamp for the start and end
+        of the current schedule of this type.
+        """
+        if schedule not in ['daily', 'weekly']:
+            raise Exception('Logic error, specify either \'daily\' or \'weekly\' for schedule type!')
+
+        if schedule == 'daily':
+            return (Time.beginning_of_today(), Time.end_of_today())
+
+        if schedule == 'weekly':
+            return (Time.beginning_of_this_week(), Time.end_of_this_week())
+
+        # Should never happen
+        return (0, 0)
+
+    def should_schedule(self, game: str, version: int, name: str, schedule: str) -> bool:
+        """
+        Given a game/version/name pair and a schedule value, return whether
+        this scheduled work is overdue or not.
+        """
+        if schedule not in ['daily', 'weekly']:
+            raise Exception('Logic error, specify either \'daily\' or \'weekly\' for schedule type!')
+
+        sql = (
+            "SELECT year, day FROM scheduled_work "
+            "WHERE game = :game AND version = :version AND "
+            "name = :name AND schedule = :schedule"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'name': name, 'schedule': schedule})
+        if cursor.rowcount != 1:
+            # No scheduled work was registered, so time to get going!
+            return True
+
+        result = cursor.fetchone()
+
+        if schedule == 'daily':
+            # Just look at the day and year, make sure it matches
+            year, day = Time.days_into_year()
+            if year != result['year']:
+                # Wrong year, so we certainly need to run!
+                return True
+            if day != result['day']:
+                # Wrong day and we're daily, so need to run!
+                return True
+
+        if schedule == 'weekly':
+            # Find the beginning of the week (Monday), as days since epoch.
+            if Time.week_in_days_since_epoch() != result['day']:
+                # Wrong week, so we should run!
+                return True
+
+        # We have already run this work for this schedule
+        return False
+
+    def mark_scheduled(self, game: str, version: int, name: str, schedule: str) -> None:
+        if schedule not in ['daily', 'weekly']:
+            raise Exception('Logic error, specify either \'daily\' or \'weekly\' for schedule type!')
+
+        if schedule == 'daily':
+            year, day = Time.days_into_year()
+            sql = (
+                "INSERT INTO scheduled_work (game, version, name, schedule, year, day) " +
+                "VALUES (:game, :version, :name, :schedule, :year, :day) " +
+                "ON DUPLICATE KEY UPDATE year=VALUES(year), day=VALUES(day)"
+            )
+            self.execute(
+                sql,
+                {
+                    'game': game,
+                    'version': version,
+                    'name': name,
+                    'schedule': schedule,
+                    'year': year,
+                    'day': day,
+                },
+            )
+
+        if schedule == 'weekly':
+            days = Time.week_in_days_since_epoch()
+            sql = (
+                "INSERT INTO scheduled_work (game, version, name, schedule, day) " +
+                "VALUES (:game, :version, :name, :schedule, :day) " +
+                "ON DUPLICATE KEY UPDATE day=VALUES(day)"
+            )
+            self.execute(
+                sql,
+                {
+                    'game': game,
+                    'version': version,
+                    'name': name,
+                    'schedule': schedule,
+                    'day': days,
+                },
+            )
+
+    def put_event(
+        self,
+        event: str,
+        data: Dict[str, Any],
+        timestamp: Optional[int]=None,
+        userid: Optional[UserID]=None,
+        arcadeid: Optional[ArcadeID]=None,
+    ) -> None:
+        if timestamp is None:
+            timestamp = Time.now()
+        sql = "INSERT INTO audit (timestamp, userid, arcadeid, type, data) VALUES (:ts, :uid, :aid, :type, :data)"
+        self.execute(sql, {'ts': timestamp, 'type': event, 'data': self.serialize(data), 'uid': userid, 'aid': arcadeid})
+
+    def get_events(
+        self,
+        userid: Optional[UserID]=None,
+        arcadeid: Optional[ArcadeID]=None,
+        event: Optional[str]=None,
+        limit: Optional[int]=None,
+        since_id: Optional[int]=None,
+        until_id: Optional[int]=None,
+    ) -> List[Event]:
+        # Base query
+        sql = "SELECT id, timestamp, userid, arcadeid, type, data FROM audit "
+
+        # Lets get specific!
+        wheres = []
+        if userid is not None:
+            wheres.append("userid = :userid")
+        if arcadeid is not None:
+            wheres.append("arcadeid = :arcadeid")
+        if event is not None:
+            wheres.append("type = :event")
+        if since_id is not None:
+            wheres.append("id >= :since_id")
+        if until_id is not None:
+            wheres.append("id < :until_id")
+        if len(wheres) > 0:
+            sql = sql + "WHERE {} ".format(' AND '.join(wheres))
+
+        # Order it newest to oldest
+        sql = sql + "ORDER BY id DESC"
+        if limit is not None:
+            sql = sql + " LIMIT :limit"
+        cursor = self.execute(sql, {'userid': userid, 'arcadeid': arcadeid, 'event': event, 'limit': limit, 'since_id': since_id, 'until_id': until_id})
+        events = []
+        for result in cursor.fetchall():
+            if result['userid'] is not None:
+                userid = UserID(result['userid'])
+            else:
+                userid = None
+            if result['arcadeid'] is not None:
+                arcadeid = ArcadeID(result['arcadeid'])
+            else:
+                arcadeid = None
+            events.append(
+                Event(
+                    result['id'],
+                    result['timestamp'],
+                    userid,
+                    arcadeid,
+                    result['type'],
+                    self.deserialize(result['data']),
+                ),
+            )
+        return events
diff --git a/bemani/data/mysql/user.py b/bemani/data/mysql/user.py
new file mode 100644
index 0000000..e4578ed
--- /dev/null
+++ b/bemani/data/mysql/user.py
@@ -0,0 +1,1226 @@
+import copy
+import random
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.types import String, Integer, JSON  # type: ignore
+from sqlalchemy.dialects.mysql import BIGINT as BigInteger  # type: ignore
+from sqlalchemy.exc import IntegrityError  # type: ignore
+from typing import Optional, Dict, List, Tuple, Any
+from passlib.hash import pbkdf2_sha512  # type: ignore
+
+from bemani.common import ValidatedDict, Time
+from bemani.data.mysql.base import BaseData, metadata
+from bemani.data.remoteuser import RemoteUser
+from bemani.data.types import User, Achievement, Link, UserID, ArcadeID
+
+"""
+Table representing a user. Each user has a unique ID and a pin which
+is used with all cards associated with the user's account. Username
+and password are optional as a user does not need to create a web login
+to use the network. However, an active user account is required
+before creating a web login.
+"""
+user = Table(  # type: ignore
+    'user',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('pin', String(4), nullable=False),
+    Column('username', String(255), unique=True),
+    Column('password', String(255)),
+    Column('email', String(255)),
+    Column('admin', Integer),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table representing a card associated with a user. Users may have zero
+or more cards associated with them. When a new card is used in a game
+a new user will be created to associate with a card, but it can later
+be unlinked.
+"""
+card = Table(  # type: ignore
+    'card',
+    metadata,
+    Column('id', String(16), nullable=False, unique=True),
+    Column('userid', BigInteger(unsigned=True), nullable=False, index=True),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table representing an extid for a user across a game series. Each game
+series on the network gets its own extid (8 digit number) for each user.
+"""
+extid = Table(  # type: ignore
+    'extid',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('extid', Integer, nullable=False, unique=True),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    UniqueConstraint('game', 'userid', name='game_userid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table representing a refid for a user. Each unique game on the network will
+need a refid for each user/game/version they have a profile for. If a user
+does not have a profile for a particular game, a new and unique refid
+will be generated for the user.
+
+Note that a user might have an extid/refid for a game without a profile,
+but a user cannot have a profile without an extid/refid.
+"""
+refid = Table(  # type: ignore
+    'refid',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('refid', String(16), nullable=False, unique=True),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing JSON profile blobs, indexed by refid.
+"""
+profile = Table(  # type: ignore
+    'profile',
+    metadata,
+    Column('refid', String(16), nullable=False, unique=True),
+    Column('data', JSON, nullable=False),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing game achievements. An achievement is just a blob of data
+with a unique ID and type. Games are free to store a JSON blob for each
+achievement. Examples would be tran medals, event unlocks, items earned,
+etc.
+"""
+achievement = Table(  # type: ignore
+    'achievement',
+    metadata,
+    Column('refid', String(16), nullable=False),
+    Column('id', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('refid', 'id', 'type', name='refid_id_type'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing time-based achievements. A time-based achievement is
+almost identical to a regular achievement, but you can earn multiple of
+the same type of achievement at different times, and it matters when
+you earn it. Games are free to store a JSON blob for each achievement and
+the blob does not need to be equal across different instances of the same
+achievement for the same user. Examples would be calorie earnings for DDR.
+"""
+time_based_achievement = Table(  # type: ignore
+    'time_based_achievement',
+    metadata,
+    Column('refid', String(16), nullable=False),
+    Column('id', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('refid', 'id', 'type', 'timestamp', name='refid_id_type_timestamp'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing a user's PASELI balance, given an arcade. There is no global
+balance on this network.
+"""
+balance = Table(  # type: ignore
+    'balance',
+    metadata,
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('arcadeid', Integer, nullable=False),
+    Column('balance', Integer, nullable=False),
+    UniqueConstraint('userid', 'arcadeid', name='userid_arcadeid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing links between two users in a game/version, whatever that
+may be. Typically used for rivals.
+etc.
+"""
+link = Table(  # type: ignore
+    'link',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('userid', BigInteger(unsigned=True), nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('other_userid', BigInteger(unsigned=True), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'version', 'userid', 'type', 'other_userid', name='game_version_userid_type_other_uuserid'),
+    mysql_charset='utf8mb4',
+)
+
+
+class AccountCreationException(Exception):
+    pass
+
+
+class UserData(BaseData):
+
+    REF_ID_LENGTH = 16
+
+    def from_cardid(self, cardid: str) -> Optional[UserID]:
+        """
+        Given a 16 digit card ID, look up a user ID.
+
+        Note that this is the E004 number as stored on the card. Not the 16 digit
+        ASCII value on the back. Use CardCipher to convert.
+
+        Parameters:
+            cardid - 16-digit card ID to look for.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        # First, look up the user account
+        sql = "SELECT userid FROM card WHERE id = :id"
+        cursor = self.execute(sql, {'id': cardid})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this card
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['userid'])
+
+    def from_username(self, username: str) -> Optional[UserID]:
+        """
+        Given a username, look up a user ID.
+
+        Parameters:
+            username - A string representing the user's username.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        sql = "SELECT id FROM user WHERE username = :username"
+        cursor = self.execute(sql, {'username': username})
+        if cursor.rowcount != 1:
+            # Couldn't find this username
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['id'])
+
+    def from_refid(self, game: str, version: int, refid: str) -> Optional[UserID]:
+        """
+        Given a generated RefID, look up a user ID.
+
+        Note that there is a unique RefID and ExtID for each profile, and both can be used
+        to look up a user. When creating a new profile, we generate a unique RefID and ExtID.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            refid - RefID in question, most likely previously generated by this class.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        # First, look up the user account
+        sql = "SELECT userid FROM refid WHERE game = :game AND version = :version AND refid = :refid"
+        cursor = self.execute(sql, {'game': game, 'version': version, 'refid': refid})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this refid
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['userid'])
+
+    def from_extid(self, game: str, version: int, extid: int) -> Optional[UserID]:
+        """
+        Given a generated ExtID, look up a user ID.
+
+        Note that there is a unique RefID and ExtID for each profile, and both can be used
+        to look up a user. When creating a new profile, we generate a unique RefID and ExtID.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            extid - ExtID in question, most likely previously generated by this class.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        # First, look up the user account
+        sql = "SELECT userid FROM extid WHERE game = :game AND extid = :extid"
+        cursor = self.execute(sql, {'game': game, 'extid': extid})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this refid
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['userid'])
+
+    def from_session(self, session: str) -> Optional[UserID]:
+        """
+        Given a previously-opened session, look up a user ID.
+
+        Parameters:
+            session - String identifying a session that was opened by create_session.
+
+        Returns:
+            User ID as an integer if found, or None if the session is expired or doesn't exist.
+        """
+        userid = self._from_session(session, 'userid')
+        if userid is None:
+            return None
+        return UserID(userid)
+
+    def get_user(self, userid: UserID) -> Optional[User]:
+        """
+        Given a userid, look up details about the account.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A User object if found, or None otherwise.
+        """
+        sql = "SELECT username, email, admin FROM user WHERE id = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        if cursor.rowcount != 1:
+            # User doesn't exist, but we have a reference?
+            return None
+
+        result = cursor.fetchone()
+        return User(userid, result['username'], result['email'], result['admin'] == 1)
+
+    def get_all_users(self) -> List[User]:
+        """
+        Look up all users in the system.
+
+        Returns:
+            A list of User objects representing all users.
+        """
+        sql = "SELECT id, username, email, admin FROM user"
+        cursor = self.execute(sql)
+        return [
+            User(UserID(result['id']), result['username'], result['email'], result['admin'] == 1)
+            for result in cursor.fetchall()
+        ]
+
+    def get_all_usernames(self) -> List[str]:
+        """
+        Look up all valid usernames in the system.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of strings representing usernames.
+        """
+        sql = "SELECT username FROM user WHERE username is not null"
+        cursor = self.execute(sql)
+        return [res['username'] for res in cursor.fetchall()]
+
+    def get_all_cards(self) -> List[Tuple[str, UserID]]:
+        """
+        Look up all cards associated with any account.
+
+        Returns:
+            A list of Tuples representing representing card ID, user ID pairs.
+        """
+        sql = "SELECT id, userid FROM card"
+        cursor = self.execute(sql)
+        return [(str(res['id']).upper(), UserID(res['userid'])) for res in cursor.fetchall()]
+
+    def get_cards(self, userid: UserID) -> List[str]:
+        """
+        Given a userid, look up all cards associated with the account.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of strings representing card IDs.
+        """
+        sql = "SELECT id FROM card WHERE userid = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        return [str(res['id']).upper() for res in cursor.fetchall()]
+
+    def add_card(self, userid: UserID, cardid: str) -> None:
+        """
+        Given a user ID and a card ID, link that card with that user.
+
+        Note that this is the E004 number as stored on the card. Not the 16 digit
+        ASCII value on the back. Use CardCipher to convert.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            cardid - 16-digit card ID to add.
+        """
+        sql = "INSERT INTO card (userid, id) VALUES (:userid, :cardid)"
+        self.execute(sql, {'userid': userid, 'cardid': cardid})
+
+        oldid = RemoteUser.card_to_userid(cardid)
+        if RemoteUser.is_remote(oldid):
+            # Kill any refid/extid that related to this card, since its now associated
+            # with another existing account.
+            sql = "DELETE FROM extid WHERE userid = :oldid"
+            self.execute(sql, {'oldid': oldid})
+            sql = "DELETE FROM refid WHERE userid = :oldid"
+            self.execute(sql, {'oldid': oldid})
+
+            # Point at the new account for any rivals against this card. Note that this
+            # might result in a duplicate rival, but its a very small edge case.
+            sql = "UPDATE link SET other_userid = :newid WHERE other_userid = :oldid"
+            self.execute(sql, {'newid': userid, 'oldid': oldid})
+
+    def destroy_card(self, userid: UserID, cardid: str) -> None:
+        """
+        Given a user ID and a card ID, remove the card ID link from that user.
+
+        Note that this is the E004 number as stored on the card. Not the 16 digit
+        ASCII value on the back. Use CardCipher to convert.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            cardid - 16-digit card ID to remove.
+        """
+        sql = "DELETE FROM card WHERE id = :cardid AND userid = :userid LIMIT 1"
+        self.execute(sql, {'cardid': cardid, 'userid': userid})
+
+    def put_user(self, user: User) -> None:
+        """
+        Given a user object, update the DB to save new user info.
+
+        Parameters:
+            user - A user, which has optional values set.
+        """
+        sql = "UPDATE user SET username = :username, email = :email, admin = :admin WHERE id = :userid"
+        self.execute(
+            sql,
+            {
+                'username': user.username,
+                'email': user.email,
+                'admin': 1 if user.admin else 0,
+                'userid': user.id,
+            },
+        )
+
+    def validate_pin(self, userid: UserID, pin: str) -> bool:
+        """
+        Given a userid and PIN, validate the PIN.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            pin - 4 digit string returned by the game for PIN entry.
+
+        Returns:
+            True if PIN is valid, False otherwise.
+        """
+        sql = "SELECT pin FROM user WHERE id = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        if cursor.rowcount != 1:
+            # User doesn't exist, but we have a reference?
+            return False
+
+        result = cursor.fetchone()
+        return pin == result['pin']
+
+    def update_pin(self, userid: UserID, pin: str) -> None:
+        """
+        Given a userid and a new PIN, update the PIN for that user.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            pin - 4 digit string returned by the game for PIN entry.
+        """
+        sql = "UPDATE user SET pin = :pin WHERE id = :userid"
+        self.execute(sql, {'pin': pin, 'userid': userid})
+
+    def validate_password(self, userid: UserID, password: str) -> bool:
+        """
+        Given a password, validate that the password matches the stored hash
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            password - String, plaintext password that will be hashed
+
+        Returns:
+            True if password is valid, False otherwise.
+        """
+        sql = "SELECT password FROM user WHERE id = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        if cursor.rowcount != 1:
+            # User doesn't exist, but we have a reference?
+            return False
+
+        result = cursor.fetchone()
+        passhash = result['password']
+
+        try:
+            # Verifying the password
+            return pbkdf2_sha512.verify(password, passhash)
+        except (ValueError, TypeError):
+            return False
+
+    def update_password(self, userid: UserID, password: str) -> None:
+        """
+        Given a userid and a new password, update the password for that user.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            password - String, plaintext password that will be hashed
+        """
+        passhash = pbkdf2_sha512.hash(password)
+        sql = "UPDATE user SET password = :hash WHERE id = :userid"
+        self.execute(sql, {'hash': passhash, 'userid': userid})
+
+    def get_profile(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid, look up the associated profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A dictionary previously stored by a game class if found, or None otherwise.
+        """
+        sql = (
+            "SELECT refid.refid AS refid, extid.extid AS extid " +
+            "FROM refid, extid " +
+            "WHERE refid.userid = :userid AND refid.game = :game AND refid.version = :version AND "
+            "extid.userid = refid.userid AND extid.game = refid.game"
+        )
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version})
+        if cursor.rowcount != 1:
+            # Profile doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        profile = {
+            'refid': result['refid'],
+            'extid': result['extid'],
+            'game': game,
+            'version': version,
+        }
+
+        sql = "SELECT data FROM profile WHERE refid = :refid"
+        cursor = self.execute(sql, {'refid': profile['refid']})
+        if cursor.rowcount != 1:
+            # Profile doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        profile.update(self.deserialize(result['data']))
+        return ValidatedDict(profile)
+
+    def get_any_profile(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid, look up the associated profile. If the profile for that version
+        doesn't exist, try another profile, failing only if there is no profile for any version of
+        this game.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A dictionary previously stored by a game class if found, or None otherwise.
+        """
+        played = self.get_games_played(userid)
+        versions = [p[1] for p in played if p[0] == game]
+        versions.sort(reverse=True)
+
+        if version in versions:
+            return self.get_profile(game, version, userid)
+        elif len(versions) > 0:
+            return self.get_profile(game, versions[0], userid)
+        else:
+            return None
+
+    def get_any_profiles(self, game: str, version: int, userids: List[UserID]) -> List[Tuple[UserID, Optional[ValidatedDict]]]:
+        """
+        Does the exact same thing as get_any_profile but across a list of users instead of one.
+        Provided purely as a convenience function.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userids - List of Integer user IDs, as looked up by one of the above functions.
+
+        Returns:
+            A List of tuples containing a userid and a dictionary previously stored by a game class if found,
+            or None otherwise.
+        """
+        return [
+            (userid, self.get_any_profile(game, version, userid))
+            for userid in userids
+        ]
+
+    def get_games_played(self, userid: UserID) -> List[Tuple[str, int]]:
+        """
+        Given a user ID, look up all game/version combos this user has played.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A List of Tuples of game, version for each game/version the user has played.
+        """
+        sql = "SELECT game, version FROM refid WHERE userid = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        profiles = []
+        for result in cursor.fetchall():
+            profiles.append((result['game'], result['version']))
+        return profiles
+
+    def get_all_profiles(self, game: str, version: int) -> List[Tuple[UserID, ValidatedDict]]:
+        """
+        Given a game/version, look up all user profiles for that game.
+
+        Parameters:
+            game - String identifier of the game we want all user profiles for.
+            version - Integer version of the game we want all user profiles for.
+
+        Returns:
+            A list of (UserID, dictionaries) previously stored by a game class for each profile.
+        """
+        sql = (
+            "SELECT refid.userid AS userid, refid.refid AS refid, extid.extid AS extid, profile.data AS data "
+            "FROM refid, profile, extid "
+            "WHERE refid.game = :game AND refid.version = :version "
+            "AND refid.refid = profile.refid AND extid.game = refid.game AND extid.userid = refid.userid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        profiles = []
+        for result in cursor.fetchall():
+            profile = {
+                'refid': result['refid'],
+                'extid': result['extid'],
+                'game': game,
+                'version': version,
+            }
+            profile.update(self.deserialize(result['data']))
+            profiles.append(
+                (
+                    UserID(result['userid']),
+                    ValidatedDict(profile),
+                )
+            )
+
+        return profiles
+
+    def get_all_players(self, game: str, version: int) -> List[UserID]:
+        """
+        Given a game/version, look up all user IDs that played this game/version.
+
+        Parameters:
+            game - String identifier of the game we want all user profiles for.
+            version - Integer version of the game we want all user profiles for.
+
+        Returns:
+            A list of UserIDs for users that played this version of this game.
+        """
+        sql = (
+            "SELECT refid.userid AS userid FROM refid "
+            "WHERE refid.game = :game AND refid.version = :version"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        return [UserID(result['userid']) for result in cursor.fetchall()]
+
+    def get_all_achievements(self, game: str, version: int) -> List[Tuple[UserID, Achievement]]:
+        """
+        Given a game/version, find all achievements for al players.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+
+        Returns:
+            A list of (UserID, Achievement) objects.
+        """
+        sql = (
+            "SELECT achievement.id AS id, achievement.type AS type, achievement.data AS data, "
+            "refid.userid AS userid FROM achievement, refid WHERE refid.game = :game AND "
+            "refid.version = :version AND refid.refid = achievement.refid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                (
+                    UserID(result['userid']),
+                    Achievement(
+                        result['id'],
+                        result['type'],
+                        None,
+                        self.deserialize(result['data']),
+                    ),
+                )
+            )
+
+        return achievements
+
+    def put_profile(self, game: str, version: int, userid: UserID, profile: Dict[str, Any]) -> None:
+        """
+        Given a game/version/userid, save an associated profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            profile - A dictionary that a game class will want to retrieve later.
+        """
+        refid = self.get_refid(game, version, userid)
+        profile = copy.deepcopy(profile)
+        if 'refid' in profile:
+            del profile['refid']
+        if 'extid' in profile:
+            del profile['extid']
+        if 'game' in profile:
+            del profile['game']
+        if 'version' in profile:
+            del profile['version']
+
+        # Add profile json to game profile
+        sql = (
+            "INSERT INTO profile (refid, data) " +
+            "VALUES (:refid, :json) " +
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'refid': refid, 'json': self.serialize(profile)})
+
+    def get_achievement(self, game: str, version: int, userid: UserID, achievementid: int, achievementtype: str) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid and achievement id/type, find that achievement.
+
+        Note that there can be more than one achievement with the same ID and game/version/userid
+        as long as each one is a different type. Essentially, achievementtype namespaces achievements.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        refid = self.get_refid(game, version, userid)
+        sql = (
+            "SELECT data FROM achievement WHERE refid = :refid AND id = :id AND type = :type"
+        )
+        cursor = self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype})
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def get_achievements(self, game: str, version: int, userid: UserID) -> List[Achievement]:
+        """
+        Given a game/version/userid, find all achievements
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of Achievement objects.
+        """
+        refid = self.get_refid(game, version, userid)
+        sql = "SELECT id, type, data FROM achievement WHERE refid = :refid"
+        cursor = self.execute(sql, {'refid': refid})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                Achievement(
+                    result['id'],
+                    result['type'],
+                    None,
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return achievements
+
+    def put_achievement(self, game: str, version: int, userid: UserID, achievementid: int, achievementtype: str, data: Dict[str, Any]) -> None:
+        """
+        Given a game/version/userid and achievement id/type, save an achievement.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        refid = self.get_refid(game, version, userid)
+
+        # Add achievement JSON to achievements
+        sql = (
+            "INSERT INTO achievement (refid, id, type, data) " +
+            "VALUES (:refid, :id, :type, :data) " +
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype, 'data': self.serialize(data)})
+
+    def destroy_achievement(self, game: str, version: int, userid: UserID, achievementid: int, achievementtype: str) -> None:
+        """
+        Given a game/version/userid and achievement id/type, delete an achievement.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+        """
+        refid = self.get_refid(game, version, userid)
+
+        # Nuke the achievement from the user
+        sql = (
+            "DELETE FROM achievement WHERE refid = :refid AND id = :id AND type = :type"
+        )
+        self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype})
+
+    def get_time_based_achievements(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        achievementtype: Optional[str]=None,
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Achievement]:
+        """
+        Given a game/version/userid, find all time-based achievements
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementtype - Optional string specifying to constrain to a type of achievement.
+            since - Return achievements since this time (inclusive).
+            until - Return achievements until this time (exclusive).
+
+        Returns:
+            A list of Achievement objects.
+        """
+        refid = self.get_refid(game, version, userid)
+        sql = "SELECT id, type, timestamp, data FROM time_based_achievement WHERE refid = :refid"
+        if achievementtype is not None:
+            sql += " AND type = :type"
+        if since is not None:
+            sql += " AND timestamp >= :since"
+        if until is not None:
+            sql += " AND timestamp < :until"
+        cursor = self.execute(sql, {'refid': refid, 'type': achievementtype, 'since': since, 'until': until})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                Achievement(
+                    result['id'],
+                    result['type'],
+                    result['timestamp'],
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return achievements
+
+    def put_time_based_achievement(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        achievementid: int,
+        achievementtype: str,
+        data: Dict[str, Any],
+    ) -> None:
+        """
+        Given a game/version/userid and achievement id/type, save a time-based achievement. Assumes that
+        time-based achievements are immutable once saved.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        refid = self.get_refid(game, version, userid)
+
+        # Add achievement JSON to achievements
+        sql = (
+            "INSERT INTO time_based_achievement (refid, id, type, timestamp, data) " +
+            "VALUES (:refid, :id, :type, :ts, :data)"
+        )
+        self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype, 'ts': Time.now(), 'data': self.serialize(data)})
+
+    def get_all_time_based_achievements(self, game: str, version: int) -> List[Tuple[UserID, Achievement]]:
+        """
+        Given a game/version, find all time-based achievements for all players.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+
+        Returns:
+            A list of (UserID, Achievement) objects.
+        """
+        sql = (
+            "SELECT time_based_achievement.id AS id, time_based_achievement.type AS type, "
+            "time_based_achievement.data AS data, time_based_achievement.timestamp AS timestamp, "
+            "refid.userid AS userid FROM time_based_achievement, refid WHERE refid.game = :game AND "
+            "refid.version = :version AND refid.refid = time_based_achievement.refid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                (
+                    UserID(result['userid']),
+                    Achievement(
+                        result['id'],
+                        result['type'],
+                        result['timestamp'],
+                        self.deserialize(result['data']),
+                    ),
+                )
+            )
+
+        return achievements
+
+    def get_link(self, game: str, version: int, userid: UserID, linktype: str, other_userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid and link type + other userid, find that link.
+
+        Note that there can be more than one link with the same user IDs and game/version
+        as long as each one is a different type.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            linktype - The type of link.
+            other_userid - Integer user ID of the account we're linked to.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        sql = (
+            "SELECT data FROM link WHERE game = :game AND version = :version AND userid = :userid AND type = :type AND other_userid = :other_userid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid})
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def get_links(self, game: str, version: int, userid: UserID) -> List[Link]:
+        """
+        Given a game/version/userid, find all links between this user and other users
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of Link objects.
+        """
+        sql = "SELECT type, other_userid, data FROM link WHERE game = :game AND version = :version AND userid = :userid"
+        cursor = self.execute(sql, {'game': game, 'version': version, 'userid': userid})
+
+        links = []
+        for result in cursor.fetchall():
+            links.append(
+                Link(
+                    userid,
+                    result['type'],
+                    UserID(result['other_userid']),
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return links
+
+    def put_link(self, game: str, version: int, userid: UserID, linktype: str, other_userid: UserID, data: Dict[str, Any]) -> None:
+        """
+        Given a game/version/userid and link id + other_userid, save an link.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            linktype - The type of link.
+            other_userid - Integer user ID of the account we're linked to.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        # Add link JSON to link
+        sql = (
+            "INSERT INTO link (game, version, userid, type, other_userid, data) "
+            "VALUES (:game, :version, :userid, :type, :other_userid, :data) "
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'game': game, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid, 'data': self.serialize(data)})
+
+    def destroy_link(self, game: str, version: int, userid: UserID, linktype: str, other_userid: UserID) -> None:
+        """
+        Given a game/version/userid and link id + other_userid, destroy the link.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            linktype - The type of link.
+            other_userid - Integer user ID of the account we're linked to.
+        """
+        sql = (
+            "DELETE FROM link WHERE game = :game AND version = :version AND userid = :userid AND type = :type AND other_userid = :other_userid"
+        )
+        self.execute(sql, {'game': game, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid})
+
+    def get_balance(self, userid: UserID, arcadeid: ArcadeID) -> int:
+        """
+        Given a user and an arcade ID, look up the user's PASELI balance for that arcade.
+
+        Parameters:
+            userid - The user ID in question, as looked up by this class.
+            arcadeid - The arcade in question.
+
+        Returns:
+            The PASELI balance for this user at this arcade.
+        """
+        sql = "SELECT balance FROM balance WHERE userid = :userid AND arcadeid = :arcadeid"
+        cursor = self.execute(sql, {'userid': userid, 'arcadeid': arcadeid})
+        if cursor.rowcount == 1:
+            result = cursor.fetchone()
+            return result['balance']
+        else:
+            return 0
+
+    def update_balance(self, userid: UserID, arcadeid: ArcadeID, delta: int) -> Optional[int]:
+        """
+        Given a user and an arcade ID, update the PASELI balance for that arcade.
+
+        Parameters:
+            userid - The user ID in question, as looked up by this class.
+            arcadeid - The arcade in question.
+            delta - The value to add (or subtract, if delta is negative).
+
+        Returns:
+            The new PASELI balance if successful, or None if there wasn't enough to apply the delta.
+        """
+        sql = (
+            "INSERT INTO balance (userid, arcadeid, balance) VALUES (:userid, :arcadeid, :delta) "
+            "ON DUPLICATE KEY UPDATE balance = balance + :delta"
+        )
+        self.execute(sql, {'delta': delta, 'userid': userid, 'arcadeid': arcadeid})
+        newbalance = self.get_balance(userid, arcadeid)
+        if newbalance < 0:
+            # Went under while grabbing, put the balance back and return nothing
+            sql = "UPDATE balance SET balance = balance - :delta WHERE userid = :userid AND arcadeid = :arcadeid"
+            self.execute(sql, {'delta': delta, 'userid': userid, 'arcadeid': arcadeid})
+            return None
+        return newbalance
+
+    def get_refid(self, game: str, version: int, userid: UserID) -> str:
+        """
+        Given a game/version and user ID, look up the RefID for the profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            The RefID associated with the profile for this user. If there isn't one, creates one
+            and returns it, which can be used for creating/looking up a profile in the future.
+        """
+        sql = "SELECT refid FROM refid WHERE userid = :userid AND game = :game AND version = :version"
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version})
+        if cursor.rowcount == 1:
+            result = cursor.fetchone()
+            return result['refid']
+        else:
+            return self.create_refid(game, version, userid)
+
+    def get_extid(self, game: str, version: int, userid: UserID) -> int:
+        """
+        Given a game/version and a user ID, look up the ExtID for the profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            The ExtID associated with the profile for this user. If there isn't one, creates
+            one in the same manner as get_refid() above.
+        """
+
+        def fetch_extid() -> Optional[int]:
+            sql = "SELECT extid FROM extid WHERE userid = :userid AND game = :game"
+            cursor = self.execute(sql, {'userid': userid, 'game': game})
+            if cursor.rowcount == 1:
+                result = cursor.fetchone()
+                return result['extid']
+            else:
+                return None
+
+        extid = fetch_extid()
+        if extid is not None:
+            return extid
+        else:
+            self.create_refid(game, version, userid)
+            extid = fetch_extid()
+            if extid is not None:
+                return extid
+            else:
+                raise AccountCreationException()
+
+    def create_session(self, userid: UserID, expiration: int=(30 * 86400)) -> str:
+        """
+        Given a user ID, create a session string.
+
+        Parameters:
+            userid - User ID we wish to start a session for.
+            expiration - Number of seconds before this session is invalid.
+
+        Returns:
+            A string that can be used as a session ID.
+        """
+        return self._create_session(userid, 'userid', expiration)
+
+    def destroy_session(self, session: str) -> None:
+        """
+        Destroy a previously-created session.
+
+        Parameters:
+            session - A session string as returned from create_session.
+        """
+        self._destroy_session(session, 'userid')
+
+    def create_refid(self, game: str, version: int, userid: UserID) -> str:
+        """
+        Given a game/version/userid, create a RefID and an ExtID if necessary.
+
+        Note that while this function returns the created RefID, an ExtID is also
+        created and stored in the DB. Both RefID and ExtID are guaranteed to be
+        unique, but the RefID is guaranteed unique for each profile while ExtID
+        is guaranteed unique for each game series/user.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A string RefID value.
+        """
+        # Create a new extid that is unique
+        while True:
+            extid = random.randint(0, 89999999) + 10000000
+            sql = "SELECT extid FROM extid WHERE extid = :extid"
+            cursor = self.execute(sql, {'extid': extid})
+            if cursor.rowcount == 0:
+                break
+
+        # Use that extid
+        sql = (
+            "INSERT INTO extid (game, extid, userid) " +
+            "VALUES (:game, :extid, :userid)"
+        )
+        try:
+            cursor = self.execute(sql, {'game': game, 'extid': extid, 'userid': userid})
+        except IntegrityError:
+            # User already has an ExtID for this game series
+            pass
+
+        # Create a new refid that is unique
+        while True:
+            refid = ''.join(random.choice('0123456789ABCDEF') for _ in range(UserData.REF_ID_LENGTH))
+            sql = "SELECT refid FROM refid WHERE refid = :refid"
+            cursor = self.execute(sql, {'refid': refid})
+            if cursor.rowcount == 0:
+                break
+
+        # Use that refid
+        sql = (
+            "INSERT INTO refid (game, version, refid, userid) " +
+            "VALUES (:game, :version, :refid, :userid)"
+        )
+        try:
+            cursor = self.execute(sql, {'game': game, 'version': version, 'refid': refid, 'userid': userid})
+            if cursor.rowcount != 1:
+                raise AccountCreationException()
+            return refid
+        except IntegrityError:
+            # We maybe lost the race? Look up the ID from another creation. Don't call get_refid
+            # because it calls us, so we don't want an infinite loop.
+            sql = "SELECT refid FROM refid WHERE userid = :userid AND game = :game AND version = :version"
+            cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version})
+            if cursor.rowcount == 1:
+                result = cursor.fetchone()
+                return result['refid']
+            # Shouldn't be possible, but here we are
+            raise AccountCreationException()
+
+    def create_account(self, cardid: str, pin: str) -> Optional[UserID]:
+        """
+        Given a Card ID and a PIN, create a new account.
+
+        Parameters:
+            cardid - 16-digit card ID of the card we are creating an account for.
+            pin - Four digit PIN as entered by the user on a cabinet.
+
+        Returns:
+            A User ID if creation was successful, or None otherwise.
+        """
+        # First, create a user account
+        sql = "INSERT INTO user (pin, admin) VALUES (:pin, 0)"
+        cursor = self.execute(sql, {'pin': pin})
+        if cursor.rowcount != 1:
+            return None
+        userid = cursor.lastrowid
+
+        # Now, insert the card, tying it to the account
+        sql = "INSERT INTO card (id, userid) VALUES (:cardid, :userid)"
+        cursor = self.execute(sql, {'cardid': cardid, 'userid': userid})
+        if cursor.rowcount != 1:
+            return None
+
+        # Now, if this user played on a remote network and their profile
+        # was ever fetched locally or they were ever rivaled against,
+        # convert those locally too so that players don't lose rivals
+        # on new account creation.
+        oldid = RemoteUser.card_to_userid(cardid)
+        if RemoteUser.is_remote(oldid):
+            sql = "UPDATE extid SET userid = :newid WHERE userid = :oldid"
+            self.execute(sql, {'newid': userid, 'oldid': oldid})
+            sql = "UPDATE refid SET userid = :newid WHERE userid = :oldid"
+            self.execute(sql, {'newid': userid, 'oldid': oldid})
+            sql = "UPDATE link SET other_userid = :newid WHERE other_userid = :oldid"
+            self.execute(sql, {'newid': userid, 'oldid': oldid})
+
+        # Finally, return the user ID
+        return userid
diff --git a/bemani/data/remoteuser.py b/bemani/data/remoteuser.py
new file mode 100644
index 0000000..db81090
--- /dev/null
+++ b/bemani/data/remoteuser.py
@@ -0,0 +1,28 @@
+from bemani.data.types import UserID
+
+
+class RemoteUser:
+    """
+    We use a nasty trick to tell the difference between a local and remote user.
+    Local users are assumed to be in the range of 1 to 2^32-1. Remote users therefore
+    are anything above that range. We cast card IDs to user IDs by treating them as
+    raw integers and then wrapping them in the UserID type. This is how we can
+    store local information in our DB for remote users, such as rival settings/etc.
+    """
+
+    @staticmethod
+    def card_to_userid(cardid: str) -> UserID:
+        return UserID(int(cardid, 16))
+
+    @staticmethod
+    def userid_to_card(userid: UserID) -> str:
+        cardid = hex(abs(userid))[2:].upper()
+        if len(cardid) <= 8:
+            raise Exception('Got invalid card back when converting from UserID!')
+        if len(cardid) < 16:
+            cardid = ('0' * (16 - len(cardid))) + cardid
+        return cardid
+
+    @staticmethod
+    def is_remote(userid: UserID) -> bool:
+        return userid > (2**32 - 1)
diff --git a/bemani/data/types.py b/bemani/data/types.py
new file mode 100644
index 0000000..dae92ff
--- /dev/null
+++ b/bemani/data/types.py
@@ -0,0 +1,514 @@
+from typing import Optional, List, Dict, Any, NewType
+
+from bemani.common import ValidatedDict
+
+UserID = NewType('UserID', int)
+ArcadeID = NewType('ArcadeID', int)
+
+
+class User:
+    """
+    An object representing a user. This is an account that has zero or more
+    cards associated with it (starting with 1 when carding in for the first time),
+    and possibly has a username/password/email if the user has signed up for
+    the frontend. Once that is done, users can remove their only card, or add
+    more cards, or swap out a card for a new one.
+    """
+
+    def __init__(self, userid: UserID, username: Optional[str], email: Optional[str], admin: bool) -> None:
+        """
+        Initialize the user object.
+
+        Parameters:
+            userid - The ID of the user.
+            username - An optional string, set if the user has claimed their account on
+                       the web UI.
+            email - An optional string, set if the user has claimed their account on the
+                    web UI.
+        """
+        self.id = userid
+        self.username = username
+        self.email = email
+        self.admin = admin
+
+    def __repr__(self) -> str:
+        return "User(userid={}, username={}, email={}, admin={})".format(
+            self.id,
+            self.username,
+            self.email,
+            self.admin,
+        )
+
+
+class Achievement:
+    """
+    An object representing a single achievement for a user.
+
+    Achievements are referred to loosely here. An achievement is really any type/id pair
+    that can have some attached data, such as item unlocks, tran medals, course progress, etc.
+    """
+
+    def __init__(self, achievementid: int, achievementtype: str, timestamp: Optional[int], data: Dict[str, Any]) -> None:
+        """
+        Initialize the achievement object.
+
+        Parameters:
+            achievementid - The ID of the achievement, as assigned by a game class.
+            achievementtype - The type of the achievement, as assigned by a game class.
+            timestamp - The timestamp this achievement was earned, if available.
+            data - Any optional data the game wishes to save and retrieve later.
+        """
+        self.id = achievementid
+        self.type = achievementtype
+        self.timestamp = timestamp
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Achievement(achievementid={}, achievementtype={}, timestamp={}, data={})".format(
+            self.id,
+            self.type,
+            self.timestamp,
+            self.data,
+        )
+
+
+class Link:
+    """
+    An object representing a single link between two users. The type of the link is
+    determined by the game that needs this linkage.
+    """
+
+    def __init__(self, userid: UserID, linktype: str, other_userid: UserID, data: Dict[str, Any]) -> None:
+        """
+        Initialize the achievement object.
+
+        Parameters:
+            userid - The ID of the user.
+            linktype - The type of the link, as assigned by a game class.
+            other_userid - The ID of the second user we're linked against.
+            data - Any optional data the game wishes to save and retrieve later.
+        """
+        self.userid = userid
+        self.type = linktype
+        self.other_userid = other_userid
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Link(userid={}, linktype={}, other_userid={}, data={})".format(
+            self.userid,
+            self.type,
+            self.other_userid,
+            self.data,
+        )
+
+
+class Machine:
+    """
+    An object representing a single machine found in the DB. Machines are
+    potentially owned by arcades, and keyed by PCBID. There will always be
+    a 1:1 mapping between a PCBID seen on the network and a Machine.
+    """
+
+    def __init__(
+        self,
+        machineid: int,
+        pcbid: str,
+        name: str,
+        description: str,
+        arcade: Optional[ArcadeID],
+        port: int,
+        game: Optional[str],
+        version: Optional[int],
+        data: Dict[str, Any],
+    ) -> None:
+        """
+        Initialize the machine instance.
+
+        Parameters:
+            machineid - The machine's internal ID, from the DB.
+            pcbid - The PCBID assigned to the machine.
+            name - The name of the machine, as potentially set by the operator.
+            arcade - Optionally, the ID of the arcade this machine belongs in.
+            port - The port this machine is assigned.
+            game - Optionally, the game series that this machine is tied to.
+            version - Optionally, the version of the above game required. If it
+                      is negative, then any game equal to or lower in version to
+                      the abs of this is required.
+            data - Extra data that a game backend may want to save with a machine.
+        """
+        self.id = machineid
+        self.pcbid = pcbid
+        self.name = name
+        self.description = description
+        self.arcade = arcade
+        self.port = port
+        self.game = game
+        self.version = version
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Machine(machineid={}, pcbid={}, name={}, description={}, arcade={}, port={}, game={}, version={}, data={})".format(
+            self.id,
+            self.pcbid,
+            self.name,
+            self.description,
+            self.arcade,
+            self.port,
+            self.game,
+            self.version,
+            self.data,
+        )
+
+
+class Arcade:
+    """
+    An object representing a single arcade found in the DB. Arcades can be given owners
+    and should be seen as a zone of machines. Zones can override PASELI settings and set
+    up events/globals/other settings. In this way, you can give power to operators of
+    arcades on your network, who can then go on to configure events and PASELI including
+    crediting accounts. Machines belong to either no arcade or a single arcase.
+    """
+
+    def __init__(self, arcadeid: ArcadeID, name: str, description: str, pin: str, data: Dict[str, Any], owners: List[UserID]) -> None:
+        """
+        Initialize the arcade instance.
+
+        Parameters:
+            arcadeid - The arcade's internal ID, from the DB.
+            name - The name of the arcade.
+            description - The description of the arcade.
+            pin - An eight digit string representing the PIN used to pull up PASELI info.
+            data - A dictionary of settings for this arcade.
+            owners - An list of integers specifying the user IDs of owners for this arcade.
+        """
+        self.id = arcadeid
+        self.name = name
+        self.description = description
+        self.pin = pin
+        self.data = ValidatedDict(data)
+        self.owners = owners
+
+    def __repr__(self) -> str:
+        return "Arcade(arcadeid={}, name={}, description={}, pin={}, data={}, owners={})".format(
+            self.id,
+            self.name,
+            self.description,
+            self.pin,
+            self.data,
+            self.owners,
+        )
+
+
+class Song:
+    """
+    An object representing a single song in the DB.
+    """
+
+    def __init__(
+        self,
+        game: str,
+        version: int,
+        songid: int,
+        songchart: int,
+        name: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        data: Dict[str, Any],
+    ) -> None:
+        """
+        Initialize the song object.
+
+        Parameters:
+            game - The song's game series.
+            version - The song's game version.
+            songid - The song's ID according to the game.
+            songchart - The song's chart number, according to the game.
+            name - The name of the song, from the DB.
+            artist - The artist of the song, from the DB.
+            genre - The genre of the song, from the DB.
+            data - Any optional data that a game class uses for a song.
+        """
+        self.game = game
+        self.version = version
+        self.id = songid
+        self.chart = songchart
+        self.name = name
+        self.artist = artist
+        self.genre = genre
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Song(game={}, version={}, songid={}, songchart={}, name={}, artist={}, genre={}, data={})".format(
+            self.game,
+            self.version,
+            self.id,
+            self.chart,
+            self.name,
+            self.artist,
+            self.genre,
+            self.data,
+        )
+
+
+class Score:
+    """
+    An object representing a single score for a user.
+    """
+
+    def __init__(
+        self,
+        key: int,
+        songid: int,
+        songchart: int,
+        points: int,
+        timestamp: int,
+        update: int,
+        location: int,
+        plays: int,
+        data: Dict[str, Any],
+    ) -> None:
+        """
+        Initialize the score object.
+
+        Parameters:
+            key - A unique key identifying this exact score.
+            songid - The song's ID according to the game.
+            songchart - The song's chart number, according to the game.
+            points - The points achieved on this song, from the DB.
+            timestamp - The timestamp when the record was earned.
+            update - The timestamp when the record was last updated (including play count).
+            plays - The number of plays the user has recorded for this song and chart.
+            location - The ID of the machine that this score was earned on.
+            data - Any optional data that a game class recorded with this score.
+        """
+        self.key = key
+        self.id = songid
+        self.chart = songchart
+        self.points = points
+        self.timestamp = timestamp
+        self.update = update
+        self.location = location
+        self.plays = plays
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Score(key={}, songid={}, songchart={}, points={}, timestamp={}, update={}, location={}, plays={}, data={})".format(
+            self.key,
+            self.id,
+            self.chart,
+            self.points,
+            self.timestamp,
+            self.update,
+            self.location,
+            self.plays,
+            self.data,
+        )
+
+
+class Attempt:
+    """
+    An object representing a single score attempt for a user.
+    """
+
+    def __init__(
+        self,
+        key: int,
+        songid: int,
+        songchart: int,
+        points: int,
+        timestamp: int,
+        location: int,
+        new_record: bool,
+        data: Dict[str, Any],
+    ) -> None:
+        """
+        Initialize the score object.
+
+        Parameters:
+            key - A unique key identifying this exact attempt.
+            songid - The song's ID according to the game.
+            songchart - The song's chart number, according to the game.
+            points - The points achieved on this song, from the DB.
+            timestamp - The timestamp of the attempt.
+            location - The ID of the machine that this score was earned on.
+            new_record - Whether this attempt resulted in a new record for this user.
+            data - Any optional data that a game class recorded with this score.
+        """
+        self.key = key
+        self.id = songid
+        self.chart = songchart
+        self.points = points
+        self.timestamp = timestamp
+        self.location = location
+        self.new_record = new_record
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Attempt(key={}, songid={}, songchart={}, points={}, timestamp={}, location={}, new_record={}, data={})".format(
+            self.key,
+            self.id,
+            self.chart,
+            self.points,
+            self.timestamp,
+            self.location,
+            self.new_record,
+            self.data,
+        )
+
+
+class News:
+    """
+    An object representing an item of news as displayed on the homepage of
+    the frontend.
+    """
+
+    def __init__(self, newsid: int, timestamp: int, title: str, body: str) -> None:
+        """
+        Initialize the news object.
+
+        Parameters:
+            newsid - Integer identifier for the news item.
+            timestamp - Integer representing unix timestamp of the news item being created.
+            title - String representing news title.
+            body - String representing news body.
+        """
+        self.id = newsid
+        self.timestamp = timestamp
+        self.title = title
+        self.body = body
+
+    def __repr__(self) -> str:
+        return "News(newsid={}, timestamp={}, title={}, body={})".format(
+            self.id,
+            self.timestamp,
+            self.title,
+            self.body,
+        )
+
+
+class Event:
+    """
+    An object representing an audit event. These are PCB events, errors, exceptions,
+    invalid PCBIDs trying to connect, or more mundate events such as daily selection.
+    """
+
+    def __init__(self, auditid: int, timestamp: int, userid: Optional[UserID], arcadeid: Optional[ArcadeID], event: str, data: Dict[str, Any]) -> None:
+        """
+        Initialize the audit event object.
+
+        Parameters:
+            auditid - Integer identifier for the audit entry.
+            timestamp - Integer representing unix timestamp of the audit entrys creation.
+            userid - User ID of the user the event related to, or None if there was no user.
+            arcadeid - Arcade ID of the arcade the event related to, or None if there was no arcade.
+            event - String event type.
+            data - Optional dictionary of values for the event.
+        """
+        self.id = auditid
+        self.timestamp = timestamp
+        self.userid = userid
+        self.arcadeid = arcadeid
+        self.type = event
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Event(auditid={}, timestamp={}, userid={}, arcadeid={}, event={}, data={})".format(
+            self.id,
+            self.timestamp,
+            self.userid,
+            self.arcadeid,
+            self.type,
+            self.data,
+        )
+
+
+class Item:
+    """
+    An object representing an item from the catalog for a game.
+    """
+
+    def __init__(self, cattype: str, catid: int, data: Dict[str, Any]) -> None:
+        """
+        Initialize the catalog object.
+
+        Parameters:
+            cattype - Catalog type.
+            catid - Catalog ID.
+            data - Optional dictionary of values for the catalog item.
+        """
+        self.type = cattype
+        self.id = catid
+        self.data = ValidatedDict(data)
+
+    def __repr__(self) -> str:
+        return "Item(cattype={}, catid={}, data={})".format(
+            self.type,
+            self.id,
+            self.data,
+        )
+
+
+class Client:
+    """
+    An object representing a client that's been authorized to talk to our BEMAPI
+    server implementation.
+    """
+
+    def __init__(self, clientid: int, timestamp: int, name: str, token: str) -> None:
+        """
+        Initialize the client object.
+
+        Parameters:
+            clientid - Integer identifier for the client.
+            timestamp - Add time as an integer unix timestamp.
+            name - Name of the client.
+            token - Authorization token given to the client.
+        """
+        self.id = clientid
+        self.timestamp = timestamp
+        self.name = name
+        self.token = token
+
+    def __repr__(self) -> str:
+        return "Client(clientid={}, timestamp={}, name={}, token={})".format(
+            self.id,
+            self.timestamp,
+            self.name,
+            self.token,
+        )
+
+
+class Server:
+    """
+    An object representing a BEMAPI server that's we've been authorized to talk
+    to for pulling data.
+    """
+
+    def __init__(self, serverid: int, timestamp: int, uri: str, token: str, allow_stats: bool, allow_scores: bool) -> None:
+        """
+        Initialize the server object.
+
+        Parameters:
+            serverid - Integer identifier for the server.
+            timestamp - Add time as an integer unix timestamp.
+            uri - Base URI of the server.
+            token - Authorization token given to us.
+            allow_stats - True if we should pull statistics from this server.
+            allow_scores - True if we should pull scores from this server.
+        """
+        self.id = serverid
+        self.timestamp = timestamp
+        self.uri = uri
+        self.token = token
+        self.allow_stats = allow_stats
+        self.allow_scores = allow_scores
+
+    def __repr__(self) -> str:
+        return "Server(serverid={}, timestamp={}, uri={}, token={}, allow_stats={}, allow_scores={})".format(
+            self.id,
+            self.timestamp,
+            self.uri,
+            self.token,
+            self.allow_stats,
+            self.allow_scores,
+        )
diff --git a/bemani/data/user.py b/bemani/data/user.py
new file mode 100644
index 0000000..a68967f
--- /dev/null
+++ b/bemani/data/user.py
@@ -0,0 +1,1118 @@
+import copy
+import random
+from sqlalchemy import Table, Column, UniqueConstraint  # type: ignore
+from sqlalchemy.types import String, Integer, JSON  # type: ignore
+from sqlalchemy.exc import IntegrityError
+from typing import Optional, Dict, List, Tuple, Any
+from passlib.hash import pbkdf2_sha512  # type: ignore
+
+from bemani.common import ValidatedDict, Time
+from bemani.data.base import BaseData, metadata
+from bemani.data.types import User, Achievement, Link, UserID, ArcadeID
+
+"""
+Table representing a user. Each user has a unique ID and a pin which
+is used with all cards associated with the user's account. Username
+and password are optional as a user does not need to create a web login
+to use the network. However, an active user account is required
+before creating a web login.
+"""
+user = Table(  # type:ignore
+    'user',
+    metadata,
+    Column('id', Integer, nullable=False, primary_key=True),
+    Column('pin', String(4), nullable=False),
+    Column('username', String(255), unique=True),
+    Column('password', String(255)),
+    Column('email', String(255)),
+    Column('admin', Integer),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table representing a card associated with a user. Users may have zero
+or more cards associated with them. When a new card is used in a game
+a new user will be created to associate with a card, but it can later
+be unlinked.
+"""
+card = Table(  # type:ignore
+    'card',
+    metadata,
+    Column('id', String(16), nullable=False, unique=True),
+    Column('userid', Integer, nullable=False, index=True),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table representing an extid for a user across a game series. Each game
+series on the network gets its own extid (8 digit number) for each user.
+"""
+extid = Table(  # type:ignore
+    'extid',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('extid', Integer, nullable=False, unique=True),
+    Column('userid', Integer, nullable=False),
+    UniqueConstraint('game', 'userid', name='game_userid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table representing a refid for a user. Each unique game on the network will
+need a refid for each user/game/version they have a profile for. If a user
+does not have a profile for a particular game, a new and unique refid
+will be generated for the user.
+
+Note that a user might have an extid/refid for a game without a profile,
+but a user cannot have a profile without an extid/refid.
+"""
+refid = Table(  # type:ignore
+    'refid',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('refid', String(16), nullable=False, unique=True),
+    Column('userid', Integer, nullable=False),
+    UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing JSON profile blobs, indexed by refid.
+"""
+profile = Table(  # type:ignore
+    'profile',
+    metadata,
+    Column('refid', String(16), nullable=False, unique=True),
+    Column('data', JSON, nullable=False),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing game achievements. An achievement is just a blob of data
+with a unique ID and type. Games are free to store a JSON blob for each
+achievement. Examples would be tran medals, event unlocks, items earned,
+etc.
+"""
+achievement = Table(  # type:ignore
+    'achievement',
+    metadata,
+    Column('refid', String(16), nullable=False),
+    Column('id', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('refid', 'id', 'type', name='refid_id_type'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing time-based achievements. A time-based achievement is
+almost identical to a regular achievement, but you can earn multiple of
+the same type of achievement at different times, and it matters when
+you earn it. Games are free to store a JSON blob for each achievement and
+the blob does not need to be equal across different instances of the same
+achievement for the same user. Examples would be calorie earnings for DDR.
+"""
+time_based_achievement = Table(  # type:ignore
+    'time_based_achievement',
+    metadata,
+    Column('refid', String(16), nullable=False),
+    Column('id', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('timestamp', Integer, nullable=False, index=True),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('refid', 'id', 'type', 'timestamp', name='refid_id_type_timestamp'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing a user's PASELI balance, given an arcade. There is no global
+balance on this network.
+"""
+balance = Table(  # type:ignore
+    'balance',
+    metadata,
+    Column('userid', Integer, nullable=False),
+    Column('arcadeid', Integer, nullable=False),
+    Column('balance', Integer, nullable=False),
+    UniqueConstraint('userid', 'arcadeid', name='userid_arcadeid'),
+    mysql_charset='utf8mb4',
+)
+
+"""
+Table for storing links between two users in a game/version, whatever that
+may be. Typically used for rivals.
+etc.
+"""
+link = Table(  # type:ignore
+    'link',
+    metadata,
+    Column('game', String(32), nullable=False),
+    Column('version', Integer, nullable=False),
+    Column('userid', Integer, nullable=False),
+    Column('type', String(64), nullable=False),
+    Column('other_userid', Integer, nullable=False),
+    Column('data', JSON, nullable=False),
+    UniqueConstraint('game', 'version', 'userid', 'type', 'other_userid', name='game_version_userid_type_other_uuserid'),
+    mysql_charset='utf8mb4',
+)
+
+
+class AccountCreationException(Exception):
+    pass
+
+
+class UserData(BaseData):
+
+    REF_ID_LENGTH = 16
+
+    def from_cardid(self, cardid: str) -> Optional[UserID]:
+        """
+        Given a 16 digit card ID, look up a user ID.
+
+        Note that this is the E004 number as stored on the card. Not the 16 digit
+        ASCII value on the back. Use CardCipher to convert.
+
+        Parameters:
+            cardid - 16-digit card ID to look for.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        # First, look up the user account
+        sql = "SELECT userid FROM card WHERE id = :id"
+        cursor = self.execute(sql, {'id': cardid})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this card
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['userid'])
+
+    def from_username(self, username: str) -> Optional[UserID]:
+        """
+        Given a username, look up a user ID.
+
+        Parameters:
+            username - A string representing the user's username.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        sql = "SELECT id FROM user WHERE username = :username"
+        cursor = self.execute(sql, {'username': username})
+        if cursor.rowcount != 1:
+            # Couldn't find this username
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['id'])
+
+    def from_refid(self, game: str, version: int, refid: str) -> Optional[UserID]:
+        """
+        Given a generated RefID, look up a user ID.
+
+        Note that there is a unique RefID and ExtID for each profile, and both can be used
+        to look up a user. When creating a new profile, we generate a unique RefID and ExtID.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            refid - RefID in question, most likely previously generated by this class.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        # First, look up the user account
+        sql = "SELECT userid FROM refid WHERE game = :game AND version = :version AND refid = :refid"
+        cursor = self.execute(sql, {'game': game, 'version': version, 'refid': refid})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this refid
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['userid'])
+
+    def from_extid(self, game: str, version: int, extid: int) -> Optional[UserID]:
+        """
+        Given a generated ExtID, look up a user ID.
+
+        Note that there is a unique RefID and ExtID for each profile, and both can be used
+        to look up a user. When creating a new profile, we generate a unique RefID and ExtID.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            extid - ExtID in question, most likely previously generated by this class.
+
+        Returns:
+            User ID as an integer if found, or None if not.
+        """
+        # First, look up the user account
+        sql = "SELECT userid FROM extid WHERE game = :game AND extid = :extid"
+        cursor = self.execute(sql, {'game': game, 'extid': extid})
+        if cursor.rowcount != 1:
+            # Couldn't find a user with this refid
+            return None
+
+        result = cursor.fetchone()
+        return UserID(result['userid'])
+
+    def from_session(self, session: str) -> Optional[UserID]:
+        """
+        Given a previously-opened session, look up a user ID.
+
+        Parameters:
+            session - String identifying a session that was opened by create_session.
+
+        Returns:
+            User ID as an integer if found, or None if the session is expired or doesn't exist.
+        """
+        userid = self._from_session(session, 'userid')
+        if userid is None:
+            return None
+        return UserID(userid)
+
+    def get_user(self, userid: UserID) -> Optional[User]:
+        """
+        Given a userid, look up details about the account.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A User object if found, or None otherwise.
+        """
+        sql = "SELECT username, email, admin FROM user WHERE id = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        if cursor.rowcount != 1:
+            # User doesn't exist, but we have a reference?
+            return None
+
+        result = cursor.fetchone()
+        return User(userid, result['username'], result['email'], result['admin'] == 1)
+
+    def get_all_users(self) -> List[User]:
+        """
+        Look up all users in the system.
+
+        Returns:
+            A list of User objects representing all users.
+        """
+        sql = "SELECT id, username, email, admin FROM user"
+        cursor = self.execute(sql)
+        return [
+            User(UserID(result['id']), result['username'], result['email'], result['admin'] == 1)
+            for result in cursor.fetchall()
+        ]
+
+    def get_all_usernames(self) -> List[str]:
+        """
+        Look up all valid usernames in the system.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of strings representing usernames.
+        """
+        sql = "SELECT username FROM user WHERE username is not null"
+        cursor = self.execute(sql)
+        return [res['username'] for res in cursor.fetchall()]
+
+    def get_all_cards(self) -> List[Tuple[str, Optional[UserID]]]:
+        """
+        Look up all cards associated with any account.
+
+        Returns:
+            A list of Tuples representing representing card ID, user ID pairs.
+        """
+        sql = "SELECT id, userid FROM card"
+        cursor = self.execute(sql)
+        return [(res['id'], UserID(res['userid']) if res['userid'] is not None else None) for res in cursor.fetchall()]
+
+    def get_cards(self, userid: UserID) -> List[str]:
+        """
+        Given a userid, look up all cards associated with the account.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of strings representing card IDs.
+        """
+        sql = "SELECT id FROM card WHERE userid = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        return [res['id'] for res in cursor.fetchall()]
+
+    def add_card(self, userid: UserID, cardid: str) -> None:
+        """
+        Given a user ID and a card ID, link that card with that user.
+
+        Note that this is the E004 number as stored on the card. Not the 16 digit
+        ASCII value on the back. Use CardCipher to convert.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            cardid - 16-digit card ID to add.
+        """
+        sql = "INSERT INTO card (userid, id) VALUES (:userid, :cardid)"
+        self.execute(sql, {'userid': userid, 'cardid': cardid})
+
+    def destroy_card(self, userid: UserID, cardid: str) -> None:
+        """
+        Given a user ID and a card ID, remove the card ID link from that user.
+
+        Note that this is the E004 number as stored on the card. Not the 16 digit
+        ASCII value on the back. Use CardCipher to convert.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            cardid - 16-digit card ID to remove.
+        """
+        sql = "DELETE FROM card WHERE id = :cardid AND userid = :userid LIMIT 1"
+        self.execute(sql, {'cardid': cardid, 'userid': userid})
+
+    def put_user(self, user: User) -> None:
+        """
+        Given a user object, update the DB to save new user info.
+
+        Parameters:
+            user - A user, which has optional values set.
+        """
+        sql = "UPDATE user SET username = :username, email = :email, admin = :admin WHERE id = :userid"
+        self.execute(
+            sql,
+            {
+                'username': user.username,
+                'email': user.email,
+                'admin': 1 if user.admin else 0,
+                'userid': user.id,
+            },
+        )
+
+    def validate_pin(self, userid: UserID, pin: str) -> bool:
+        """
+        Given a userid and PIN, validate the PIN.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            pin - 4 digit string returned by the game for PIN entry.
+
+        Returns:
+            True if PIN is valid, False otherwise.
+        """
+        sql = "SELECT pin FROM user WHERE id = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        if cursor.rowcount != 1:
+            # User doesn't exist, but we have a reference?
+            return False
+
+        result = cursor.fetchone()
+        return pin == result['pin']
+
+    def update_pin(self, userid: UserID, pin: str) -> None:
+        """
+        Given a userid and a new PIN, update the PIN for that user.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            pin - 4 digit string returned by the game for PIN entry.
+        """
+        sql = "UPDATE user SET pin = :pin WHERE id = :userid"
+        self.execute(sql, {'pin': pin, 'userid': userid})
+
+    def validate_password(self, userid: UserID, password: str) -> bool:
+        """
+        Given a password, validate that the password matches the stored hash
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            password - String, plaintext password that will be hashed
+
+        Returns:
+            True if password is valid, False otherwise.
+        """
+        sql = "SELECT password FROM user WHERE id = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        if cursor.rowcount != 1:
+            # User doesn't exist, but we have a reference?
+            return False
+
+        result = cursor.fetchone()
+        passhash = result['password']
+
+        try:
+            # Verifying the password
+            return pbkdf2_sha512.verify(password, passhash)
+        except (ValueError, TypeError):
+            return False
+
+    def update_password(self, userid: UserID, password: str) -> None:
+        """
+        Given a userid and a new password, update the password for that user.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+            password - String, plaintext password that will be hashed
+        """
+        passhash = pbkdf2_sha512.hash(password)
+        sql = "UPDATE user SET password = :hash WHERE id = :userid"
+        self.execute(sql, {'hash': passhash, 'userid': userid})
+
+    def get_profile(self, game: str, version: int, userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid, look up the associated profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A dictionary previously stored by a game class if found, or None otherwise.
+        """
+        sql = (
+            "SELECT refid.refid AS refid, extid.extid AS extid " +
+            "FROM refid, extid " +
+            "WHERE refid.userid = :userid AND refid.game = :game AND refid.version = :version AND "
+            "extid.userid = refid.userid AND extid.game = refid.game"
+        )
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version})
+        if cursor.rowcount != 1:
+            # Profile doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        profile = {
+            'refid': result['refid'],
+            'extid': result['extid'],
+            'game': game,
+            'version': version,
+        }
+
+        sql = "SELECT data FROM profile WHERE refid = :refid"
+        cursor = self.execute(sql, {'refid': profile['refid']})
+        if cursor.rowcount != 1:
+            # Profile doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        profile.update(self.deserialize(result['data']))
+        return ValidatedDict(profile)
+
+    def get_games_played(self, userid: UserID) -> List[Tuple[str, int]]:
+        """
+        Given a user ID, look up all game/version combos this user has played.
+
+        Parameters:
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A List of Tuples of game, version for each game/version the user has played.
+        """
+        sql = "SELECT game, version FROM refid WHERE userid = :userid"
+        cursor = self.execute(sql, {'userid': userid})
+        profiles = []
+        for result in cursor.fetchall():
+            profiles.append((result['game'], result['version']))
+        return profiles
+
+    def get_all_profiles(self, game: str, version: int) -> List[Tuple[UserID, ValidatedDict]]:
+        """
+        Given a game/version, look up all user profiles for that game.
+
+        Parameters:
+            game - String identifier of the game we want all user profiles for.
+            version - Integer version of the game we want all user profiles for.
+
+        Returns:
+            A list of (UserID, dictionaries) previously stored by a game class for each profile.
+        """
+        sql = (
+            "SELECT refid.userid AS userid, refid.refid AS refid, extid.extid AS extid, profile.data AS data "
+            "FROM refid, profile, extid "
+            "WHERE refid.game = :game AND refid.version = :version "
+            "AND refid.refid = profile.refid AND extid.game = refid.game AND extid.userid = refid.userid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        profiles = []
+        for result in cursor.fetchall():
+            profile = {
+                'refid': result['refid'],
+                'extid': result['extid'],
+                'game': game,
+                'version': version,
+            }
+            profile.update(self.deserialize(result['data']))
+            profiles.append(
+                (
+                    UserID(result['userid']),
+                    ValidatedDict(profile),
+                )
+            )
+
+        return profiles
+
+    def get_all_players(self, game: str, version: int) -> List[UserID]:
+        """
+        Given a game/version, look up all user IDs that played this game/version.
+
+        Parameters:
+            game - String identifier of the game we want all user profiles for.
+            version - Integer version of the game we want all user profiles for.
+
+        Returns:
+            A list of UserIDs for users that played this version of this game.
+        """
+        sql = (
+            "SELECT refid.userid AS userid FROM refid "
+            "WHERE refid.game = :game AND refid.version = :version"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        return [UserID(result['userid']) for result in cursor.fetchall()]
+
+    def get_all_achievements(self, game: str, version: int) -> List[Tuple[UserID, Achievement]]:
+        """
+        Given a game/version, find all achievements for al players.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+
+        Returns:
+            A list of (UserID, Achievement) objects.
+        """
+        sql = (
+            "SELECT achievement.id AS id, achievement.type AS type, achievement.data AS data, "
+            "refid.userid AS userid FROM achievement, refid WHERE refid.game = :game AND "
+            "refid.version = :version AND refid.refid = achievement.refid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                (
+                    UserID(result['userid']),
+                    Achievement(
+                        result['id'],
+                        result['type'],
+                        None,
+                        self.deserialize(result['data']),
+                    ),
+                )
+            )
+
+        return achievements
+
+    def put_profile(self, game: str, version: int, userid: UserID, profile: Dict[str, Any]) -> None:
+        """
+        Given a game/version/userid, save an associated profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            profile - A dictionary that a game class will want to retrieve later.
+        """
+        refid = self.get_refid(game, version, userid)
+        profile = copy.deepcopy(profile)
+        if 'refid' in profile:
+            del profile['refid']
+        if 'extid' in profile:
+            del profile['extid']
+        if 'game' in profile:
+            del profile['game']
+        if 'version' in profile:
+            del profile['version']
+
+        # Add profile json to game profile
+        sql = (
+            "INSERT INTO profile (refid, data) " +
+            "VALUES (:refid, :json) " +
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'refid': refid, 'json': self.serialize(profile)})
+
+    def get_achievement(self, game: str, version: int, userid: UserID, achievementid: int, achievementtype: str) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid and achievement id/type, find that achievement.
+
+        Note that there can be more than one achievement with the same ID and game/version/userid
+        as long as each one is a different type. Essentially, achievementtype namespaces achievements.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        refid = self.get_refid(game, version, userid)
+        sql = (
+            "SELECT data FROM achievement WHERE refid = :refid AND id = :id AND type = :type"
+        )
+        cursor = self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype})
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def get_achievements(self, game: str, version: int, userid: UserID) -> List[Achievement]:
+        """
+        Given a game/version/userid, find all achievements
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of Achievement objects.
+        """
+        refid = self.get_refid(game, version, userid)
+        sql = "SELECT id, type, data FROM achievement WHERE refid = :refid"
+        cursor = self.execute(sql, {'refid': refid})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                Achievement(
+                    result['id'],
+                    result['type'],
+                    None,
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return achievements
+
+    def put_achievement(self, game: str, version: int, userid: UserID, achievementid: int, achievementtype: str, data: Dict[str, Any]) -> None:
+        """
+        Given a game/version/userid and achievement id/type, save an achievement.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        refid = self.get_refid(game, version, userid)
+
+        # Add achievement JSON to achievements
+        sql = (
+            "INSERT INTO achievement (refid, id, type, data) " +
+            "VALUES (:refid, :id, :type, :data) " +
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype, 'data': self.serialize(data)})
+
+    def destroy_achievement(self, game: str, version: int, userid: UserID, achievementid: int, achievementtype: str) -> None:
+        """
+        Given a game/version/userid and achievement id/type, delete an achievement.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+        """
+        refid = self.get_refid(game, version, userid)
+
+        # Nuke the achievement from the user
+        sql = (
+            "DELETE FROM achievement WHERE refid = :refid AND id = :id AND type = :type"
+        )
+        self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype})
+
+    def get_time_based_achievements(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        achievementtype: Optional[str]=None,
+        since: Optional[int]=None,
+        until: Optional[int]=None,
+    ) -> List[Achievement]:
+        """
+        Given a game/version/userid, find all time-based achievements
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementtype - Optional string specifying to constrain to a type of achievement.
+            since - Return achievements since this time (inclusive).
+            until - Return achievements until this time (exclusive).
+
+        Returns:
+            A list of Achievement objects.
+        """
+        refid = self.get_refid(game, version, userid)
+        sql = "SELECT id, type, timestamp, data FROM time_based_achievement WHERE refid = :refid"
+        if achievementtype is not None:
+            sql += " AND type = :type"
+        if since is not None:
+            sql += " AND timestamp >= :since"
+        if until is not None:
+            sql += " AND timestamp < :until"
+        cursor = self.execute(sql, {'refid': refid, 'type': achievementtype, 'since': since, 'until': until})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                Achievement(
+                    result['id'],
+                    result['type'],
+                    result['timestamp'],
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return achievements
+
+    def put_time_based_achievement(
+        self,
+        game: str,
+        version: int,
+        userid: UserID,
+        achievementid: int,
+        achievementtype: str,
+        data: Dict[str, Any],
+    ) -> None:
+        """
+        Given a game/version/userid and achievement id/type, save a time-based achievement. Assumes that
+        time-based achievements are immutable once saved.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            achievementid - Integer ID, as provided by a game.
+            achievementtype - The type of achievement.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        refid = self.get_refid(game, version, userid)
+
+        # Add achievement JSON to achievements
+        sql = (
+            "INSERT INTO time_based_achievement (refid, id, type, timestamp, data) " +
+            "VALUES (:refid, :id, :type, :ts, :data)"
+        )
+        self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype, 'ts': Time.now(), 'data': self.serialize(data)})
+
+    def get_all_time_based_achievements(self, game: str, version: int) -> List[Tuple[UserID, Achievement]]:
+        """
+        Given a game/version, find all time-based achievements for all players.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+
+        Returns:
+            A list of (UserID, Achievement) objects.
+        """
+        sql = (
+            "SELECT time_based_achievement.id AS id, time_based_achievement.type AS type, "
+            "time_based_achievement.data AS data, time_based_achievement.timestamp AS timestamp, "
+            "refid.userid AS userid FROM time_based_achievement, refid WHERE refid.game = :game AND "
+            "refid.version = :version AND refid.refid = time_based_achievement.refid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version})
+
+        achievements = []
+        for result in cursor.fetchall():
+            achievements.append(
+                (
+                    UserID(result['userid']),
+                    Achievement(
+                        result['id'],
+                        result['type'],
+                        result['timestamp'],
+                        self.deserialize(result['data']),
+                    ),
+                )
+            )
+
+        return achievements
+
+    def get_link(self, game: str, version: int, userid: UserID, linktype: str, other_userid: UserID) -> Optional[ValidatedDict]:
+        """
+        Given a game/version/userid and link type + other userid, find that link.
+
+        Note that there can be more than one link with the same user IDs and game/version
+        as long as each one is a different type.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            linktype - The type of link.
+            other_userid - Integer user ID of the account we're linked to.
+
+        Returns:
+            A dictionary as stored by a game class previously, or None if not found.
+        """
+        sql = (
+            "SELECT data FROM link WHERE game = :game AND version = :version AND userid = :userid AND type = :type AND other_userid = :other_userid"
+        )
+        cursor = self.execute(sql, {'game': game, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid})
+        if cursor.rowcount != 1:
+            # score doesn't exist
+            return None
+
+        result = cursor.fetchone()
+        return ValidatedDict(self.deserialize(result['data']))
+
+    def get_links(self, game: str, version: int, userid: UserID) -> List[Link]:
+        """
+        Given a game/version/userid, find all links between this user and other users
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A list of Link objects.
+        """
+        sql = "SELECT type, other_userid, data FROM link WHERE game = :game AND version = :version AND userid = :userid"
+        cursor = self.execute(sql, {'game': game, 'version': version, 'userid': userid})
+
+        links = []
+        for result in cursor.fetchall():
+            links.append(
+                Link(
+                    userid,
+                    result['type'],
+                    UserID(result['other_userid']),
+                    self.deserialize(result['data']),
+                )
+            )
+
+        return links
+
+    def put_link(self, game: str, version: int, userid: UserID, linktype: str, other_userid: UserID, data: Dict[str, Any]) -> None:
+        """
+        Given a game/version/userid and link id + other_userid, save an link.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            linktype - The type of link.
+            other_userid - Integer user ID of the account we're linked to.
+            data - A dictionary of data that the game wishes to retrieve later.
+        """
+        # Add link JSON to link
+        sql = (
+            "INSERT INTO link (game, version, userid, type, other_userid, data) "
+            "VALUES (:game, :version, :userid, :type, :other_userid, :data) "
+            "ON DUPLICATE KEY UPDATE data=VALUES(data)"
+        )
+        self.execute(sql, {'game': game, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid, 'data': self.serialize(data)})
+
+    def destroy_link(self, game: str, version: int, userid: UserID, linktype: str, other_userid: UserID) -> None:
+        """
+        Given a game/version/userid and link id + other_userid, destroy the link.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+            linktype - The type of link.
+            other_userid - Integer user ID of the account we're linked to.
+        """
+        sql = (
+            "DELETE FROM link WHERE game = :game AND version = :version AND userid = :userid AND type = :type AND other_userid = :other_userid"
+        )
+        self.execute(sql, {'game': game, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid})
+
+    def get_balance(self, userid: UserID, arcadeid: ArcadeID) -> int:
+        """
+        Given a user and an arcade ID, look up the user's PASELI balance for that arcade.
+
+        Parameters:
+            userid - The user ID in question, as looked up by this class.
+            arcadeid - The arcade in question.
+
+        Returns:
+            The PASELI balance for this user at this arcade.
+        """
+        sql = "SELECT balance FROM balance WHERE userid = :userid AND arcadeid = :arcadeid"
+        cursor = self.execute(sql, {'userid': userid, 'arcadeid': arcadeid})
+        if cursor.rowcount == 1:
+            result = cursor.fetchone()
+            return result['balance']
+        else:
+            return 0
+
+    def update_balance(self, userid: UserID, arcadeid: ArcadeID, delta: int) -> Optional[int]:
+        """
+        Given a user and an arcade ID, update the PASELI balance for that arcade.
+
+        Parameters:
+            userid - The user ID in question, as looked up by this class.
+            arcadeid - The arcade in question.
+            delta - The value to add (or subtract, if delta is negative).
+
+        Returns:
+            The new PASELI balance if successful, or None if there wasn't enough to apply the delta.
+        """
+        sql = (
+            "INSERT INTO balance (userid, arcadeid, balance) VALUES (:userid, :arcadeid, :delta) "
+            "ON DUPLICATE KEY UPDATE balance = balance + :delta"
+        )
+        self.execute(sql, {'delta': delta, 'userid': userid, 'arcadeid': arcadeid})
+        newbalance = self.get_balance(userid, arcadeid)
+        if newbalance < 0:
+            # Went under while grabbing, put the balance back and return nothing
+            sql = "UPDATE balance SET balance = balance - :delta WHERE userid = :userid AND arcadeid = :arcadeid"
+            self.execute(sql, {'delta': delta, 'userid': userid, 'arcadeid': arcadeid})
+            return None
+        return newbalance
+
+    def get_refid(self, game: str, version: int, userid: UserID) -> str:
+        """
+        Given a game/version and user ID, look up the RefID for the profile.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            The RefID associated with the profile for this user. If there isn't one, creates one
+            and returns it, which can be used for creating/looking up a profile in the future.
+        """
+        sql = "SELECT refid FROM refid WHERE userid = :userid AND game = :game AND version = :version"
+        cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version})
+        if cursor.rowcount == 1:
+            result = cursor.fetchone()
+            return result['refid']
+        else:
+            return self.create_refid(game, version, userid)
+
+    def create_session(self, userid: UserID, expiration: int=(30 * 86400)) -> str:
+        """
+        Given a user ID, create a session string.
+
+        Parameters:
+            userid - User ID we wish to start a session for.
+            expiration - Number of seconds before this session is invalid.
+
+        Returns:
+            A string that can be used as a session ID.
+        """
+        return self._create_session(userid, 'userid', expiration)
+
+    def destroy_session(self, session: str) -> None:
+        """
+        Destroy a previously-created session.
+
+        Parameters:
+            session - A session string as returned from create_session.
+        """
+        self._destroy_session(session, 'userid')
+
+    def create_refid(self, game: str, version: int, userid: UserID) -> str:
+        """
+        Given a game/version/userid, create a RefID and an ExtID if necessary.
+
+        Note that while this function returns the created RefID, an ExtID is also
+        created and stored in the DB. Both RefID and ExtID are guaranteed to be
+        unique, but the RefID is guaranteed unique for each profile while ExtID
+        is guaranteed unique for each game series/user.
+
+        Parameters:
+            game - String identifier of the game looking up the user.
+            version - Integer version of the game looking up the user.
+            userid - Integer user ID, as looked up by one of the above functions.
+
+        Returns:
+            A string RefID value.
+        """
+        # Create a new extid that is unique
+        while True:
+            extid = random.randint(0, 89999999) + 10000000
+            sql = "SELECT extid FROM extid WHERE extid = :extid"
+            cursor = self.execute(sql, {'extid': extid})
+            if cursor.rowcount == 0:
+                break
+
+        # Use that extid
+        sql = (
+            "INSERT INTO extid (game, extid, userid) " +
+            "VALUES (:game, :extid, :userid)"
+        )
+        try:
+            cursor = self.execute(sql, {'game': game, 'extid': extid, 'userid': userid})
+        except IntegrityError:
+            # User already has an ExtID for this game series
+            pass
+
+        # Create a new refid that is unique
+        while True:
+            refid = ''.join(random.choice('0123456789ABCDEF') for _ in range(UserData.REF_ID_LENGTH))
+            sql = "SELECT refid FROM refid WHERE refid = :refid"
+            cursor = self.execute(sql, {'refid': refid})
+            if cursor.rowcount == 0:
+                break
+
+        # Use that refid
+        sql = (
+            "INSERT INTO refid (game, version, refid, userid) " +
+            "VALUES (:game, :version, :refid, :userid)"
+        )
+        try:
+            cursor = self.execute(sql, {'game': game, 'version': version, 'refid': refid, 'userid': userid})
+            if cursor.rowcount != 1:
+                raise AccountCreationException()
+            return refid
+        except IntegrityError:
+            # We maybe lost the race? Look up the ID from another creation. Don't call get_refid
+            # because it calls us, so we don't want an infinite loop.
+            sql = "SELECT refid FROM refid WHERE userid = :userid AND game = :game AND version = :version"
+            cursor = self.execute(sql, {'userid': userid, 'game': game, 'version': version})
+            if cursor.rowcount == 1:
+                result = cursor.fetchone()
+                return result['refid']
+            # Shouldn't be possible, but here we are
+            raise AccountCreationException()
+
+    def create_account(self, cardid: str, pin: str) -> Optional[UserID]:
+        """
+        Given a Card ID and a PIN, create a new account.
+
+        Parameters:
+            cardid - 16-digit card ID of the card we are creating an account for.
+            pin - Four digit PIN as entered by the user on a cabinet.
+
+        Returns:
+            A User ID if creation was successful, or None otherwise.
+        """
+        # First, create a user account
+        sql = "INSERT INTO user (pin, admin) VALUES (:pin, 0)"
+        cursor = self.execute(sql, {'pin': pin})
+        if cursor.rowcount != 1:
+            return None
+        userid = cursor.lastrowid
+
+        # Now, insert the card, tying it to the account
+        sql = "INSERT INTO card (id, userid) VALUES (:cardid, :userid)"
+        cursor = self.execute(sql, {'cardid': cardid, 'userid': userid})
+        if cursor.rowcount != 1:
+            return None
+
+        return userid
diff --git a/bemani/format/__init__.py b/bemani/format/__init__.py
new file mode 100644
index 0000000..d9d1dfe
--- /dev/null
+++ b/bemani/format/__init__.py
@@ -0,0 +1,5 @@
+from bemani.format.ifs import IFS
+from bemani.format.arc import ARC
+from bemani.format.twodx import TwoDX
+from bemani.format.iidxchart import IIDXChart
+from bemani.format.iidxmusicdb import IIDXMusicDB, IIDXSong
diff --git a/bemani/format/arc.py b/bemani/format/arc.py
new file mode 100644
index 0000000..5c64f1f
--- /dev/null
+++ b/bemani/format/arc.py
@@ -0,0 +1,53 @@
+import struct
+from typing import Dict, List, Tuple
+
+from bemani.protocol.lz77 import Lz77
+
+
+class ARC:
+    """
+    Class representing an `.arc` file. These are found in DDR Ace, and possibly
+    other games that use ESS. Given a serires of bytes, this will allow you to
+    query included filenames as well as read the contents of any file inside the
+    archive.
+    """
+
+    def __init__(self, data: bytes) -> None:
+        self.__files: Dict[str, Tuple[int, int, int]] = {}
+        self.__data = data
+        self.__parse_file(data)
+
+    def __parse_file(self, data: bytes) -> None:
+        # Check file header
+        if data[0:4] != bytes([0x20, 0x11, 0x75, 0x19]):
+            raise Exception('Unknown file format!')
+
+        # Grab header offsets
+        (_, numfiles, _) = struct.unpack('<III', data[4:16])
+
+        for fno in range(numfiles):
+            start = 16 + (16 * fno)
+            end = start + 16
+            (nameoffset, fileoffset, uncompressedsize, compressedsize) = struct.unpack('<IIII', data[start:end])
+            name = ""
+
+            while data[nameoffset] != 0:
+                name = name + data[nameoffset:(nameoffset + 1)].decode('ascii')
+                nameoffset = nameoffset + 1
+
+            self.__files[name] = (fileoffset, uncompressedsize, compressedsize)
+
+    @property
+    def filenames(self) -> List[str]:
+        return [f for f in self.__files]
+
+    def read_file(self, filename: str) -> bytes:
+        (fileoffset, uncompressedsize, compressedsize) = self.__files[filename]
+
+        if compressedsize == uncompressedsize:
+            # Just stored
+            return self.__data[fileoffset:(fileoffset + compressedsize)]
+        else:
+            # Compressed
+            lz77 = Lz77()
+            return lz77.decompress(self.__data[fileoffset:(fileoffset + compressedsize)])
diff --git a/bemani/format/ifs.py b/bemani/format/ifs.py
new file mode 100644
index 0000000..fe48405
--- /dev/null
+++ b/bemani/format/ifs.py
@@ -0,0 +1,183 @@
+import hashlib
+import io
+import os
+import struct
+from PIL import Image  # type: ignore
+from typing import Dict, List, Tuple, Optional
+
+from bemani.protocol.binary import BinaryEncoding
+from bemani.protocol.xml import XmlEncoding
+from bemani.protocol.lz77 import Lz77
+from bemani.protocol.node import Node
+
+
+class IFS:
+    """
+    Best-effort utility for decoding the `.ifs` file format. There are better tools out
+    there, but this was developed before their existence. This should work with most of
+    the games out there including non-rhythm games that use this format.
+    """
+
+    def __init__(self, data: bytes, decode_binxml: bool=False, decode_textures: bool=False) -> None:
+        self.__files: Dict[str, bytes] = {}
+        self.__texdata: Dict[str, Node] = {}
+        self.__mappings: Dict[str, str] = {}
+        self.__sizes: Dict[str, Tuple[int, int]] = {}
+        self.__decode_binxml = decode_binxml
+        self.__decode_textures = decode_textures
+        self.__parse_file(data)
+
+    def __fix_name(self, filename: str) -> str:
+        if filename[0] == '_' and filename[1].isdigit():
+            filename = filename[1:]
+        filename = filename.replace('_E', '.')
+        filename = filename.replace('__', '_')
+        return filename
+
+    def __parse_file(self, data: bytes) -> None:
+        # Grab the magic values and make sure this is an IFS
+        (signature, version, version_crc, pack_time, unpacked_header_size, data_index) = struct.unpack(
+            '>IHHIII',
+            data[0:20],
+        )
+        if signature != 0x6CAD8F89:
+            raise Exception('Invalid IFS file!')
+        if version ^ version_crc != 0xFFFF:
+            raise Exception('Corrupt version in IFS file!')
+
+        if version == 1:
+            # No header MD5
+            header_offset = 20
+        else:
+            # Make room for header MD5, at byte offset 20-36
+            header_offset = 36
+
+        # First, try as binary
+        benc = BinaryEncoding()
+        header = benc.decode(data[header_offset:data_index])
+
+        if header is None:
+            # Now, try as XML
+            xenc = XmlEncoding()
+            header = xenc.decode(
+                b'<?xml encoding="ascii"?>' +
+                data[header_offset:data_index].split(b'\0')[0]
+            )
+
+            if header is None:
+                raise Exception('Invalid IFS file!')
+
+        files: Dict[str, Tuple[int, int, int]] = {}
+
+        if header.name != 'imgfs':
+            raise Exception('Unknown IFS format!')
+
+        def get_children(parent: str, node: Node) -> None:
+            real_name = self.__fix_name(node.name)
+            if node.data_type == '3s32':
+                node_name = os.path.join(parent, real_name).replace('/imgfs/', '')
+                files[node_name] = (node.value[0] + data_index, node.value[1], node.value[2])
+            else:
+                for subchild in node.children:
+                    get_children(os.path.join(parent, "{}/".format(real_name)), subchild)
+
+        get_children("/", header)
+
+        for fn in files:
+            (start, size, pack_time) = files[fn]
+            filedata = data[start:(start + size)]
+            self.__files[fn] = filedata
+
+        if self.__decode_textures:
+            # We must fix up the name of the textures since we're decoding them
+            def fix_name(hashname: str) -> str:
+                path = os.path.dirname(hashname)
+                filename = os.path.basename(hashname)
+
+                texlist = self.__get_texlist_for_file(hashname)
+
+                if texlist is not None and texlist.name == 'texturelist':
+                    for child in texlist.children:
+                        if child.name != 'texture':
+                            continue
+
+                        textfmt = child.attribute('format')
+
+                        for subchild in child.children:
+                            if subchild.name != 'image':
+                                continue
+                            md5sum = hashlib.md5(subchild.attribute('name').encode(benc.encoding)).hexdigest()
+
+                            if md5sum == filename:
+                                if textfmt == "argb8888rev":
+                                    name = '{}.png'.format(subchild.attribute('name'))
+                                else:
+                                    name = subchild.attribute('name')
+                                newpath = os.path.join(path, name)
+
+                                rect = subchild.child_value('imgrect')
+                                if rect is not None:
+                                    self.__mappings[newpath] = textfmt
+                                    self.__sizes[newpath] = (
+                                        (rect[1] - rect[0]) // 2,
+                                        (rect[3] - rect[2]) // 2,
+                                    )
+
+                                return newpath
+
+                return hashname
+
+            self.__files = {fix_name(fn): self.__files[fn] for fn in self.__files}
+
+    @property
+    def filenames(self) -> List[str]:
+        return [f for f in self.__files]
+
+    def __get_texlist_for_file(self, filename: str) -> Optional[Node]:
+        texlist = os.path.join(os.path.dirname(filename), 'texturelist.xml')
+        if texlist != filename and texlist in self.__files:
+            if texlist not in self.__texdata and texlist in self.__files:
+                benc = BinaryEncoding()
+                self.__texdata[texlist] = benc.decode(self.__files[texlist])
+
+            return self.__texdata.get(texlist)
+        return None
+
+    def read_file(self, filename: str) -> bytes:
+        # If this is a texture folder, first we need to grab the texturelist.xml file
+        # to figure out if this is compressed or not.
+        decompress = False
+        texlist = self.__get_texlist_for_file(filename)
+        if texlist is not None and texlist.name == 'texturelist':
+            if texlist.attribute('compress') == 'avslz':
+                # We should decompress!
+                decompress = True
+
+        filedata = self.__files[filename]
+        if decompress:
+            uncompressed_size, compressed_size = struct.unpack('>II', filedata[0:8])
+            if len(filedata) == compressed_size + 8:
+                lz77 = Lz77()
+                filedata = lz77.decompress(filedata[8:])
+            else:
+                raise Exception('Unrecognized compression!')
+
+        if self.__decode_binxml and os.path.splitext(filename)[1] == '.xml':
+            benc = BinaryEncoding()
+            filexml = benc.decode(filedata)
+            if filexml is not None:
+                filedata = str(filexml).encode('utf-8')
+
+        if self.__decode_textures and filename in self.__mappings and filename in self.__sizes:
+            fmt = self.__mappings.get(filename)
+            wh = self.__sizes.get(filename)
+            if fmt == "argb8888rev":
+                if len(filedata) < (wh[0] * wh[1] * 4):
+                    left = (wh[0] * wh[1] * 4) - len(filedata)
+                    filedata = filedata + b'\x00' * left
+                img = Image.frombytes('RGBA', wh, filedata, 'raw', 'BGRA')
+                b = io.BytesIO()
+                img.save(b, format='PNG')
+                filedata = b.getvalue()
+
+        return filedata
diff --git a/bemani/format/iidxchart.py b/bemani/format/iidxchart.py
new file mode 100644
index 0000000..0d2d7f8
--- /dev/null
+++ b/bemani/format/iidxchart.py
@@ -0,0 +1,75 @@
+import struct
+from typing import List, Optional, Tuple
+
+
+class IIDXChart:
+    """
+    Class representing a IIDX chart. This is known to be iffy with charge notes
+    and hell charge notes, but I never investigated enough to fix it. If somebody
+    wants to dig in and make a patch that would be excellent. This currently only
+    allows fetching notecounts and bpm since this is necessary for calculating
+    clear ranks for IIDX.
+    """
+
+    CHART_POSITIONS = [1, 0, 2, 7, 6, 8]
+
+    def __init__(self, data: bytes) -> None:
+        self.__bpm_min: Optional[int] = None
+        self.__bpm_max: Optional[int] = None
+        self.__note_counts = [0, 0, 0, 0, 0, 0]
+        self.__parse_charts(data)
+
+    def __parse_header(self, data: bytes) -> List[Tuple[int, int]]:
+        header: List[Tuple[int, int]] = []
+        for i in range(12):
+            offset, length = struct.unpack('<II', data[(i * 8):((i + 1) * 8)])
+            header.append((offset, length))
+        return header
+
+    def __parse_charts(self, data: bytes) -> None:
+        header = self.__parse_header(data)
+
+        for chart in [0, 1, 2, 3, 4, 5]:
+            offset, length = header[self.CHART_POSITIONS[chart]]
+            chartdata = data[offset:(offset + length)]
+            position = 0
+
+            if length == 0:
+                # Some songs don't have all charts :(
+                continue
+
+            while True:
+                time, event, side, value = struct.unpack('<iBBH', chartdata[(position * 8):((position + 1) * 8)])
+                position += 1
+
+                if time == 0x7FFFFFFF:
+                    break
+
+                if event == 0 or event == 1:
+                    # Note!
+                    self.__note_counts[chart] += 1
+                    if value != 0:
+                        # Add one more for charge note lift
+                        self.__note_counts[chart] += 1
+
+                if event == 4:
+                    # BPM change
+                    if value > 1000:
+                        value = int(value / 100)
+
+                    if self.__bpm_min is None:
+                        self.__bpm_min = value
+                    else:
+                        self.__bpm_min = min(self.__bpm_min, value)
+                    if self.__bpm_max is None:
+                        self.__bpm_max = value
+                    else:
+                        self.__bpm_max = max(self.__bpm_max, value)
+
+    @property
+    def bpm(self) -> Tuple[int, int]:
+        return (self.__bpm_min, self.__bpm_max)
+
+    @property
+    def notecounts(self) -> List[int]:
+        return self.__note_counts
diff --git a/bemani/format/iidxmusicdb.py b/bemani/format/iidxmusicdb.py
new file mode 100644
index 0000000..380d693
--- /dev/null
+++ b/bemani/format/iidxmusicdb.py
@@ -0,0 +1,131 @@
+import copy
+import struct
+from typing import Dict, List, Tuple
+
+
+class IIDXSong:
+    def __init__(
+        self,
+        songid: int,
+        title: str,
+        english_title: str,
+        genre: str,
+        artist: str,
+        difficulties: List[int],
+        folder: int,
+    ) -> None:
+        """
+        Initialize a IIDX Song. Everything is self-explanatory except difficulties, which
+        is a list of integers representing the difficulty for SPN, SPH, SPA, DPN, DPH, DPA.
+        """
+        self.id = songid
+        self.title = title
+        self.english_title = english_title
+        self.genre = genre
+        self.artist = artist
+        self.difficulties = difficulties
+        self.folder = folder
+
+
+class IIDXMusicDB:
+
+    def __init__(self, data: bytes) -> None:
+        self.__songs: Dict[int, Tuple[IIDXSong, int]] = {}
+        self.__data = data
+        self.__parse_db(data)
+
+    def get_new_db(self) -> bytes:
+        # Write out a new music DB based on any possible changes to songs
+        data = copy.deepcopy(self.__data)
+
+        def format_string(string: str) -> bytes:
+            bdata = string.encode('shift-jis')
+            if len(bdata) < 64:
+                bdata = bdata + (b'\0' * (64 - len(bdata)))
+            return bdata
+
+        def copy_over(dst: bytes, src: bytes, base: int, offset: int) -> bytes:
+            return dst[:(base + offset)] + src + dst[(base + offset + len(src)):]
+
+        for mid in self.__songs:
+            song, offset = self.__songs[mid]
+            data = copy_over(data, format_string(song.title), offset, 0)
+            data = copy_over(data, format_string(song.english_title), offset, 64)
+            data = copy_over(data, format_string(song.genre), offset, 128)
+            data = copy_over(data, format_string(song.artist), offset, 192)
+            data = copy_over(data, bytes([song.folder]), offset, 280)
+            data = copy_over(data, bytes(song.difficulties), offset, 288)
+        return data
+
+    def __parse_db(self, data: bytes) -> None:
+        # Verify the signature
+        sig = struct.unpack_from(
+            "<4s",
+            data,
+            0,
+        )
+        # Offset and difference lookup (not sure this is always right)
+        if data[4] == 0x14:
+            offset = 0xa420
+            leap = 0x320
+        elif data[4] == 0x15:
+            offset = 0xabf0
+            leap = 0x320
+        elif data[4] == 0x16:
+            offset = 0xb3c0
+            leap = 0x340
+        elif data[4] == 0x17:
+            offset = 0xbb90
+            leap = 0x340
+        elif data[4] == 0x18:
+            offset = 0xc360
+            leap = 0x340
+
+        if sig[0] != b'IIDX':
+            raise Exception('Invalid signature \'{}\' found!'.format(sig[0]))
+
+        def parse_string(string: bytes) -> str:
+            for i in range(len(string)):
+                if string[i] == 0:
+                    string = string[:i]
+                    break
+
+            return string.decode('shift-jis')
+
+        # Load songs
+        while True:
+            try:
+                songdata = struct.unpack_from(
+                    "<64s64s64s64s24xB7xBBBBBB162xH",
+                    data,
+                    offset,
+                )
+            except struct.error:
+                # Out of input!
+                break
+
+            songoffset = offset
+            offset = offset + leap
+            song = IIDXSong(
+                songdata[11],
+                parse_string(songdata[0]),
+                parse_string(songdata[1]),
+                parse_string(songdata[2]),
+                parse_string(songdata[3]),
+                [songdata[5], songdata[6], songdata[7], songdata[8], songdata[9], songdata[10]],
+                songdata[4],
+            )
+            if song.artist == 'event_data' and song.genre == 'event_data':
+                continue
+            self.__songs[songdata[11]] = (song, songoffset)
+
+    @property
+    def songs(self) -> List[IIDXSong]:
+        return sorted([self.__songs[mid][0] for mid in self.__songs], key=lambda song: song.id)
+
+    @property
+    def songids(self) -> List[int]:
+        return sorted([mid for mid in self.__songs])
+
+    def song(self, songid: int) -> IIDXSong:
+        return self.__songs[songid][0]
diff --git a/bemani/format/twodx.py b/bemani/format/twodx.py
new file mode 100644
index 0000000..2acfc99
--- /dev/null
+++ b/bemani/format/twodx.py
@@ -0,0 +1,100 @@
+import struct
+from typing import Dict, List, Optional
+
+
+class TwoDX:
+    """
+    Packer/unpacker class for a bytestream representing a `.2dx` file.
+    """
+
+    def __init__(self, data: Optional[bytes] = None) -> None:
+        self.__name: Optional[str] = None
+        self.__files: Dict[str, bytes] = {}
+        if data is not None:
+            self.__parse_file(data)
+
+    def __parse_file(self, data: bytes) -> None:
+        # Parse file header
+        (name, headerSize, numfiles) = struct.unpack('<16sII', data[0:24])
+        self.__name = name.split(b'\x00')[0].decode('ascii')
+
+        if headerSize != (72 + (4 * numfiles)):
+            raise Exception('Unrecognized 2dx file header!')
+
+        fileoffsets = struct.unpack('<' + ''.join(['I' for _ in range(numfiles)]), data[72:(72 + (4 * numfiles))])
+        fileno = 1
+
+        for offset in fileoffsets:
+            (magic, headerSize, wavSize, _, track, _, attenuation, loop) = struct.unpack(
+                '<4sIIhhhhi',
+                data[offset:(offset + 24)],
+            )
+
+            if magic != b'2DX9':
+                raise Exception('Unrecognized entry in file!')
+            if headerSize != 24:
+                raise Exception('Unrecognized subheader in file!')
+
+            wavOffset = offset + headerSize
+            wavData = data[wavOffset:(wavOffset + wavSize)]
+
+            self.__files['{}_{}.wav'.format(self.__name, fileno)] = wavData
+            fileno = fileno + 1
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    def set_name(self, name: str) -> None:
+        if len(name) <= 16:
+            self.__name = name
+        else:
+            raise Exception('Name of archive too long!')
+
+    @property
+    def filenames(self) -> List[str]:
+        return [f for f in self.__files]
+
+    def read_file(self, filename: str) -> bytes:
+        return self.__files[filename]
+
+    def write_file(self, filename: str, data: bytes) -> None:
+        self.__files[filename] = data
+
+    def get_new_data(self) -> bytes:
+        if not self.__files:
+            raise Exception('No files to write!')
+        if not self.__name:
+            raise Exception('2dx archive name not set!')
+
+        name = self.__name.encode('ascii')
+        while len(name) < 16:
+            name = name + b'\x00'
+        filedata = [self.__files[x] for x in self.__files]
+
+        # Header length is also the base offset for the first file
+        baseoffset = 72 + (4 * len(filedata))
+        data = [struct.pack('<16sII', name, baseoffset, len(filedata)) + (b'\x00' * 48)]
+
+        # Calculate offset this will go to
+        for bytedata in filedata:
+            # Add where this file will go, then calculate the length
+            data.append(struct.pack('<I', baseoffset))
+            baseoffset = baseoffset + 24 + len(bytedata)
+
+        # Now output the headers and files
+        for bytedata in filedata:
+            data.append(struct.pack(
+                '<4sIIhhhhi',
+                b'2DX9',
+                24,
+                len(bytedata),
+                0x3231,
+                -1,
+                64,
+                1,
+                0,
+            ))
+            data.append(bytedata)
+
+        return b''.join(data)
diff --git a/bemani/frontend/__init__.py b/bemani/frontend/__init__.py
new file mode 100644
index 0000000..1135c7a
--- /dev/null
+++ b/bemani/frontend/__init__.py
@@ -0,0 +1 @@
+from bemani.frontend.app import app, config, loginrequired, loginprohibited
diff --git a/bemani/frontend/account/__init__.py b/bemani/frontend/account/__init__.py
new file mode 100644
index 0000000..de65504
--- /dev/null
+++ b/bemani/frontend/account/__init__.py
@@ -0,0 +1 @@
+from bemani.frontend.account.account import account_pages
diff --git a/bemani/frontend/account/account.py b/bemani/frontend/account/account.py
new file mode 100644
index 0000000..21c39b3
--- /dev/null
+++ b/bemani/frontend/account/account.py
@@ -0,0 +1,326 @@
+import datetime
+from typing import Dict, Any
+from flask import Blueprint, request, redirect, Response, url_for, make_response, render_template, g  # type: ignore
+
+from bemani.common import CardCipher, CardCipherException, AESCipher
+from bemani.frontend.app import loginrequired, loginprohibited, success, error, jsonify, valid_email, valid_username, valid_pin, render_react
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+account_pages = Blueprint(
+    'account_pages',
+    __name__,
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@account_pages.route('/login', methods=['POST'])
+@loginprohibited
+def login() -> Response:
+    username = request.form['username']
+    password = request.form['password']
+
+    userid = g.data.local.user.from_username(username)
+    if userid is None:
+        error('Unrecognized username or password!')
+        return Response(render_template('account/login.html', **{'title': 'Log In', 'show_navigation': False, 'username': username}))
+
+    if g.data.local.user.validate_password(userid, password):
+        aes = AESCipher(g.config['secret_key'])
+        sessionID = g.data.local.user.create_session(userid, expiration=90 * 86400)
+        response = make_response(redirect(url_for('home_pages.viewhome')))
+        response.set_cookie(
+            'SessionID',
+            aes.encrypt(sessionID),
+            expires=datetime.datetime.now() + datetime.timedelta(days=90)
+        )
+        return response
+    else:
+        error('Unrecognized username or password!')
+        return Response(render_template('account/login.html', **{'title': 'Log In', 'show_navigation': False, 'username': username}))
+
+
+@account_pages.route('/login')
+@loginprohibited
+def viewlogin() -> Response:
+    return Response(render_template('account/login.html', **{'title': 'Log In', 'show_navigation': False}))
+
+
+def register_display(card_number: str, username: str, email: str) -> Response:
+    return Response(render_template(
+        'account/register.html',
+        **{
+            'title': 'Register New Account',
+            'show_navigation': False,
+            'card_number': card_number,
+            'username': username,
+            'email': email,
+        },
+    ))
+
+
+@account_pages.route('/register', methods=['POST'])
+@loginprohibited
+def register() -> Response:
+    card_number = request.form['card_number']
+    pin = request.form['pin']
+    username = request.form['username']
+    email = request.form['email']
+    password1 = request.form['password1']
+    password2 = request.form['password2']
+
+    # First, try to convert the card to a valid E004 ID
+    try:
+        cardid = CardCipher.decode(card_number)
+    except CardCipherException:
+        error('Invalid card number!')
+        return register_display(card_number, username, email)
+
+    # Now, see if this card ID exists already
+    userid = g.data.local.user.from_cardid(cardid)
+    if userid is None:
+        error('This card has not been used on the network yet!')
+        return register_display(card_number, username, email)
+
+    # Now, make sure this user doesn't already have an account
+    user = g.data.local.user.get_user(userid)
+    if user.username is not None or user.email is not None:
+        error('This card is already in use!')
+        return register_display(card_number, username, email)
+
+    # Now, see if the pin is correct
+    if not g.data.local.user.validate_pin(userid, pin):
+        error('The entered PIN does not match the PIN on the card!')
+        return register_display(card_number, username, email)
+
+    # Now, see if the username is valid
+    if not valid_username(username):
+        error('Invalid username!')
+        return register_display(card_number, username, email)
+
+    # Now, check whether the username is already in use
+    if g.data.local.user.from_username(username) is not None:
+        error('The chosen username is already in use!')
+        return register_display(card_number, username, email)
+
+    # Now, see if the email address is valid
+    if not valid_email(email):
+        error('Invalid email address!')
+        return register_display(card_number, username, email)
+
+    # Now, make sure that the passwords match
+    if password1 != password2:
+        error('Passwords do not match each other!')
+        return register_display(card_number, username, email)
+
+    # Now, make sure passwords are long enough
+    if len(password1) < 6:
+        error('Password is not long enough!')
+        return register_display(card_number, username, email)
+
+    # Now, create the account.
+    user.username = username
+    user.email = email
+    g.data.local.user.put_user(user)
+    g.data.local.user.update_password(userid, password1)
+
+    # Now, log them into that created account!
+    aes = AESCipher(g.config['secret_key'])
+    sessionID = g.data.local.user.create_session(userid)
+    success('Successfully registered account!')
+    response = make_response(redirect(url_for('home_pages.viewhome')))
+    response.set_cookie('SessionID', aes.encrypt(sessionID))
+    return response
+
+
+@account_pages.route('/register')
+@loginprohibited
+def viewregister() -> Response:
+    return Response(render_template('account/register.html', **{'title': 'Register New Account', 'show_navigation': False}))
+
+
+@account_pages.route('/logout')
+@loginrequired
+def logout() -> Response:
+    g.data.local.user.destroy_session(g.sessionID)
+    response = make_response(redirect(url_for('account_pages.viewlogin')))
+    response.set_cookie('SessionID', '', expires=0)
+    success('Successfully logged out!')
+    return response
+
+
+@account_pages.route('/account')
+@loginrequired
+def viewaccount() -> Response:
+    user = g.data.local.user.get_user(g.userID)
+    return render_react(
+        'Account Management',
+        'account/account.react.js',
+        {
+            'email': user.email,
+            'username': user.username,
+        },
+        {
+            'updateemail': url_for('account_pages.updateemail'),
+            'updatepin': url_for('account_pages.updatepin'),
+            'updatepassword': url_for('account_pages.updatepassword'),
+        },
+    )
+
+
+@account_pages.route('/account/cards')
+@loginrequired
+def viewcards() -> Response:
+    cards = [CardCipher.encode(card) for card in g.data.local.user.get_cards(g.userID)]
+    return render_react(
+        'Card Management',
+        'account/cards.react.js',
+        {
+            'cards': cards,
+        },
+        {
+            'addcard': url_for('account_pages.addcard'),
+            'removecard': url_for('account_pages.removecard'),
+            'listcards': url_for('account_pages.listcards'),
+        },
+    )
+
+
+@account_pages.route('/account/cards/list')
+@jsonify
+@loginrequired
+def listcards() -> Dict[str, Any]:
+    # Return new card list
+    cards = [CardCipher.encode(card) for card in g.data.local.user.get_cards(g.userID)]
+    return {
+        'cards': cards,
+    }
+
+
+@account_pages.route('/account/cards/add', methods=['POST'])
+@jsonify
+@loginrequired
+def addcard() -> Dict[str, Any]:
+    # Grab card, convert it
+    card = request.get_json()['card']
+    try:
+        cardid = CardCipher.decode(card)
+    except CardCipherException:
+        raise Exception('Invalid card number!')
+
+    # See if it is already claimed
+    userid = g.data.local.user.from_cardid(cardid)
+    if userid is not None:
+        raise Exception('This card is already in use!')
+
+    # Add it to this user's account
+    g.data.local.user.add_card(g.userID, cardid)
+
+    # Return new card list
+    cards = [CardCipher.encode(card) for card in g.data.local.user.get_cards(g.userID)]
+    return {
+        'cards': cards,
+    }
+
+
+@account_pages.route('/account/cards/remove', methods=['POST'])
+@jsonify
+@loginrequired
+def removecard() -> Dict[str, Any]:
+    # Grab card, convert it
+    card = request.get_json()['card']
+    try:
+        cardid = CardCipher.decode(card)
+    except CardCipherException:
+        raise Exception('Invalid card number!')
+
+    # Make sure it is our card
+    userid = g.data.local.user.from_cardid(cardid)
+    if userid != g.userID:
+        raise Exception('This card is not yours to delete!')
+
+    # Remove it from this user's account
+    g.data.local.user.destroy_card(g.userID, cardid)
+
+    # Return new card list
+    cards = [CardCipher.encode(card) for card in g.data.local.user.get_cards(g.userID)]
+    return {
+        'cards': cards,
+    }
+
+
+@account_pages.route('/account/email/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updateemail() -> Dict[str, Any]:
+    email = request.get_json()['email']
+    password = request.get_json()['password']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Make sure current password matches
+    if not g.data.local.user.validate_password(g.userID, password):
+        raise Exception('Current password is not correct!')
+
+    if not valid_email(email):
+        raise Exception('Invalid email address!')
+
+    # Update and save
+    user.email = email
+    g.data.local.user.put_user(user)
+
+    # Return updated email
+    return {
+        'email': email,
+    }
+
+
+@account_pages.route('/account/pin/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatepin() -> Dict[str, Any]:
+    pin = request.get_json()['pin']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    if not valid_pin(pin, 'card'):
+        raise Exception('Invalid PIN, must be exactly 4 digits!')
+
+    # Update and save
+    g.data.local.user.update_pin(g.userID, pin)
+
+    # Return nothing
+    return {}
+
+
+@account_pages.route('/account/password/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatepassword() -> Dict[str, Any]:
+    old = request.get_json()['old']
+    new1 = request.get_json()['new1']
+    new2 = request.get_json()['new2']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Make sure current password matches
+    if not g.data.local.user.validate_password(g.userID, old):
+        raise Exception('Current password is not correct!')
+
+    # Now, make sure that the passwords match
+    if new1 != new2:
+        raise Exception('Passwords do not match each other!')
+
+    # Now, make sure passwords are long enough
+    if len(new1) < 6:
+        raise Exception('Password is not long enough!')
+
+    # Update and save
+    g.data.local.user.update_password(g.userID, new1)
+
+    # Return nothing
+    return {}
diff --git a/bemani/frontend/admin/__init__.py b/bemani/frontend/admin/__init__.py
new file mode 100644
index 0000000..fb44c55
--- /dev/null
+++ b/bemani/frontend/admin/__init__.py
@@ -0,0 +1 @@
+from bemani.frontend.admin.admin import admin_pages
diff --git a/bemani/frontend/admin/admin.py b/bemani/frontend/admin/admin.py
new file mode 100644
index 0000000..c8972a5
--- /dev/null
+++ b/bemani/frontend/admin/admin.py
@@ -0,0 +1,1039 @@
+import random
+from typing import Dict, Tuple, Any, Optional
+from flask import Blueprint, request, Response, render_template, url_for, g  # type: ignore
+
+from bemani.backend.base import Base
+from bemani.common import CardCipher, CardCipherException, GameConstants
+from bemani.data import Arcade, Machine, User, News, Event, Server, Client
+from bemani.data.api.client import APIClient, NotAuthorizedAPIException, APIException
+from bemani.frontend.app import adminrequired, jsonify, valid_email, valid_username, valid_pin, render_react
+from bemani.frontend.iidx.iidx import IIDXFrontend
+from bemani.frontend.jubeat.jubeat import JubeatFrontend
+from bemani.frontend.popn.popn import PopnMusicFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+admin_pages = Blueprint(
+    'admin_pages',
+    __name__,
+    url_prefix='/admin',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+def format_arcade(arcade: Arcade) -> Dict[str, Any]:
+    owners = []
+    for owner in arcade.owners:
+        user = g.data.local.user.get_user(owner)
+        if user is not None:
+            owners.append(user.username)
+    return {
+        'id': arcade.id,
+        'name': arcade.name,
+        'description': arcade.description,
+        'paseli_enabled': arcade.data.get_bool('paseli_enabled'),
+        'paseli_infinite': arcade.data.get_bool('paseli_infinite'),
+        'mask_services_url': arcade.data.get_bool('mask_services_url'),
+        'owners': owners,
+    }
+
+
+def format_machine(machine: Machine) -> Dict[str, Any]:
+    return {
+        'id': machine.id,
+        'pcbid': machine.pcbid,
+        'name': machine.name,
+        'description': machine.description,
+        'arcade': machine.arcade,
+        'port': machine.port,
+        'game': machine.game or 'any',
+        'version': machine.version,
+    }
+
+
+def format_card(card: Tuple[str, Optional[int]]) -> Dict[str, Any]:
+    owner = None
+    if card[1] is not None:
+        user = g.data.local.user.get_user(card[1])
+        if user is not None:
+            owner = user.username
+    try:
+        return {
+            'number': CardCipher.encode(card[0]),
+            'owner': owner,
+            'id': card[1],
+        }
+    except CardCipherException:
+        return {
+            'number': '????????????????',
+            'owner': owner,
+            'id': card[1],
+        }
+
+
+def format_user(user: User) -> Dict[str, Any]:
+    return {
+        'id': user.id,
+        'username': user.username,
+        'email': user.email,
+        'admin': user.admin,
+    }
+
+
+def format_news(news: News) -> Dict[str, Any]:
+    return {
+        'id': news.id,
+        'timestamp': news.timestamp,
+        'title': news.title,
+        'body': news.body,
+    }
+
+
+def format_event(event: Event) -> Dict[str, Any]:
+    return {
+        'id': event.id,
+        'timestamp': event.timestamp,
+        'userid': event.userid,
+        'arcadeid': event.arcadeid,
+        'type': event.type,
+        'data': event.data,
+    }
+
+
+def format_client(client: Client) -> Dict[str, Any]:
+    return {
+        'id': client.id,
+        'name': client.name,
+        'token': client.token,
+    }
+
+
+def format_server(server: Server) -> Dict[str, Any]:
+    return {
+        'id': server.id,
+        'uri': server.uri,
+        'token': server.token,
+        'allow_stats': server.allow_stats,
+        'allow_scores': server.allow_scores,
+    }
+
+
+@admin_pages.route('/')
+@adminrequired
+def viewsettings() -> Response:
+    return Response(render_template(
+        'admin/settings.html',
+        **{
+            'title': 'Network Settings',
+            'config': g.config,
+        },
+    ))
+
+
+@admin_pages.route('/events')
+@adminrequired
+def viewevents() -> Response:
+    iidx = IIDXFrontend(g.data, g.config, g.cache)
+    jubeat = JubeatFrontend(g.data, g.config, g.cache)
+    pnm = PopnMusicFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'Events',
+        'admin/events.react.js',
+        {
+            'events': [format_event(event) for event in g.data.local.network.get_events(limit=100)],
+            'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
+            'arcades': {arcade.id: arcade.name for arcade in g.data.local.machine.get_all_arcades()},
+            'iidxsongs': iidx.get_all_songs(),
+            'jubeatsongs': jubeat.get_all_songs(),
+            'pnmsongs': pnm.get_all_songs(),
+            'iidxversions': {version: name for (game, version, name) in iidx.all_games()},
+            'jubeatversions': {version: name for (game, version, name) in jubeat.all_games()},
+            'pnmversions': {version: name for (game, version, name) in pnm.all_games()},
+        },
+        {
+            'refresh': url_for('admin_pages.listevents', since=-1),
+            'backfill': url_for('admin_pages.backfillevents', until=-1),
+            'viewuser': url_for('admin_pages.viewuser', userid=-1),
+            'jubeatsong': url_for('jubeat_pages.viewtopscores', musicid=-1) if g.config.get('support', {}).get(GameConstants.JUBEAT, False) else None,
+            'iidxsong': url_for('iidx_pages.viewtopscores', musicid=-1) if g.config.get('support', {}).get(GameConstants.IIDX, False) else None,
+            'pnmsong': url_for('popn_pages.viewtopscores', musicid=-1) if g.config.get('support', {}).get(GameConstants.POPN_MUSIC, False) else None,
+        },
+    )
+
+
+@admin_pages.route('/events/backfill/<int:until>')
+@jsonify
+@adminrequired
+def backfillevents(until: int) -> Dict[str, Any]:
+    return {
+        'events': [format_event(event) for event in g.data.local.network.get_events(until_id=until, limit=1000)],
+    }
+
+
+@admin_pages.route('/events/list/<int:since>')
+@jsonify
+@adminrequired
+def listevents(since: int) -> Dict[str, Any]:
+    return {
+        'events': [format_event(event) for event in g.data.local.network.get_events(since_id=since)],
+        'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
+        'arcades': {arcade.id: arcade.name for arcade in g.data.local.machine.get_all_arcades()},
+    }
+
+
+@admin_pages.route('/api')
+@adminrequired
+def viewapi() -> Response:
+    return render_react(
+        'Data API',
+        'admin/api.react.js',
+        {
+            'clients': [format_client(client) for client in g.data.local.api.get_all_clients()],
+            'servers': [format_server(server) for server in g.data.local.api.get_all_servers()],
+        },
+        {
+            'addclient': url_for('admin_pages.addclient'),
+            'updateclient': url_for('admin_pages.updateclient'),
+            'removeclient': url_for('admin_pages.removeclient'),
+            'addserver': url_for('admin_pages.addserver'),
+            'updateserver': url_for('admin_pages.updateserver'),
+            'removeserver': url_for('admin_pages.removeserver'),
+            'queryserver': url_for('admin_pages.queryserver', serverid=-1),
+        },
+    )
+
+
+@admin_pages.route('/arcades')
+@adminrequired
+def viewarcades() -> Response:
+    return render_react(
+        'Arcades',
+        'admin/arcades.react.js',
+        {
+            'arcades': [format_arcade(arcade) for arcade in g.data.local.machine.get_all_arcades()],
+            'usernames': g.data.local.user.get_all_usernames(),
+            'paseli_enabled': g.config['paseli']['enabled'],
+            'paseli_infinite': g.config['paseli']['infinite'],
+            'mask_services_url': False,
+        },
+        {
+            'addarcade': url_for('admin_pages.addarcade'),
+            'updatearcade': url_for('admin_pages.updatearcade'),
+            'removearcade': url_for('admin_pages.removearcade'),
+        },
+    )
+
+
+@admin_pages.route('/machines')
+@adminrequired
+def viewmachines() -> Response:
+    games: Dict[str, Dict[int, str]] = {}
+    for (game, version, name) in Base.all_games():
+        if game not in games:
+            games[game] = {}
+        games[game][version] = name
+
+    return render_react(
+        'Machines',
+        'admin/machines.react.js',
+        {
+            'machines': [format_machine(machine) for machine in g.data.local.machine.get_all_machines()],
+            'arcades': {arcade.id: arcade.name for arcade in g.data.local.machine.get_all_arcades()},
+            'series': {
+                GameConstants.BISHI_BASHI: 'BishiBashi',
+                GameConstants.DDR: 'DDR',
+                GameConstants.IIDX: 'IIDX',
+                GameConstants.JUBEAT: 'Jubeat',
+                GameConstants.MUSECA: 'MÚSECA',
+                GameConstants.POPN_MUSIC: 'Pop\'n Music',
+                GameConstants.REFLEC_BEAT: 'Reflec Beat',
+                GameConstants.SDVX: 'SDVX',
+            },
+            'games': games,
+            'enforcing': g.config['server']['enforce_pcbid'],
+        },
+        {
+            'generatepcbid': url_for('admin_pages.generatepcbid'),
+            'addpcbid': url_for('admin_pages.addpcbid'),
+            'updatepcbid': url_for('admin_pages.updatepcbid'),
+            'removepcbid': url_for('admin_pages.removepcbid'),
+        },
+    )
+
+
+@admin_pages.route('/cards')
+@adminrequired
+def viewcards() -> Response:
+    return render_react(
+        'Cards',
+        'admin/cards.react.js',
+        {
+            'cards': [format_card(card) for card in g.data.local.user.get_all_cards()],
+            'usernames': g.data.local.user.get_all_usernames(),
+        },
+        {
+            'addcard': url_for('admin_pages.addcard'),
+            'removecard': url_for('admin_pages.removecard'),
+            'viewuser': url_for('admin_pages.viewuser', userid=-1),
+        },
+    )
+
+
+@admin_pages.route('/users')
+@adminrequired
+def viewusers() -> Response:
+    return render_react(
+        'Users',
+        'admin/users.react.js',
+        {
+            'users': [format_user(user) for user in g.data.local.user.get_all_users()],
+        },
+        {
+            'searchusers': url_for('admin_pages.searchusers'),
+            'viewuser': url_for('admin_pages.viewuser', userid=-1),
+        },
+    )
+
+
+@admin_pages.route('/news')
+@adminrequired
+def viewnews() -> Response:
+    return render_react(
+        'News',
+        'admin/news.react.js',
+        {
+            'news': [format_news(news) for news in g.data.local.network.get_all_news()],
+        },
+        {
+            'removenews': url_for('admin_pages.removenews'),
+            'addnews': url_for('admin_pages.addnews'),
+            'updatenews': url_for('admin_pages.updatenews'),
+        },
+    )
+
+
+@admin_pages.route('/users/<int:userid>')
+@adminrequired
+def viewuser(userid: int) -> Response:
+    user = g.data.local.user.get_user(userid)
+
+    def __format_card(card: str) -> str:
+        try:
+            return CardCipher.encode(card)
+        except CardCipherException:
+            return '????????????????'
+
+    cards = [__format_card(card) for card in g.data.local.user.get_cards(userid)]
+    arcades = g.data.local.machine.get_all_arcades()
+    return render_react(
+        'User',
+        'admin/user.react.js',
+        {
+            'user': {
+                'email': user.email,
+                'username': user.username,
+            },
+            'cards': cards,
+            'arcades': {arcade.id: arcade.name for arcade in arcades},
+            'balances': {arcade.id: g.data.local.user.get_balance(userid, arcade.id) for arcade in arcades},
+            'events': [format_event(event) for event in g.data.local.network.get_events(userid=userid, event='paseli_transaction')],
+        },
+        {
+            'refresh': url_for('admin_pages.listuser', userid=userid),
+            'removeusercard': url_for('admin_pages.removeusercard', userid=userid),
+            'addusercard': url_for('admin_pages.addusercard', userid=userid),
+            'updatebalance': url_for('admin_pages.updatebalance', userid=userid),
+            'updateusername': url_for('admin_pages.updateusername', userid=userid),
+            'updateemail': url_for('admin_pages.updateemail', userid=userid),
+            'updatepin': url_for('admin_pages.updatepin', userid=userid),
+            'updatepassword': url_for('admin_pages.updatepassword', userid=userid),
+        },
+    )
+
+
+@admin_pages.route('/users/<int:userid>/list')
+@jsonify
+@adminrequired
+def listuser(userid: int) -> Dict[str, Any]:
+
+    def __format_card(card: str) -> str:
+        try:
+            return CardCipher.encode(card)
+        except CardCipherException:
+            return '????????????????'
+
+    cards = [__format_card(card) for card in g.data.local.user.get_cards(userid)]
+    arcades = g.data.local.machine.get_all_arcades()
+    return {
+        'cards': cards,
+        'arcades': {arcade.id: arcade.name for arcade in arcades},
+        'balances': {arcade.id: g.data.local.user.get_balance(userid, arcade.id) for arcade in arcades},
+        'events': [format_event(event) for event in g.data.local.network.get_events(userid=userid, event='paseli_transaction')],
+    }
+
+
+@admin_pages.route('/arcades/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updatearcade() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    new_values = request.get_json()['arcade']
+    arcade = g.data.local.machine.get_arcade(new_values['id'])
+    if arcade is None:
+        raise Exception('Unable to find arcade to update!')
+
+    arcade.name = new_values['name']
+    arcade.description = new_values['description']
+    arcade.data.replace_bool('paseli_enabled', new_values['paseli_enabled'])
+    arcade.data.replace_bool('paseli_infinite', new_values['paseli_infinite'])
+    arcade.data.replace_bool('mask_services_url', new_values['mask_services_url'])
+    owners = []
+    for owner in new_values['owners']:
+        ownerid = g.data.local.user.from_username(owner)
+        if ownerid is not None:
+            owners.append(ownerid)
+    owners = list(set(owners))
+    arcade.owners = owners
+    g.data.local.machine.put_arcade(arcade)
+
+    # Just return all arcades for ease of updating
+    return {
+        'arcades': [format_arcade(arcade) for arcade in g.data.local.machine.get_all_arcades()],
+    }
+
+
+@admin_pages.route('/arcades/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addarcade() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    new_values = request.get_json()['arcade']
+
+    if len(new_values['name']) == 0:
+        raise Exception('Please name your new arcade!')
+    if len(new_values['description']) == 0:
+        raise Exception('Please describe your new arcade!')
+    owners = []
+    for owner in new_values['owners']:
+        ownerid = g.data.local.user.from_username(owner)
+        if ownerid is not None:
+            owners.append(ownerid)
+    owners = list(set(owners))
+
+    g.data.local.machine.create_arcade(
+        new_values['name'],
+        new_values['description'],
+        {
+            'paseli_enabled': new_values['paseli_enabled'],
+            'paseli_infinite': new_values['paseli_infinite'],
+            'mask_services_url': new_values['mask_services_url'],
+        },
+        owners,
+    )
+
+    # Just return all arcades for ease of updating
+    return {
+        'arcades': [format_arcade(arcade) for arcade in g.data.local.machine.get_all_arcades()],
+    }
+
+
+@admin_pages.route('/arcades/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removearcade() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    arcadeid = request.get_json()['arcadeid']
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if arcade is None:
+        raise Exception('Unable to find arcade to delete!')
+    g.data.local.machine.destroy_arcade(arcadeid)
+
+    # Just return all arcades for ease of updating
+    return {
+        'arcades': [format_arcade(arcade) for arcade in g.data.local.machine.get_all_arcades()],
+    }
+
+
+@admin_pages.route('/clients/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updateclient() -> Dict[str, Any]:
+    # Attempt to look this client up
+    new_values = request.get_json()['client']
+    client = g.data.local.api.get_client(new_values['id'])
+    if client is None:
+        raise Exception('Unable to find client to update!')
+
+    if len(new_values['name']) == 0:
+        raise Exception('Client names must be at least one character long!')
+
+    client.name = new_values['name']
+    g.data.local.api.put_client(client)
+
+    # Just return all clients for ease of updating
+    return {
+        'clients': [format_client(client) for client in g.data.local.api.get_all_clients()],
+    }
+
+
+@admin_pages.route('/clients/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addclient() -> Dict[str, Any]:
+    # Attempt to look this client up
+    new_values = request.get_json()['client']
+
+    if len(new_values['name']) == 0:
+        raise Exception('Please name your new client!')
+
+    g.data.local.api.create_client(
+        new_values['name'],
+    )
+
+    # Just return all clientss for ease of updating
+    return {
+        'clients': [format_client(client) for client in g.data.local.api.get_all_clients()],
+    }
+
+
+@admin_pages.route('/clients/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removeclient() -> Dict[str, Any]:
+    # Attempt to look this client up
+    clientid = request.get_json()['clientid']
+    client = g.data.local.api.get_client(clientid)
+    if client is None:
+        raise Exception('Unable to find client to delete!')
+    g.data.local.api.destroy_client(clientid)
+
+    # Just return all clients for ease of updating
+    return {
+        'clients': [format_client(client) for client in g.data.local.api.get_all_clients()],
+    }
+
+
+@admin_pages.route('/server/<int:serverid>/info')
+@jsonify
+@adminrequired
+def queryserver(serverid: int) -> Dict[str, Any]:
+    # Attempt to look this server up
+    server = g.data.local.api.get_server(serverid)
+    if server is None:
+        raise Exception('Unable to find server to query!')
+
+    client = APIClient(server.uri, server.token, False, False)
+    try:
+        serverinfo = client.get_server_info()
+        info = {
+            'name': serverinfo['name'],
+            'email': serverinfo['email'],
+        }
+        info['status'] = 'ok' if APIClient.API_VERSION in serverinfo['versions'] else 'badversion'
+    except NotAuthorizedAPIException:
+        info = {
+            'name': 'unknown',
+            'email': 'unknown',
+            'status': 'badauth',
+        }
+    except APIException:
+        info = {
+            'name': 'unknown',
+            'email': 'unknown',
+            'status': 'error',
+        }
+
+    return info
+
+
+@admin_pages.route('/servers/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updateserver() -> Dict[str, Any]:
+    # Attempt to look this server up
+    new_values = request.get_json()['server']
+    server = g.data.local.api.get_server(new_values['id'])
+    if server is None:
+        raise Exception('Unable to find server to update!')
+
+    if len(new_values['uri']) == 0:
+        raise Exception('Please provide a valid connection URI for this server!')
+    if len(new_values['token']) == 0 or len(new_values['token']) > 64:
+        raise Exception('Please provide a valid connection token for this server!')
+
+    server.uri = new_values['uri']
+    server.token = new_values['token']
+    server.allow_stats = new_values['allow_stats']
+    server.allow_scores = new_values['allow_scores']
+    g.data.local.api.put_server(server)
+
+    # Just return all servers for ease of updating
+    return {
+        'servers': [format_server(server) for server in g.data.local.api.get_all_servers()],
+    }
+
+
+@admin_pages.route('/servers/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addserver() -> Dict[str, Any]:
+    # Attempt to look this server up
+    new_values = request.get_json()['server']
+
+    if len(new_values['uri']) == 0:
+        raise Exception('Please provide a connection URI for the new server!')
+    if len(new_values['token']) == 0 or len(new_values['token']) > 64:
+        raise Exception('Please provide a valid connection token for the new server!')
+
+    g.data.local.api.create_server(
+        new_values['uri'],
+        new_values['token'],
+    )
+
+    # Just return all serverss for ease of updating
+    return {
+        'servers': [format_server(server) for server in g.data.local.api.get_all_servers()],
+    }
+
+
+@admin_pages.route('/servers/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removeserver() -> Dict[str, Any]:
+    # Attempt to look this server up
+    serverid = request.get_json()['serverid']
+    server = g.data.local.api.get_server(serverid)
+    if server is None:
+        raise Exception('Unable to find server to delete!')
+    g.data.local.api.destroy_server(serverid)
+
+    # Just return all servers for ease of updating
+    return {
+        'servers': [format_server(server) for server in g.data.local.api.get_all_servers()],
+    }
+
+
+@admin_pages.route('/machines/generate', methods=['POST'])
+@jsonify
+@adminrequired
+def generatepcbid() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    new_pcbid = request.get_json()['machine']
+    if new_pcbid['arcade'] is not None:
+        arcade = g.data.local.machine.get_arcade(new_pcbid['arcade'])
+        if arcade is None:
+            raise Exception('Unable to find arcade to link PCBID to!')
+
+    # Will be set by the game on boot.
+    name = 'なし'
+    pcbid = None
+    while pcbid is None:
+        # Generate a new PCBID, check for uniqueness
+        potential_pcbid = "01201000000000" + "".join([random.choice("0123456789ABCDEF") for _ in range(6)])
+        if g.data.local.machine.get_machine(potential_pcbid) is None:
+            pcbid = potential_pcbid
+
+    g.data.local.machine.create_machine(pcbid, name, new_pcbid['description'], new_pcbid['arcade'])
+
+    # Just return all machines for ease of updating
+    return {
+        'machines': [format_machine(machine) for machine in g.data.local.machine.get_all_machines()],
+    }
+
+
+@admin_pages.route('/machines/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addpcbid() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    new_pcbid = request.get_json()['machine']
+    if new_pcbid['arcade'] is not None:
+        arcade = g.data.local.machine.get_arcade(new_pcbid['arcade'])
+        if arcade is None:
+            raise Exception('Unable to find arcade to link PCBID to!')
+
+    # Verify that the PCBID is valid
+    potential_pcbid = "".join([c for c in new_pcbid['pcbid'].upper() if c in "0123456789ABCDEF"])
+    if len(potential_pcbid) != len(new_pcbid['pcbid']):
+        raise Exception("Invalid characters in PCBID!")
+    if len(potential_pcbid) != 20:
+        raise Exception("PCBID has invalid length!")
+
+    if g.data.local.machine.get_machine(potential_pcbid) is not None:
+        raise Exception('PCBID already exists!')
+
+    # Will be set by the game on boot.
+    name = 'なし'
+    g.data.local.machine.create_machine(potential_pcbid, name, new_pcbid['description'], new_pcbid['arcade'])
+
+    # Just return all machines for ease of updating
+    return {
+        'machines': [format_machine(machine) for machine in g.data.local.machine.get_all_machines()],
+    }
+
+
+@admin_pages.route('/machines/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updatepcbid() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    machine = request.get_json()['machine']
+    if machine['arcade'] is not None:
+        arcade = g.data.local.machine.get_arcade(machine['arcade'])
+        if arcade is None:
+            raise Exception('Unable to find arcade to link PCBID to!')
+
+    # Make sure we don't duplicate port assignments
+    other_pcbid = g.data.local.machine.from_port(machine['port'])
+    if other_pcbid is not None and other_pcbid != machine['pcbid']:
+        raise Exception('This port is already in use by \'{}\'!'.format(other_pcbid))
+
+    if machine['port'] < 1 or machine['port'] > 65535:
+        raise Exception('The specified port is out of range!')
+
+    current_machine = g.data.local.machine.get_machine(machine['pcbid'])
+    current_machine.description = machine['description']
+    current_machine.arcade = machine['arcade']
+    current_machine.port = machine['port']
+    current_machine.game = None if machine['game'] == 'any' else machine['game']
+    current_machine.version = None if machine['game'] == 'any' else machine['version']
+    g.data.local.machine.put_machine(current_machine)
+
+    # Just return all machines for ease of updating
+    return {
+        'machines': [format_machine(machine) for machine in g.data.local.machine.get_all_machines()],
+    }
+
+
+@admin_pages.route('/machines/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removepcbid() -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    pcbid = request.get_json()['pcbid']
+    if g.data.local.machine.get_machine(pcbid) is None:
+        raise Exception('Unable to find machine to delete!')
+
+    g.data.local.machine.destroy_machine(pcbid)
+
+    # Just return all machines for ease of updating
+    return {
+        'machines': [format_machine(machine) for machine in g.data.local.machine.get_all_machines()],
+    }
+
+
+@admin_pages.route('/cards/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removecard() -> Dict[str, Any]:
+    # Grab card, convert it
+    card = request.get_json()['card']
+    try:
+        cardid = CardCipher.decode(card)
+    except CardCipherException:
+        raise Exception('Invalid card number!')
+
+    # Make sure it is our card
+    userid = g.data.local.user.from_cardid(cardid)
+
+    # Remove it from the user's account
+    g.data.local.user.destroy_card(userid, cardid)
+
+    # Return new card list
+    return {
+        'cards': [format_card(card) for card in g.data.local.user.get_all_cards()],
+    }
+
+
+@admin_pages.route('/cards/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addcard() -> Dict[str, Any]:
+    # Grab card, convert it
+    card = request.get_json()['card']
+    try:
+        cardid = CardCipher.decode(card['number'])
+    except CardCipherException:
+        raise Exception('Invalid card number!')
+
+    # Make sure it is our card
+    userid = g.data.local.user.from_username(card['owner'])
+    if userid is None:
+        raise Exception('Cannot find user to add card to!')
+
+    # See if it is already claimed
+    curuserid = g.data.local.user.from_cardid(cardid)
+    if curuserid is not None:
+        raise Exception('This card is already in use!')
+
+    # Add it to the user's account
+    g.data.local.user.add_card(userid, cardid)
+
+    # Return new card list
+    return {
+        'cards': [format_card(card) for card in g.data.local.user.get_all_cards()],
+    }
+
+
+@admin_pages.route('/users/search', methods=['POST'])
+@jsonify
+@adminrequired
+def searchusers() -> Dict[str, Any]:
+    # Grab card, convert it
+    searchdetails = request.get_json()['user_search']
+    if len(searchdetails['card']) > 0:
+        try:
+            cardid = CardCipher.decode(searchdetails['card'])
+            actual_userid = g.data.local.user.from_cardid(cardid)
+            if actual_userid is None:
+                # Force a non-match below
+                actual_userid = -1
+        except CardCipherException:
+            actual_userid = -1
+    else:
+        actual_userid = None
+
+    def match(user: User) -> bool:
+        if actual_userid is not None:
+            return user.id == actual_userid
+        else:
+            return True
+
+    return {
+        'users': [format_user(user) for user in g.data.local.user.get_all_users() if match(user)],
+    }
+
+
+@admin_pages.route('/users/<int:userid>/balance/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updatebalance(userid: int) -> Dict[str, Any]:
+    credits = request.get_json()['credits']
+    user = g.data.local.user.get_user(userid)
+    arcades = g.data.local.machine.get_all_arcades()
+
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    # Update balances
+    for arcadeid in credits:
+        balance = g.data.local.user.update_balance(userid, arcadeid, credits[arcadeid])
+        if balance is not None:
+            g.data.local.network.put_event(
+                'paseli_transaction',
+                {
+                    'delta': credits[arcadeid],
+                    'balance': balance,
+                    'reason': 'admin adjustment',
+                },
+                userid=userid,
+                arcadeid=arcadeid,
+            )
+
+    return {
+        'arcades': {arcade.id: arcade.name for arcade in arcades},
+        'balances': {arcade.id: g.data.local.user.get_balance(userid, arcade.id) for arcade in arcades},
+        'events': [format_event(event) for event in g.data.local.network.get_events(userid=userid, event='paseli_transaction')],
+    }
+
+
+@admin_pages.route('/users/<int:userid>/username/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updateusername(userid: int) -> Dict[str, Any]:
+    username = request.get_json()['username']
+    user = g.data.local.user.get_user(userid)
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    if not valid_username(username):
+        raise Exception('Invalid username!')
+
+    # Make sure this user ID isn't taken
+    potential_userid = g.data.local.user.from_username(username)
+    if potential_userid is not None and potential_userid != userid:
+        raise Exception('That username is already taken!')
+
+    # Update the user
+    user.username = username
+    g.data.local.user.put_user(user)
+
+    return {
+        'username': username,
+    }
+
+
+@admin_pages.route('/users/<int:userid>/email/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updateemail(userid: int) -> Dict[str, Any]:
+    email = request.get_json()['email']
+    user = g.data.local.user.get_user(userid)
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    if not valid_email(email):
+        raise Exception('Invalid email!')
+
+    # Update the user
+    user.email = email
+    g.data.local.user.put_user(user)
+
+    return {
+        'email': email,
+    }
+
+
+@admin_pages.route('/users/<int:userid>/pin/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updatepin(userid: int) -> Dict[str, Any]:
+    pin = request.get_json()['pin']
+    user = g.data.local.user.get_user(userid)
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    if not valid_pin(pin, 'card'):
+        raise Exception('Invalid pin, must be exactly 4 digits!')
+
+    # Update the user
+    g.data.local.user.update_pin(userid, pin)
+
+    return {}
+
+
+@admin_pages.route('/users/<int:userid>/password/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updatepassword(userid: int) -> Dict[str, Any]:
+    new1 = request.get_json()['new1']
+    new2 = request.get_json()['new2']
+    user = g.data.local.user.get_user(userid)
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    # Now, make sure that the passwords match
+    if new1 != new2:
+        raise Exception('Passwords do not match each other!')
+
+    # Now, make sure passwords are long enough
+    if len(new1) < 6:
+        raise Exception('Password is not long enough!')
+
+    # Update the user
+    g.data.local.user.update_password(userid, new1)
+
+    return {}
+
+
+@admin_pages.route('/users/<int:userid>/cards/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removeusercard(userid: int) -> Dict[str, Any]:
+    # Grab card, convert it
+    card = request.get_json()['card']
+    try:
+        cardid = CardCipher.decode(card)
+    except CardCipherException:
+        raise Exception('Invalid card number!')
+    user = g.data.local.user.get_user(userid)
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    # Remove it from the user's account
+    g.data.local.user.destroy_card(userid, cardid)
+
+    # Return new card list
+    return {
+        'cards': [CardCipher.encode(card) for card in g.data.local.user.get_cards(userid)],
+    }
+
+
+@admin_pages.route('/users/<int:userid>/cards/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addusercard(userid: int) -> Dict[str, Any]:
+    # Grab card, convert it
+    card = request.get_json()['card']
+    try:
+        cardid = CardCipher.decode(card)
+    except CardCipherException:
+        raise Exception('Invalid card number!')
+    user = g.data.local.user.get_user(userid)
+    # Make sure the user ID is valid
+    if user is None:
+        raise Exception('Cannot find user to update!')
+
+    # See if it is already claimed
+    curuserid = g.data.local.user.from_cardid(cardid)
+    if curuserid is not None:
+        raise Exception('This card is already in use!')
+
+    # Add it to the user's account
+    g.data.local.user.add_card(userid, cardid)
+
+    # Return new card list
+    return {
+        'cards': [CardCipher.encode(card) for card in g.data.local.user.get_cards(userid)],
+    }
+
+
+@admin_pages.route('/news/add', methods=['POST'])
+@jsonify
+@adminrequired
+def addnews() -> Dict[str, Any]:
+    news = request.get_json()['news']
+    if len(news['title']) == 0:
+        raise Exception('Please provide a title!')
+    if len(news['body']) == 0:
+        raise Exception('Please provide a body!')
+
+    g.data.local.network.create_news(news['title'], news['body'])
+
+    return {
+        'news': [format_news(news) for news in g.data.local.network.get_all_news()],
+    }
+
+
+@admin_pages.route('/news/remove', methods=['POST'])
+@jsonify
+@adminrequired
+def removenews() -> Dict[str, Any]:
+    newsid = request.get_json()['newsid']
+    if g.data.local.network.get_news(newsid) is None:
+        raise Exception('Unable to find entry to delete!')
+
+    g.data.local.network.destroy_news(newsid)
+
+    return {
+        'news': [format_news(news) for news in g.data.local.network.get_all_news()],
+    }
+
+
+@admin_pages.route('/news/update', methods=['POST'])
+@jsonify
+@adminrequired
+def updatenews() -> Dict[str, Any]:
+    new_news = request.get_json()['news']
+    if g.data.local.network.get_news(new_news['id']) is None:
+        raise Exception('Unable to find entry to update!')
+    if len(new_news['title']) == 0:
+        raise Exception('Please provide a title!')
+    if len(new_news['body']) == 0:
+        raise Exception('Please provide a body!')
+
+    news = g.data.local.network.get_news(new_news['id'])
+    news.title = new_news['title']
+    news.body = new_news['body']
+    g.data.local.network.put_news(news)
+
+    return {
+        'news': [format_news(news) for news in g.data.local.network.get_all_news()],
+    }
diff --git a/bemani/frontend/app.py b/bemani/frontend/app.py
new file mode 100644
index 0000000..4c1b386
--- /dev/null
+++ b/bemani/frontend/app.py
@@ -0,0 +1,710 @@
+import os
+import re
+import traceback
+from typing import Callable, Dict, Any, Optional, List
+from react.jsx import JSXTransformer  # type: ignore
+from flask import Flask, flash, request, redirect, Response, url_for, render_template, got_request_exception, jsonify as flask_jsonify, g
+from flask_caching import Cache  # type: ignore
+from functools import wraps
+
+from bemani.common import AESCipher, GameConstants
+from bemani.data import Data
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+app = Flask(
+    __name__,
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+config: Dict[str, Any] = {}
+
+
+@app.before_request
+def before_request() -> None:
+    global config
+    g.cache = Cache(app, config={
+        'CACHE_TYPE': 'filesystem',
+        'CACHE_DIR': config['cache_dir'],
+    })
+    if request.endpoint in ['jsx', 'static']:
+        # This is just serving cached compiled frontends, skip loading from DB
+        return
+
+    g.config = config
+    g.data = Data(config)
+    g.sessionID = None
+    g.userID = None
+    try:
+        aes = AESCipher(config['secret_key'])
+        sessionID = aes.decrypt(request.cookies.get('SessionID'))
+    except Exception:
+        sessionID = None
+    g.sessionID = sessionID
+    if sessionID is not None:
+        g.userID = g.data.local.user.from_session(sessionID)
+    else:
+        g.userID = None
+
+
+@app.teardown_request
+def teardown_request(exception: Any) -> None:
+    data = getattr(g, 'data', None)
+    if data is not None:
+        data.close()
+
+
+def loginrequired(func: Callable) -> Callable:
+    @wraps(func)
+    def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+        if g.userID is None:
+            return redirect(url_for('account_pages.viewlogin'))  # type: ignore
+        else:
+            return func(*args, **kwargs)
+    return decoratedfunction
+
+
+def adminrequired(func: Callable) -> Callable:
+    @wraps(func)
+    def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+        if g.userID is None:
+            return redirect(url_for('account_pages.viewlogin'))  # type: ignore
+        else:
+            user = g.data.local.user.get_user(g.userID)
+            if not user.admin:
+                return Response(render_template('403.html', **{'title': '403 Forbidden'}), 403)
+            else:
+                return func(*args, **kwargs)
+    return decoratedfunction
+
+
+def loginprohibited(func: Callable) -> Callable:
+    @wraps(func)
+    def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+        if g.userID is not None:
+            return redirect(url_for('home_pages.viewhome'))  # type: ignore
+        else:
+            return func(*args, **kwargs)
+    return decoratedfunction
+
+
+def jsonify(func: Callable) -> Callable:
+    @wraps(func)
+    def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+        try:
+            return flask_jsonify(func(*args, **kwargs))
+        except Exception as e:
+            print(traceback.format_exc())
+            return flask_jsonify({
+                'error': True,
+                'message': str(e),
+            })
+    return decoratedfunction
+
+
+def cacheable(max_age: int) -> Callable:
+    def __cache(func: Callable) -> Callable:
+        @wraps(func)
+        def decoratedfunction(*args: Any, **kwargs: Any) -> Response:
+            response = func(*args, **kwargs)
+            response.cache_control.max_age = max_age
+            return response
+        return decoratedfunction
+    return __cache
+
+
+@app.route('/jsx/<path:filename>')
+@cacheable(86400)
+def jsx(filename: str) -> Response:
+    # Figure out what our update time is to namespace on
+    jsxfile = os.path.join(static_location, filename)
+    mtime = os.path.getmtime(jsxfile)
+    namespace = '{}.{}'.format(mtime, jsxfile)
+    jsx = g.cache.get(namespace)
+    if jsx is None:
+        transformer = JSXTransformer()
+        f = open(jsxfile, 'r')
+        jsx = transformer.transform_string(f.read())
+        f.close()
+        # Set the cache to one year, since we namespace on this file's update time
+        g.cache.set(namespace, jsx, timeout=86400 * 365)
+    return Response(jsx, mimetype='application/javascript')
+
+
+def render_react(
+    title: str,
+    controller: str,
+    inits: Optional[Dict[str, Any]]=None,
+    links: Optional[Dict[str, Any]]=None,
+) -> Response:
+    if links is None:
+        links = {}
+    if inits is None:
+        inits = {}
+    links['static'] = url_for('static', filename='-1')
+
+    return Response(render_template(
+        'react.html',
+        **{
+            'title': title,
+            'reactbase': os.path.join('controllers/', controller),
+            'inits': inits,
+            'links': links,
+        },
+    ))
+
+
+def exception(sender: Any, exception: Exception, **extra: Any) -> None:
+    stack = ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+    try:
+        g.data.local.network.put_event(
+            'exception',
+            {
+                'service': 'frontend',
+                'request': request.url,
+                'traceback': stack,
+            },
+        )
+    except Exception:
+        pass
+
+
+got_request_exception.connect(exception, app)
+
+
+@app.errorhandler(403)
+def forbidden(error: Any) -> Response:
+    return Response(render_template('403.html', **{'title': '403 Forbidden'}), 403)
+
+
+@app.errorhandler(404)
+def page_not_found(error: Any) -> Response:
+    return Response(render_template('404.html', **{'title': '404 Not Found'}), 404)
+
+
+@app.errorhandler(500)
+def server_error(error: Any) -> Response:
+    return Response(render_template('500.html', **{'title': '500 Internal Server Error'}), 500)
+
+
+def error(msg: str) -> None:
+    flash(msg, 'error')
+
+
+def warning(msg: str) -> None:
+    flash(msg, 'warning')
+
+
+def success(msg: str) -> None:
+    flash(msg, 'success')
+
+
+def info(msg: str) -> None:
+    flash(msg, 'info')
+
+
+def valid_email(email: str) -> bool:
+    return re.match(r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)", email) is not None
+
+
+def valid_username(username: str) -> bool:
+    return re.match(r"^[a-zA-Z0-9_]+$", username) is not None
+
+
+def valid_pin(pin: str, type: str) -> bool:
+    if type == 'card':
+        return re.match(r"\d\d\d\d", pin) is not None
+    elif type == 'arcade':
+        return re.match(r"\d\d\d\d\d\d\d\d", pin) is not None
+    else:
+        return False
+
+
+@app.context_processor
+def navigation() -> Dict[str, Any]:
+    # Look up JSX components we should provide for every page load
+    components = [
+        os.path.join('components/', f)
+        for f in os.listdir(os.path.join(static_location, 'components/'))
+        if re.search(r'\.react\.js$', f)
+    ]
+
+    # Define useful functions for jnija2
+    def jinja2_any(lval: Optional[List[Any]], pull: str, equals: str) -> bool:
+        if lval is None:
+            return False
+        for entry in lval:
+            if entry[pull] == equals:
+                return True
+        return False
+
+    # Look up the logged in user ID.
+    if g.userID is not None:
+        user = g.data.local.user.get_user(g.userID)
+        profiles = g.data.local.user.get_games_played(g.userID)
+    else:
+        return {
+            'components': components,
+            'any': jinja2_any,
+        }
+    pages = []
+
+    # Landing page
+    pages.append(
+        {
+            'label': 'Home',
+            'uri': url_for('home_pages.viewhome'),
+        },
+    )
+
+    if g.config.get('support', {}).get(GameConstants.BISHI_BASHI, False):
+        # BishiBashi pages
+        bishi_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.BISHI_BASHI]) > 0:
+            bishi_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('bishi_pages.viewsettings'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('bishi_pages.viewplayer', userid=g.userID),
+                },
+            ])
+        bishi_entries.extend([
+            {
+                'label': 'All Players',
+                'uri': url_for('bishi_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'BishiBashi',
+                'entries': bishi_entries,
+                'base_uri': app.blueprints['bishi_pages'].url_prefix,
+                'gamecode': GameConstants.BISHI_BASHI,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.DDR, False):
+        # DDR pages
+        ddr_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.DDR]) > 0:
+            ddr_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('ddr_pages.viewsettings'),
+                },
+                {
+                    'label': 'Rivals',
+                    'uri': url_for('ddr_pages.viewrivals'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('ddr_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('ddr_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('ddr_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        ddr_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('ddr_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('ddr_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('ddr_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'DDR',
+                'entries': ddr_entries,
+                'base_uri': app.blueprints['ddr_pages'].url_prefix,
+                'gamecode': GameConstants.DDR,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.IIDX, False):
+        # IIDX pages
+        iidx_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.IIDX]) > 0:
+            iidx_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('iidx_pages.viewsettings'),
+                },
+                {
+                    'label': 'Rivals',
+                    'uri': url_for('iidx_pages.viewrivals'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('iidx_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('iidx_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('iidx_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        iidx_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('iidx_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('iidx_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('iidx_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'IIDX',
+                'entries': iidx_entries,
+                'base_uri': app.blueprints['iidx_pages'].url_prefix,
+                'gamecode': GameConstants.IIDX,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.JUBEAT, False):
+        # Jubeat pages
+        jubeat_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.JUBEAT]) > 0:
+            jubeat_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('jubeat_pages.viewsettings'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('jubeat_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('jubeat_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('jubeat_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        jubeat_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('jubeat_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('jubeat_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('jubeat_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'Jubeat',
+                'entries': jubeat_entries,
+                'base_uri': app.blueprints['jubeat_pages'].url_prefix,
+                'gamecode': GameConstants.JUBEAT,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.MUSECA, False):
+        # Museca pages
+        museca_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.MUSECA]) > 0:
+            museca_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('museca_pages.viewsettings'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('museca_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('museca_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('museca_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        museca_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('museca_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('museca_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('museca_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'MÚSECA',
+                'entries': museca_entries,
+                'base_uri': app.blueprints['museca_pages'].url_prefix,
+                'gamecode': GameConstants.MUSECA,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.POPN_MUSIC, False):
+        # Pop'n Music pages
+        popn_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.POPN_MUSIC]) > 0:
+            popn_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('popn_pages.viewsettings'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('popn_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('popn_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('popn_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        popn_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('popn_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('popn_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('popn_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'Pop\'n Music',
+                'entries': popn_entries,
+                'base_uri': app.blueprints['popn_pages'].url_prefix,
+                'gamecode': GameConstants.POPN_MUSIC,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.REFLEC_BEAT, False):
+        # ReflecBeat pages
+        reflec_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.REFLEC_BEAT]) > 0:
+            reflec_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('reflec_pages.viewsettings'),
+                },
+                {
+                    'label': 'Rivals',
+                    'uri': url_for('reflec_pages.viewrivals'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('reflec_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('reflec_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('reflec_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        reflec_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('reflec_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('reflec_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('reflec_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'Reflec Beat',
+                'entries': reflec_entries,
+                'base_uri': app.blueprints['reflec_pages'].url_prefix,
+                'gamecode': GameConstants.REFLEC_BEAT,
+            },
+        )
+
+    if g.config.get('support', {}).get(GameConstants.SDVX, False):
+        # SDVX pages
+        sdvx_entries = []
+        if len([p for p in profiles if p[0] == GameConstants.SDVX]) > 0:
+            sdvx_entries.extend([
+                {
+                    'label': 'Game Options',
+                    'uri': url_for('sdvx_pages.viewsettings'),
+                },
+                {
+                    'label': 'Rivals',
+                    'uri': url_for('sdvx_pages.viewrivals'),
+                },
+                {
+                    'label': 'Personal Profile',
+                    'uri': url_for('sdvx_pages.viewplayer', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Scores',
+                    'uri': url_for('sdvx_pages.viewscores', userid=g.userID),
+                },
+                {
+                    'label': 'Personal Records',
+                    'uri': url_for('sdvx_pages.viewrecords', userid=g.userID),
+                },
+            ])
+        sdvx_entries.extend([
+            {
+                'label': 'Global Scores',
+                'uri': url_for('sdvx_pages.viewnetworkscores'),
+            },
+            {
+                'label': 'Global Records',
+                'uri': url_for('sdvx_pages.viewnetworkrecords'),
+            },
+            {
+                'label': 'All Players',
+                'uri': url_for('sdvx_pages.viewplayers'),
+            },
+        ])
+        pages.append(
+            {
+                'label': 'SDVX',
+                'entries': sdvx_entries,
+                'base_uri': app.blueprints['sdvx_pages'].url_prefix,
+                'gamecode': GameConstants.SDVX,
+            },
+        )
+
+    # Admin pages
+    if user.admin:
+        pages.append(
+            {
+                'label': 'Admin',
+                'uri': url_for('admin_pages.viewsettings'),
+                'entries': [
+                    {
+                        'label': 'Events',
+                        'uri': url_for('admin_pages.viewevents'),
+                    },
+                    {
+                        'label': 'Data API',
+                        'uri': url_for('admin_pages.viewapi'),
+                    },
+                    {
+                        'label': 'Arcades',
+                        'uri': url_for('admin_pages.viewarcades'),
+                    },
+                    {
+                        'label': 'Machines',
+                        'uri': url_for('admin_pages.viewmachines'),
+                    },
+                    {
+                        'label': 'Cards',
+                        'uri': url_for('admin_pages.viewcards'),
+                    },
+                    {
+                        'label': 'Users',
+                        'uri': url_for('admin_pages.viewusers'),
+                    },
+                    {
+                        'label': 'News',
+                        'uri': url_for('admin_pages.viewnews'),
+                    },
+                ],
+                'base_uri': app.blueprints['admin_pages'].url_prefix,
+                'right_justify': True,
+            },
+        )
+
+    # Arcade owner pages
+    arcadeids = g.data.local.machine.from_userid(g.userID)
+    if len(arcadeids) > 0:
+        entries = []
+        for arcadeid in arcadeids:
+            arcade = g.data.local.machine.get_arcade(arcadeid)
+            entries.append({
+                'label': arcade.name,
+                'uri': url_for('arcade_pages.viewarcade', arcadeid=arcade.id),
+            })
+
+        pages.append({
+            'label': 'Arcades',
+            'entries': entries,
+            'base_uri': app.blueprints['arcade_pages'].url_prefix,
+            'right_justify': True,
+        })
+
+    # User account pages
+    pages.append(
+        {
+            'label': 'Account',
+            'uri': url_for('account_pages.viewaccount'),
+            'entries': [
+                {
+                    'label': 'Cards',
+                    'uri': url_for('account_pages.viewcards'),
+                },
+            ],
+            'base_uri': app.blueprints['account_pages'].url_prefix,
+            'right_justify': True,
+        },
+    )
+
+    # GTFO button
+    pages.append(
+        {
+            'label': 'Log Out',
+            'uri': url_for('account_pages.logout'),
+            'right_justify': True,
+        },
+    )
+
+    return {
+        'current_path': request.path,
+        'show_navigation': True,
+        'navigation': pages,
+        'components': components,
+        'any': jinja2_any,
+    }
diff --git a/bemani/frontend/arcade/__init__.py b/bemani/frontend/arcade/__init__.py
new file mode 100644
index 0000000..d325c9c
--- /dev/null
+++ b/bemani/frontend/arcade/__init__.py
@@ -0,0 +1 @@
+from bemani.frontend.arcade.arcade import arcade_pages
diff --git a/bemani/frontend/arcade/arcade.py b/bemani/frontend/arcade/arcade.py
new file mode 100644
index 0000000..cb7cfb8
--- /dev/null
+++ b/bemani/frontend/arcade/arcade.py
@@ -0,0 +1,375 @@
+from typing import Any, Dict, List
+from flask import Blueprint, request, Response, abort, url_for, g  # type: ignore
+
+from bemani.backend.base import Base
+from bemani.common import CardCipher, CardCipherException, ValidatedDict, GameConstants
+from bemani.data import Arcade, Event, Machine
+from bemani.frontend.app import loginrequired, jsonify, render_react, valid_pin
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+arcade_pages = Blueprint(
+    'arcade_pages',
+    __name__,
+    url_prefix='/arcade',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+def format_machine(machine: Machine) -> Dict[str, Any]:
+    if machine.game is None:
+        game = 'any game'
+    elif machine.version is None:
+        game = {
+            GameConstants.BISHI_BASHI: 'BishiBashi',
+            GameConstants.DDR: 'DDR',
+            GameConstants.IIDX: 'IIDX',
+            GameConstants.JUBEAT: 'Jubeat',
+            GameConstants.MUSECA: 'MÚSECA',
+            GameConstants.POPN_MUSIC: 'Pop\'n Music',
+            GameConstants.REFLEC_BEAT: 'Reflec Beat',
+            GameConstants.SDVX: 'SDVX',
+        }.get(machine.game)
+    elif machine.version > 0:
+        game = [
+            name for (game, version, name) in Base.all_games()
+            if game == machine.game and version == machine.version
+        ][0]
+    elif machine.version < 0:
+        game = [
+            name for (game, version, name) in Base.all_games()
+            if game == machine.game and version == -machine.version
+        ][0] + ' or older'
+
+    return {
+        'pcbid': machine.pcbid,
+        'name': machine.name,
+        'description': machine.description,
+        'port': machine.port,
+        'game': game,
+    }
+
+
+def format_arcade(arcade: Arcade) -> Dict[str, Any]:
+    return {
+        'id': arcade.id,
+        'name': arcade.name,
+        'description': arcade.description,
+        'pin': arcade.pin,
+        'paseli_enabled': arcade.data.get_bool('paseli_enabled'),
+        'paseli_infinite': arcade.data.get_bool('paseli_infinite'),
+        'mask_services_url': arcade.data.get_bool('mask_services_url'),
+        'owners': arcade.owners,
+    }
+
+
+def format_event(event: Event) -> Dict[str, Any]:
+    return {
+        'id': event.id,
+        'timestamp': event.timestamp,
+        'userid': event.userid,
+        'arcadeid': event.arcadeid,
+        'type': event.type,
+        'data': event.data,
+    }
+
+
+def get_game_settings(arcade: Arcade) -> List[Dict[str, Any]]:
+    game_lut: Dict[str, Dict[int, str]] = {}
+    settings_lut: Dict[str, Dict[int, Dict[str, Any]]] = {}
+    all_settings = []
+
+    for (game, version, name) in Base.all_games():
+        if game not in game_lut:
+            game_lut[game] = {}
+            settings_lut[game] = {}
+        game_lut[game][version] = name
+        settings_lut[game][version] = {}
+
+    for (game, version, settings) in Base.all_settings():
+        if not settings:
+            continue
+
+        # First, set up the basics
+        game_settings: Dict[str, Any] = {
+            'game': game,
+            'version': version,
+            'name': game_lut[game][version],
+            'bools': [],
+            'ints': [],
+        }
+
+        # Now, look up the current setting for each returned setting
+        for bool_setting in settings.get('bools', []):
+            if bool_setting['category'] not in settings_lut[game][version]:
+                cached_setting = g.data.local.machine.get_settings(arcade.id, game, version, bool_setting['category'])
+                if cached_setting is None:
+                    cached_setting = ValidatedDict()
+                settings_lut[game][version][bool_setting['category']] = cached_setting
+
+            current_settings = settings_lut[game][version][bool_setting['category']]
+            bool_setting['value'] = current_settings.get_bool(bool_setting['setting'])
+            game_settings['bools'].append(bool_setting)
+
+        # Now, look up the current setting for each returned setting
+        for int_setting in settings.get('ints', []):
+            if int_setting['category'] not in settings_lut[game][version]:
+                cached_setting = g.data.local.machine.get_settings(arcade.id, game, version, int_setting['category'])
+                if cached_setting is None:
+                    cached_setting = ValidatedDict()
+                settings_lut[game][version][int_setting['category']] = cached_setting
+
+            current_settings = settings_lut[game][version][int_setting['category']]
+            int_setting['value'] = current_settings.get_int(int_setting['setting'])
+            game_settings['ints'].append(int_setting)
+
+        # Now, include it!
+        all_settings.append(game_settings)
+
+    return all_settings
+
+
+@arcade_pages.route('/<int:arcadeid>')
+@loginrequired
+def viewarcade(arcadeid: int) -> Response:
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if g.userID not in arcade.owners:
+        abort(403)
+    machines = [
+        format_machine(machine) for machine in g.data.local.machine.get_all_machines(arcade.id)
+    ]
+    return render_react(
+        arcade.name,
+        'arcade/arcade.react.js',
+        {
+            'arcade': format_arcade(arcade),
+            'machines': machines,
+            'game_settings': get_game_settings(arcade),
+            'balances': {balance[0]: balance[1] for balance in g.data.local.machine.get_balances(arcadeid)},
+            'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
+            'events': [format_event(event) for event in g.data.local.network.get_events(arcadeid=arcadeid, event='paseli_transaction')],
+            'enforcing': g.config['server']['enforce_pcbid'],
+        },
+        {
+            'refresh': url_for('arcade_pages.listarcade', arcadeid=arcadeid),
+            'viewuser': url_for('admin_pages.viewuser', userid=-1),
+            'paseli_enabled': url_for('arcade_pages.updatearcade', arcadeid=arcadeid, attribute='paseli_enabled'),
+            'paseli_infinite': url_for('arcade_pages.updatearcade', arcadeid=arcadeid, attribute='paseli_infinite'),
+            'mask_services_url': url_for('arcade_pages.updatearcade', arcadeid=arcadeid, attribute='mask_services_url'),
+            'update_settings': url_for('arcade_pages.updatesettings', arcadeid=arcadeid),
+            'add_balance': url_for('arcade_pages.addbalance', arcadeid=arcadeid),
+            'update_balance': url_for('arcade_pages.updatebalance', arcadeid=arcadeid),
+            'update_pin': url_for('arcade_pages.updatepin', arcadeid=arcadeid),
+        },
+    )
+
+
+@arcade_pages.route('/<int:arcadeid>/list')
+@jsonify
+@loginrequired
+def listarcade(arcadeid: int) -> Dict[str, Any]:
+    # Make sure the arcade is valid
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if arcade is None:
+        raise Exception('Unable to find arcade to list!')
+    if g.userID not in arcade.owners:
+        raise Exception('You don\'t own this arcade, refusing to list!')
+
+    machines = [
+        format_machine(machine) for machine in g.data.local.machine.get_all_machines(arcade.id)
+    ]
+    return {
+        'machines': machines,
+        'balances': {balance[0]: balance[1] for balance in g.data.local.machine.get_balances(arcadeid)},
+        'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
+        'events': [format_event(event) for event in g.data.local.network.get_events(arcadeid=arcadeid, event='paseli_transaction')],
+    }
+
+
+@arcade_pages.route('/<int:arcadeid>/balance/add', methods=['POST'])
+@jsonify
+@loginrequired
+def addbalance(arcadeid: int) -> Dict[str, Any]:
+    credits = request.get_json()['credits']
+    card = request.get_json()['card']
+
+    # Make sure the arcade is valid
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if arcade is None:
+        raise Exception('Unable to find arcade to update!')
+    if g.userID not in arcade.owners:
+        raise Exception('You don\'t own this arcade, refusing to update!')
+
+    try:
+        cardid = CardCipher.decode(card)
+        userid = g.data.local.user.from_cardid(cardid)
+    except CardCipherException:
+        userid = None
+
+    if userid is None:
+        raise Exception('Unable to find user by this card!')
+
+    # Update balance
+    balance = g.data.local.user.update_balance(userid, arcadeid, credits)
+    if balance is not None:
+        g.data.local.network.put_event(
+            'paseli_transaction',
+            {
+                'delta': credits,
+                'balance': balance,
+                'reason': 'arcade operator adjustment',
+            },
+            userid=userid,
+            arcadeid=arcadeid,
+        )
+
+    return {
+        'balances': {balance[0]: balance[1] for balance in g.data.local.machine.get_balances(arcadeid)},
+        'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
+        'events': [format_event(event) for event in g.data.local.network.get_events(arcadeid=arcadeid, event='paseli_transaction')],
+    }
+
+
+@arcade_pages.route('/<int:arcadeid>/balance/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatebalance(arcadeid: int) -> Dict[str, Any]:
+    credits = request.get_json()['credits']
+
+    # Make sure the arcade is valid
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if arcade is None:
+        raise Exception('Unable to find arcade to update!')
+    if g.userID not in arcade.owners:
+        raise Exception('You don\'t own this arcade, refusing to update!')
+
+    # Update balances
+    for userid in credits:
+        balance = g.data.local.user.update_balance(userid, arcadeid, credits[userid])
+        if balance is not None:
+            g.data.local.network.put_event(
+                'paseli_transaction',
+                {
+                    'delta': credits[userid],
+                    'balance': balance,
+                    'reason': 'arcade operator adjustment',
+                },
+                userid=userid,
+                arcadeid=arcadeid,
+            )
+
+    return {
+        'balances': {balance[0]: balance[1] for balance in g.data.local.machine.get_balances(arcadeid)},
+        'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
+        'events': [format_event(event) for event in g.data.local.network.get_events(arcadeid=arcadeid, event='paseli_transaction')],
+    }
+
+
+@arcade_pages.route('/<int:arcadeid>/pin/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatepin(arcadeid: int) -> Dict[str, Any]:
+    pin = request.get_json()['pin']
+
+    # Make sure the arcade is valid
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if arcade is None:
+        raise Exception('Unable to find arcade to update!')
+    if g.userID not in arcade.owners:
+        raise Exception('You don\'t own this arcade, refusing to update!')
+
+    if not valid_pin(pin, 'arcade'):
+        raise Exception('Invalid PIN, must be exactly 8 digits!')
+
+    # Update and save
+    arcade.pin = pin
+    g.data.local.machine.put_arcade(arcade)
+
+    # Return nothing
+    return {'pin': pin}
+
+
+@arcade_pages.route('/<int:arcadeid>/update/<string:attribute>', methods=['POST'])
+@jsonify
+@loginrequired
+def updatearcade(arcadeid: int, attribute: str) -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    new_value = request.get_json()['value']
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+    if arcade is None:
+        raise Exception('Unable to find arcade to update!')
+    if g.userID not in arcade.owners:
+        raise Exception('You don\'t own this arcade, refusing to update!')
+
+    if attribute == 'paseli_enabled':
+        arcade.data.replace_bool('paseli_enabled', new_value)
+    elif attribute == 'paseli_infinite':
+        arcade.data.replace_bool('paseli_infinite', new_value)
+    elif attribute == 'mask_services_url':
+        arcade.data.replace_bool('mask_services_url', new_value)
+    else:
+        raise Exception('Unknown attribute {} to update!'.format(attribute))
+
+    g.data.local.machine.put_arcade(arcade)
+
+    # Return the updated value
+    return {
+        'value': new_value,
+    }
+
+
+@arcade_pages.route('/<int:arcadeid>/settings/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatesettings(arcadeid: int) -> Dict[str, Any]:
+    # Attempt to look this arcade up
+    arcade = g.data.local.machine.get_arcade(arcadeid)
+
+    if arcade is None:
+        raise Exception('Unable to find arcade to update!')
+    if g.userID not in arcade.owners:
+        raise Exception('You don\'t own this arcade, refusing to update!')
+
+    game = request.get_json()['game']
+    version = request.get_json()['version']
+
+    for game_setting in request.get_json()['bools']:
+        # Grab the value to update
+        category = game_setting['category']
+        setting = game_setting['setting']
+        new_value = game_setting['value']
+
+        # Update the value
+        current_settings = g.data.local.machine.get_settings(arcade.id, game, version, category)
+        if current_settings is None:
+            current_settings = ValidatedDict()
+
+        current_settings.replace_bool(setting, new_value)
+
+        # Save it back
+        g.data.local.machine.put_settings(arcade.id, game, version, category, current_settings)
+
+    for game_setting in request.get_json()['ints']:
+        # Grab the value to update
+        category = game_setting['category']
+        setting = game_setting['setting']
+        new_value = game_setting['value']
+
+        # Update the value
+        current_settings = g.data.local.machine.get_settings(arcade.id, game, version, category)
+        if current_settings is None:
+            current_settings = ValidatedDict()
+
+        current_settings.replace_int(setting, new_value)
+
+        # Save it back
+        g.data.local.machine.put_settings(arcade.id, game, version, category, current_settings)
+
+    # Return the updated value
+    return {
+        'game_settings': [
+            gs for gs in get_game_settings(arcade)
+            if gs['game'] == game and gs['version'] == version
+        ][0],
+    }
diff --git a/bemani/frontend/base.py b/bemani/frontend/base.py
new file mode 100644
index 0000000..7e78c5a
--- /dev/null
+++ b/bemani/frontend/base.py
@@ -0,0 +1,327 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.common import ValidatedDict, ID
+from bemani.data import Data, Score, Attempt, Link, Song, UserID, RemoteUser
+
+
+class FrontendBase:
+
+    """
+    All subclasses should override this attribute with the string
+    the game series uses in the DB.
+    """
+    game: str = None
+
+    """
+    If a subclass wishes to constrain music searches to a particular
+    version, this should be set. If this is left blank, music operations
+    such as records and attempts will pull from all versions of the game.
+    """
+    version: Optional[int] = None
+
+    """
+    List of valid chart integers. Should be overridden by the game.
+    """
+    valid_charts: List[int] = []
+
+    """
+    List of valid rival type strings. Should be overridden by the game.
+    """
+    valid_rival_types: List[str] = []
+
+    def __init__(self, data: Data, config: Dict[str, Any], cache: Cache) -> None:
+        self.data = data
+        self.config = config
+        self.cache = cache
+
+    def make_index(self, songid: int, chart: int) -> str:
+        return '{}-{}'.format(songid, chart)
+
+    def get_duplicate_id(self, musicid: int, chart: int) -> Optional[Tuple[int, int]]:
+        return None
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        return {
+            'userid': str(userid),
+            'songid': score.id,
+            'chart': score.chart,
+            'plays': score.plays,
+            'points': score.points,
+        }
+
+    def format_top_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        return self.format_score(userid, score)
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        return {
+            'userid': str(userid),
+            'songid': attempt.id,
+            'chart': attempt.chart,
+            'timestamp': attempt.timestamp,
+            'raised': attempt.new_record,
+            'points': attempt.points,
+        }
+
+    def format_rival(self, link: Link, profile: ValidatedDict) -> Dict[str, Any]:
+        return {
+            'type': link.type,
+            'userid': str(link.other_userid),
+            'remote': RemoteUser.is_remote(link.other_userid),
+        }
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        return {
+            'name': profile.get_str('name'),
+            'extid': ID.format_extid(profile.get_int('extid')),
+            'first_play_time': playstats.get_int('first_play_timestamp'),
+            'last_play_time': playstats.get_int('last_play_timestamp'),
+        }
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        return {
+            'name': song.name,
+            'artist': song.artist,
+            'genre': song.genre,
+        }
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        return existing
+
+    def round_to_ten(self, elems: List[Any]) -> List[Any]:
+        num = len(elems)
+        if num % 10 == 0:
+            return elems
+        else:
+            return elems[:-(num % 10)]
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        """
+        Override this to return an interator based on a game series factory.
+        """
+
+    def get_all_songs(self, force_db_load: bool=False) -> Dict[int, Dict[str, Any]]:
+        if not force_db_load:
+            cached_songs = self.cache.get('{}.sorted_songs'.format(self.game))
+            if cached_songs is not None:
+                return cached_songs
+
+        # Find all songs in the game, process notecounts and difficulties
+        songs: Dict[int, Dict[str, Any]] = {}
+        for song in self.data.local.music.get_all_songs(self.game, self.version):
+            if song.chart not in self.valid_charts:
+                # No beginner chart support
+                continue
+            if song.id not in songs:
+                songs[song.id] = self.format_song(song)
+            else:
+                songs[song.id] = self.merge_song(songs[song.id], song)
+
+        self.cache.set('{}.sorted_songs'.format(self.game), songs, timeout=600)
+        return songs
+
+    def get_all_player_info(self, userids: List[UserID], limit: Optional[int]=None, allow_remote: bool=False) -> Dict[UserID, Dict[int, Dict[str, Any]]]:
+        info: Dict[UserID, Dict[int, Dict[str, Any]]] = {}
+        playstats: Dict[UserID, ValidatedDict] = {}
+
+        # Find all versions of the users' profiles, sorted newest to oldest.
+        versions = sorted([version for (game, version, name) in self.all_games()], reverse=True)
+        for userid in userids:
+            info[userid] = {}
+            userlimit = limit
+            for version in versions:
+                if allow_remote:
+                    profile = self.data.remote.user.get_profile(self.game, version, userid)
+                else:
+                    profile = self.data.local.user.get_profile(self.game, version, userid)
+                if profile is not None:
+                    if userid not in playstats:
+                        stats = self.data.local.game.get_settings(self.game, userid)
+                        if stats is None:
+                            stats = ValidatedDict()
+                        playstats[userid] = stats
+                    info[userid][version] = self.format_profile(profile, playstats[userid])
+                    info[userid][version]['remote'] = RemoteUser.is_remote(userid)
+                    # Exit out if we've hit the limit
+                    if userlimit is not None:
+                        userlimit = userlimit - 1
+                        if userlimit == 0:
+                            break
+
+        return info
+
+    def get_latest_player_info(self, userids: List[UserID]) -> Dict[UserID, Dict[str, Any]]:
+        # Grab the latest profile for each user
+        all_info = self.get_all_player_info(userids, 1)
+        info = {}
+
+        for userid in userids:
+            for version in all_info[userid]:
+                info[userid] = all_info[userid][version]
+                break
+
+        return info
+
+    def get_all_players(self) -> Dict[UserID, Dict[str, Any]]:
+        userids: Set[UserID] = set()
+
+        versions = [version for (game, version, name) in self.all_games()]
+        for version in versions:
+            userids.update(self.data.local.user.get_all_players(self.game, version))
+
+        return self.get_latest_player_info(list(userids))
+
+    def get_network_scores(self, limit: Optional[int]=None) -> Dict[str, Any]:
+        userids: List[UserID] = []
+
+        # Find all attempts across all games
+        attempts = [
+            attempt for attempt in self.data.local.music.get_all_attempts(game=self.game, version=self.version, limit=limit)
+            if attempt[0] is not None
+        ]
+        for attempt in attempts:
+            if attempt[0] not in userids:
+                userids.append(attempt[0])
+
+        return {
+            'attempts': sorted(
+                [self.format_attempt(attempt[0], attempt[1]) for attempt in attempts],
+                reverse=True,
+                key=lambda attempt: (attempt['timestamp'], attempt['songid'], attempt['chart']),
+            ),
+            'players': self.get_latest_player_info(userids),
+        }
+
+    def get_network_records(self) -> Dict[str, Any]:
+        records: Dict[str, Tuple[UserID, Score]] = {}
+        userids: List[UserID] = []
+
+        # Find all high-scores across all games
+        highscores = self.data.local.music.get_all_records(game=self.game, version=self.version)
+        for score in highscores:
+            index = self.make_index(score[1].id, score[1].chart)
+            if index not in records:
+                records[index] = score
+                if score[0] not in userids:
+                    userids.append(score[0])
+            # Also take care of duplicate IDs (revivals, omnimix, etc)
+            alternate = self.get_duplicate_id(score[1].id, score[1].chart)
+            if alternate is not None:
+                altid, altchart = alternate
+                index = self.make_index(altid, altchart)
+                if index not in records:
+                    newscore = copy.deepcopy(score)
+                    newscore[1].id = altid
+                    newscore[1].chart = altchart
+                    records[index] = newscore
+
+        return {
+            'records': [
+                self.format_score(records[index][0], records[index][1]) for index in records
+            ],
+            'players': self.get_latest_player_info(userids),
+        }
+
+    def get_scores(self, userid: UserID, limit: Optional[int]=None) -> List[Dict[str, Any]]:
+        # Find all attempts across all games
+        attempts = [
+            attempt for attempt in self.data.local.music.get_all_attempts(game=self.game, version=self.version, userid=userid, limit=limit)
+            if attempt[0] is not None
+        ]
+
+        return sorted(
+            [self.format_attempt(None, attempt[1]) for attempt in attempts],
+            reverse=True,
+            key=lambda attempt: (attempt['timestamp'], attempt['songid'], attempt['chart']),
+        )
+
+    def get_records(self, userid: UserID) -> List[Dict[str, Any]]:
+        records: Dict[str, Tuple[UserID, Score]] = {}
+
+        # Find all high-scores across all games
+        highscores = self.data.local.music.get_all_scores(game=self.game, version=self.version, userid=userid)
+        for score in highscores:
+            index = self.make_index(score[1].id, score[1].chart)
+            if index not in records:
+                records[index] = score
+            else:
+                current_score = records[index][1].points
+                current_plays = records[index][1].plays
+                new_score = score[1].points
+                new_plays = score[1].plays
+                if new_score > current_score:
+                    records[index] = score
+                    records[index][1].plays += current_plays
+                else:
+                    records[index][1].plays += new_plays
+
+        # Copy over records to duplicate IDs, such as revivals
+        indexes = [index for index in records]
+        for index in indexes:
+            alternate = self.get_duplicate_id(records[index][1].id, records[index][1].chart)
+            if alternate is not None:
+                altid, altchart = alternate
+                newindex = self.make_index(altid, altchart)
+                if newindex not in records:
+                    newscore = copy.deepcopy(score)
+                    newscore[1].id = altid
+                    newscore[1].chart = altchart
+                    records[newindex] = newscore
+
+        return [self.format_score(None, records[index][1]) for index in records]
+
+    def get_top_scores(self, musicid: int) -> Dict[str, Any]:
+        scores = self.data.local.music.get_all_scores(game=self.game, version=self.version, songid=musicid)
+        userids: List[UserID] = []
+        for score in scores:
+            if score[1].chart not in self.valid_charts:
+                # No beginner chart support
+                continue
+            if score[0] not in userids:
+                userids.append(score[0])
+
+        for score in scores:
+            # See if this is a legacy ID
+            if score[1].id != musicid:
+                alternative = self.get_duplicate_id(score[1].id, score[1].chart)
+                if alternative is None:
+                    continue
+
+                oldid, oldchart = alternative
+                if oldid == musicid:
+                    score[1].id = oldid
+                    score[1].chart = oldchart
+
+        return {
+            'topscores': [
+                self.format_top_score(score[0], score[1]) for score in scores
+                if score[1].chart in self.valid_charts
+            ],
+            'players': self.get_latest_player_info(userids),
+        }
+
+    def get_rivals(self, userid: UserID) -> Tuple[Dict[int, List[Dict[str, Any]]], Dict[UserID, Dict[int, Dict[str, Any]]]]:
+        rivals = {}
+        userids = set()
+        versions = [version for (game, version, name) in self.all_games()]
+        profiles = {}
+        for version in versions:
+            profile = self.data.local.user.get_profile(self.game, version, userid)
+            if profile is None:
+                # No profile for this version, so no rivals either.
+                continue
+            profiles[version] = profile
+            rivals[version] = [
+                link for link in self.data.local.user.get_links(self.game, version, userid)
+                if link.type in self.valid_rival_types
+            ]
+            for rival in rivals[version]:
+                userids.add(rival.other_userid)
+
+        return (
+            {version: [self.format_rival(rival, profiles[version]) for rival in rivals[version]] for version in rivals},
+            self.get_all_player_info(list(userids), allow_remote=True),
+        )
diff --git a/bemani/frontend/bishi/__init__.py b/bemani/frontend/bishi/__init__.py
new file mode 100644
index 0000000..bac7767
--- /dev/null
+++ b/bemani/frontend/bishi/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.bishi.endpoints import bishi_pages
+from bemani.frontend.bishi.cache import BishiBashiCache
diff --git a/bemani/frontend/bishi/bishi.py b/bemani/frontend/bishi/bishi.py
new file mode 100644
index 0000000..fe196b3
--- /dev/null
+++ b/bemani/frontend/bishi/bishi.py
@@ -0,0 +1,88 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, Iterator, Tuple
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.backend.bishi import BishiBashiFactory
+from bemani.common import ValidatedDict, ID, GameConstants
+from bemani.data import Data
+from bemani.frontend.base import FrontendBase
+
+
+class BishiBashiFrontend(FrontendBase):
+
+    game = GameConstants.BISHI_BASHI
+
+    def __init__(self, data: Data, config: Dict[str, Any], cache: Cache) -> None:
+        super().__init__(data, config, cache)
+        self.machines: Dict[int, str] = {}
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from BishiBashiFactory.all_games()
+
+    def __update_value(self, oldvalue: str, newvalue: bytes) -> str:
+        try:
+            newstr = newvalue.decode('shift-jis')
+        except Exception:
+            newstr = ''
+        if len(newstr) == 0:
+            return oldvalue
+        else:
+            return newstr
+
+    def sanitize_name(self, name: str) -> str:
+        if len(name) == 0:
+            return 'なし'
+        return name
+
+    def update_name(self, profile: ValidatedDict, name: str) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        for i in range(len(newprofile['strdatas'])):
+            strdata = newprofile['strdatas'][i]
+
+            # Figure out the profile type
+            csvs = strdata.split(b',')
+            if len(csvs) < 2:
+                # Not long enough to care about
+                continue
+            datatype = csvs[1].decode('ascii')
+            if datatype != 'IBBDAT00':
+                # Not the right profile type requested
+                continue
+            csvs[27] = name.encode('shift-jis')
+            newprofile['strdatas'][i] = b','.join(csvs)
+
+        return newprofile
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        name = 'なし'  # Nothing
+        shop = '未設定'  # Not set
+        shop_area = '未設定'  # Not set
+
+        for i in range(len(profile['strdatas'])):
+            strdata = profile['strdatas'][i]
+
+            # Figure out the profile type
+            csvs = strdata.split(b',')
+            if len(csvs) < 2:
+                # Not long enough to care about
+                continue
+            datatype = csvs[1].decode('ascii')
+            if datatype != 'IBBDAT00':
+                # Not the right profile type requested
+                continue
+
+            name = self.__update_value(name, csvs[27])
+            shop = self.__update_value(shop, csvs[30])
+            shop_area = self.__update_value(shop_area, csvs[31])
+
+        return {
+            'name': name,
+            'extid': ID.format_extid(profile.get_int('extid')),
+            'shop': shop,
+            'shop_area': shop_area,
+            'first_play_time': playstats.get_int('first_play_timestamp'),
+            'last_play_time': playstats.get_int('last_play_timestamp'),
+            'plays': playstats.get_int('total_plays'),
+        }
diff --git a/bemani/frontend/bishi/cache.py b/bemani/frontend/bishi/cache.py
new file mode 100644
index 0000000..5ed0526
--- /dev/null
+++ b/bemani/frontend/bishi/cache.py
@@ -0,0 +1,10 @@
+from typing import Dict, Any
+
+from bemani.data import Data
+
+
+class BishiBashiCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        pass
diff --git a/bemani/frontend/bishi/endpoints.py b/bemani/frontend/bishi/endpoints.py
new file mode 100644
index 0000000..a9d3952
--- /dev/null
+++ b/bemani/frontend/bishi/endpoints.py
@@ -0,0 +1,174 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.bishi.bishi import BishiBashiFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+
+bishi_pages = Blueprint(
+    'bishi_pages',
+    __name__,
+    url_prefix='/bishi',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@bishi_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = BishiBashiFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All BishiBashi Players',
+        'bishi/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('bishi_pages.listplayers'),
+            'player': url_for('bishi_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@bishi_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = BishiBashiFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@bishi_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = BishiBashiFrontend(g.data, g.config, g.cache)
+    djinfo = frontend.get_all_player_info([userid])[userid]
+    if not djinfo:
+        abort(404)
+    latest_version = sorted(djinfo.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s BishiBashi Profile'.format(djinfo[latest_version]['name']),
+        'bishi/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': djinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('bishi_pages.listplayer', userid=userid),
+        },
+    )
+
+
+@bishi_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = BishiBashiFrontend(g.data, g.config, g.cache)
+    djinfo = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': djinfo,
+    }
+
+
+@bishi_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = BishiBashiFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    djinfo = frontend.get_all_player_info([userid])[userid]
+    if not djinfo:
+        abort(404)
+
+    return render_react(
+        'BishiBashi Game Settings',
+        'bishi/settings.react.js',
+        {
+            'player': djinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('bishi_pages.updatename'),
+        },
+    )
+
+
+@bishi_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    frontend = BishiBashiFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update dj name
+    profile = g.data.local.user.get_profile(GameConstants.BISHI_BASHI, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 6:
+        raise Exception('Invalid profile name!')
+
+    # Convert lowercase to uppercase. We allow lowercase widetext in
+    # the JS frontend to allow for Windows IME input of hiragana/katakana.
+    def conv(char: str) -> str:
+        i = ord(char)
+        if i >= 0xFF41 and i <= 0xFF5A:
+            return chr(i - (0xFF41 - 0xFF21))
+        else:
+            return char
+    name = ''.join([conv(a) for a in name])
+
+    if re.match(
+        "^[" +
+        "\uFF20-\uFF3A" +  # widetext A-Z, @
+        "\uFF10-\uFF19" +  # widetext 0-9
+        "\u3041-\u308D\u308F\u3092\u3093" +  # hiragana
+        "\u30A1-\u30ED\u30EF\u30F2\u30F3\u30FC" +  # katakana
+        "\u3000" +  # widetext blank space
+        "\u301C" +  # widetext ~
+        "\u30FB" +  # widetext middot
+        "\u30FC" +  # widetext long dash
+        "\u2212" +  # widetext short dash
+        "\u2605" +  # widetext heavy star
+        "\uFF01" +  # widetext !
+        "\uFF03" +  # widetext #
+        "\uFF04" +  # widetext $
+        "\uFF05" +  # widetext %
+        "\uFF06" +  # widetext &
+        "\uFF08" +  # widetext (
+        "\uFF09" +  # widetext )
+        "\uFF0A" +  # widetext *
+        "\uFF0B" +  # widetext +
+        "\uFF0F" +  # widetext /
+        "\uFF1C" +  # widetext <
+        "\uFF1D" +  # widetext =
+        "\uFF1E" +  # widetext >
+        "\uFF1F" +  # widetext ?
+        "\uFFE5" +  # widetext Yen symbol
+        "]*$",
+        name,
+    ) is None:
+        raise Exception('Invalid profile name!')
+    profile = frontend.update_name(profile, name)
+    g.data.local.user.put_profile(GameConstants.BISHI_BASHI, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': frontend.sanitize_name(name),
+    }
diff --git a/bemani/frontend/ddr/__init__.py b/bemani/frontend/ddr/__init__.py
new file mode 100644
index 0000000..6955dd3
--- /dev/null
+++ b/bemani/frontend/ddr/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.ddr.endpoints import ddr_pages
+from bemani.frontend.ddr.cache import DDRCache
diff --git a/bemani/frontend/ddr/cache.py b/bemani/frontend/ddr/cache.py
new file mode 100644
index 0000000..0ea595c
--- /dev/null
+++ b/bemani/frontend/ddr/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.ddr.ddr import DDRFrontend
+
+
+class DDRCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = DDRFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/ddr/ddr.py b/bemani/frontend/ddr/ddr.py
new file mode 100644
index 0000000..6a48eca
--- /dev/null
+++ b/bemani/frontend/ddr/ddr.py
@@ -0,0 +1,260 @@
+# vim: set fileencoding=utf-8
+import copy
+from typing import Any, Dict, Iterator, Tuple
+
+from bemani.backend.ddr import DDRFactory, DDRBase
+from bemani.common import ValidatedDict, GameConstants, VersionConstants
+from bemani.data import Attempt, Link, RemoteUser, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class DDRFrontend(FrontendBase):
+
+    game = GameConstants.DDR
+
+    version = 0  # We use a virtual version for DDR to tie charts together
+
+    valid_charts = [
+        DDRBase.CHART_SINGLE_BEGINNER,
+        DDRBase.CHART_SINGLE_BASIC,
+        DDRBase.CHART_SINGLE_DIFFICULT,
+        DDRBase.CHART_SINGLE_EXPERT,
+        DDRBase.CHART_SINGLE_CHALLENGE,
+        DDRBase.CHART_DOUBLE_BASIC,
+        DDRBase.CHART_DOUBLE_DIFFICULT,
+        DDRBase.CHART_DOUBLE_EXPERT,
+        DDRBase.CHART_DOUBLE_CHALLENGE,
+    ]
+
+    valid_rival_types = ['friend_{}'.format(i) for i in range(10)]
+
+    max_active_rivals = {
+        VersionConstants.DDR_X2: 1,
+        VersionConstants.DDR_X3_VS_2NDMIX: 3,
+        VersionConstants.DDR_2013: 3,
+        VersionConstants.DDR_2014: 3,
+        VersionConstants.DDR_ACE: 3,
+        VersionConstants.DDR_A20: 3,
+    }
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from DDRFactory.all_games()
+
+    def update_name(self, profile: ValidatedDict, name: str) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        newprofile.replace_str('name', name)
+        return newprofile
+
+    def update_weight(self, profile: ValidatedDict, weight: int, enabled: bool) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        if newprofile.get_int('version') in (VersionConstants.DDR_ACE, VersionConstants.DDR_A20):
+            if enabled:
+                newprofile.replace_int('weight', weight)
+                newprofile.replace_bool('workout_mode', True)
+            else:
+                newprofile.replace_int('weight', 0)
+                newprofile.replace_bool('workout_mode', False)
+        else:
+            if enabled:
+                newprofile.replace_int('weight', weight)
+            else:
+                if 'weight' in newprofile:
+                    del newprofile['weight']
+        return newprofile
+
+    def update_early_late(self, profile: ValidatedDict, display_early_late: bool) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        newprofile.replace_int('early_late', 1 if display_early_late else 0)
+        return newprofile
+
+    def update_background_combo(self, profile: ValidatedDict, background_combo: bool) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        newprofile.replace_int('combo', 1 if background_combo else 0)
+        return newprofile
+
+    def update_settings(self, profile: ValidatedDict, new_settings: Dict[str, Any]) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        if newprofile.get_int('version') in (VersionConstants.DDR_ACE, VersionConstants.DDR_A20):
+            newprofile.replace_int('arrowskin', new_settings['arrowskin'])
+            newprofile.replace_int('guidelines', new_settings['guidelines'])
+            newprofile.replace_int('filter', new_settings['filter'])
+            newprofile.replace_int('character', new_settings['character'])
+        else:
+            # No other versions have extra options yet.
+            pass
+        return newprofile
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        if profile.get_int('version') in (VersionConstants.DDR_ACE, VersionConstants.DDR_A20):
+            formatted_profile.update({
+                'sp': playstats.get_int('single_plays'),
+                'dp': playstats.get_int('double_plays'),
+                'early_late': profile.get_int('early_late') != 0,
+                'background_combo': profile.get_int('combo') != 0,
+                'workout_mode': profile.get_bool('workout_mode'),
+                'weight': profile.get_int('weight'),
+                'settings': {
+                    'arrowskin': profile.get_int('arrowskin'),
+                    'guidelines': profile.get_int('guidelines'),
+                    'filter': profile.get_int('filter'),
+                    'character': profile.get_int('character'),
+                },
+            })
+        else:
+            formatted_profile.update({
+                'sp': playstats.get_int('single_plays'),
+                'dp': playstats.get_int('double_plays'),
+                'early_late': profile.get_int('early_late') != 0,
+                'background_combo': profile.get_int('combo') != 0,
+                'workout_mode': 'weight' in profile,
+                'weight': profile.get_int('weight'),
+            })
+        return formatted_profile
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['combo'] = score.data.get_int('combo')
+        formatted_score['lamp'] = score.data.get_int('halo')
+        formatted_score['halo'] = {
+            DDRBase.HALO_NONE: None,
+            DDRBase.HALO_GOOD_FULL_COMBO: "GOOD FULL COMBO",
+            DDRBase.HALO_GREAT_FULL_COMBO: "GREAT FULL COMBO",
+            DDRBase.HALO_PERFECT_FULL_COMBO: "PERFECT FULL COMBO",
+            DDRBase.HALO_MARVELOUS_FULL_COMBO: "MARVELOUS FULL COMBO",
+        }.get(score.data.get_int('halo'))
+        formatted_score['status'] = score.data.get_int('rank')
+        formatted_score['rank'] = {
+            DDRBase.RANK_AAA: "AAA",
+            DDRBase.RANK_AA_PLUS: "AA+",
+            DDRBase.RANK_AA: "AA",
+            DDRBase.RANK_AA_MINUS: "AA-",
+            DDRBase.RANK_A_PLUS: "A+",
+            DDRBase.RANK_A: "A",
+            DDRBase.RANK_A_MINUS: "A-",
+            DDRBase.RANK_B_PLUS: "B+",
+            DDRBase.RANK_B: "B",
+            DDRBase.RANK_B_MINUS: "B-",
+            DDRBase.RANK_C_PLUS: "C+",
+            DDRBase.RANK_C: "C",
+            DDRBase.RANK_C_MINUS: "C-",
+            DDRBase.RANK_D_PLUS: "D+",
+            DDRBase.RANK_D: "D",
+            DDRBase.RANK_E: "E",
+        }.get(score.data.get_int('rank'), 'NO PLAY')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['combo'] = attempt.data.get_int('combo')
+        formatted_attempt['halo'] = {
+            DDRBase.HALO_NONE: None,
+            DDRBase.HALO_GOOD_FULL_COMBO: "GOOD FULL COMBO",
+            DDRBase.HALO_GREAT_FULL_COMBO: "GREAT FULL COMBO",
+            DDRBase.HALO_PERFECT_FULL_COMBO: "PERFECT FULL COMBO",
+            DDRBase.HALO_MARVELOUS_FULL_COMBO: "MARVELOUS FULL COMBO",
+        }.get(attempt.data.get_int('halo'))
+        formatted_attempt['rank'] = {
+            DDRBase.RANK_AAA: "AAA",
+            DDRBase.RANK_AA_PLUS: "AA+",
+            DDRBase.RANK_AA: "AA",
+            DDRBase.RANK_AA_MINUS: "AA-",
+            DDRBase.RANK_A_PLUS: "A+",
+            DDRBase.RANK_A: "A",
+            DDRBase.RANK_A_MINUS: "A-",
+            DDRBase.RANK_B_PLUS: "B+",
+            DDRBase.RANK_B: "B",
+            DDRBase.RANK_B_MINUS: "B-",
+            DDRBase.RANK_C_PLUS: "C+",
+            DDRBase.RANK_C: "C",
+            DDRBase.RANK_C_MINUS: "C-",
+            DDRBase.RANK_D_PLUS: "D+",
+            DDRBase.RANK_D: "D",
+            DDRBase.RANK_E: "E",
+        }.get(attempt.data.get_int('rank'), 'NO PLAY')
+        return formatted_attempt
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0] * 10
+        difficulties[song.chart] = song.data.get_int('difficulty', 20)
+
+        formatted_song = super().format_song(song)
+        formatted_song['bpm_min'] = song.data.get_int('bpm_min', 120)
+        formatted_song['bpm_max'] = song.data.get_int('bpm_max', 120)
+        formatted_song['category'] = song.data.get_int('category', 0)
+        formatted_song['groove'] = song.data.get_dict('groove', {
+            'voltage': 0,
+            'stream': 0,
+            'air': 0,
+            'chaos': 0,
+            'freeze': 0,
+        })
+        formatted_song['difficulties'] = difficulties
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if (
+            existing['difficulties'][new.chart] == 0
+        ):
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 20)
+        return new_song
+
+    def activate_rival(self, profile: ValidatedDict, position: int) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        if newprofile.get_int('version') == VersionConstants.DDR_X2:
+            # X2 only has one active rival
+            lastdict = newprofile.get_dict('last')
+            lastdict.replace_int('fri', position + 1)
+            newprofile.replace_dict('last', lastdict)
+        elif newprofile.get_int('version') in [VersionConstants.DDR_X3_VS_2NDMIX, VersionConstants.DDR_2013, VersionConstants.DDR_2014, VersionConstants.DDR_ACE, VersionConstants.DDR_A20]:
+            # X3 has 3 active rivals, put this in the first open slot
+            lastdict = newprofile.get_dict('last')
+            if lastdict.get_int('rival1') < 1:
+                lastdict.replace_int('rival1', position + 1)
+            elif lastdict.get_int('rival2') < 1:
+                lastdict.replace_int('rival2', position + 1)
+            elif lastdict.get_int('rival3') < 1:
+                lastdict.replace_int('rival3', position + 1)
+            newprofile.replace_dict('last', lastdict)
+        return newprofile
+
+    def deactivate_rival(self, profile: ValidatedDict, position: int) -> ValidatedDict:
+        newprofile = copy.deepcopy(profile)
+        if newprofile.get_int('version') == VersionConstants.DDR_X2:
+            # X2 only has one active rival
+            lastdict = newprofile.get_dict('last')
+            if lastdict.get_int('fri') == position + 1:
+                lastdict.replace_int('fri', 0)
+            newprofile.replace_dict('last', lastdict)
+        elif newprofile.get_int('version') in [VersionConstants.DDR_X3_VS_2NDMIX, VersionConstants.DDR_2013, VersionConstants.DDR_2014, VersionConstants.DDR_ACE, VersionConstants.DDR_A20]:
+            # X3 has 3 active rivals, put this in the first open slot
+            lastdict = newprofile.get_dict('last')
+            if lastdict.get_int('rival1') == position + 1:
+                lastdict.replace_int('rival1', 0)
+            elif lastdict.get_int('rival2') == position + 1:
+                lastdict.replace_int('rival2', 0)
+            elif lastdict.get_int('rival3') == position + 1:
+                lastdict.replace_int('rival3', 0)
+            newprofile.replace_dict('last', lastdict)
+        return newprofile
+
+    def format_rival(self, link: Link, profile: ValidatedDict) -> Dict[str, Any]:
+        pos = int(link.type[7:])
+        if profile.get_int('version') == VersionConstants.DDR_X2:
+            active = pos == (profile.get_dict('last').get_int('fri') - 1)
+        elif profile.get_int('version') in [VersionConstants.DDR_X3_VS_2NDMIX, VersionConstants.DDR_2013, VersionConstants.DDR_2014, VersionConstants.DDR_ACE, VersionConstants.DDR_A20]:
+            actives = [
+                profile.get_dict('last').get_int('rival1') - 1,
+                profile.get_dict('last').get_int('rival2') - 1,
+                profile.get_dict('last').get_int('rival3') - 1,
+            ]
+            active = pos in actives
+        else:
+            active = False
+        return {
+            'position': pos,
+            'active': active,
+            'userid': str(link.other_userid),
+            'remote': RemoteUser.is_remote(link.other_userid),
+        }
diff --git a/bemani/frontend/ddr/endpoints.py b/bemani/frontend/ddr/endpoints.py
new file mode 100644
index 0000000..187a528
--- /dev/null
+++ b/bemani/frontend/ddr/endpoints.py
@@ -0,0 +1,647 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict, List, Optional
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import ID, GameConstants
+from bemani.data import Link, UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.ddr.ddr import DDRFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+ddr_pages = Blueprint(
+    'ddr_pages',
+    __name__,
+    url_prefix='/ddr',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@ddr_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global DDR Scores',
+        'ddr/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'shownames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('ddr_pages.listnetworkscores'),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+            'individual_score': url_for('ddr_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@ddr_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@ddr_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        '{}\'s DDR Scores'.format(info['name']),
+        'ddr/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'shownames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('ddr_pages.listscores', userid=userid),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+            'individual_score': url_for('ddr_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@ddr_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@ddr_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+
+    return render_react(
+        'Global DDR Records',
+        'ddr/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'shownames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('ddr_pages.listnetworkrecords'),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+            'individual_score': url_for('ddr_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@ddr_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@ddr_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    return render_react(
+        '{}\'s DDR Records'.format(info['name']),
+        'ddr/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'shownames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('ddr_pages.listrecords', userid=userid),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+            'individual_score': url_for('ddr_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@ddr_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@ddr_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    name = None
+    artist = None
+    genre = None
+    difficulties: List[int] = [0] * 10
+    groove: List[Dict[str, int]] = [{}] * 10
+
+    for chart in frontend.valid_charts:
+        details = g.data.local.music.get_song(GameConstants.DDR, 0, musicid, chart)
+        if details is not None:
+            name = details.name
+            artist = details.artist
+            genre = details.genre
+            difficulties[chart] = details.data.get_int('difficulty', 13)
+            groove[chart] = details.data.get_dict('groove')
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top DDR Scores for {} - {}'.format(artist, name),
+        'ddr/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'genre': genre,
+            'difficulties': difficulties,
+            'groove': groove,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('ddr_pages.listtopscores', musicid=musicid),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@ddr_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@ddr_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All DDR Players',
+        'ddr/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('ddr_pages.listplayers'),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@ddr_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@ddr_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+    latest_version = sorted(info.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s DDR Profile'.format(info[latest_version]['name']),
+        'ddr/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('ddr_pages.listplayer', userid=userid),
+            'records': url_for('ddr_pages.viewrecords', userid=userid),
+            'scores': url_for('ddr_pages.viewscores', userid=userid),
+        },
+    )
+
+
+@ddr_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': info,
+    }
+
+
+@ddr_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+
+    return render_react(
+        'DDR Game Settings',
+        'ddr/settings.react.js',
+        {
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('ddr_pages.updatename'),
+            'updateweight': url_for('ddr_pages.updateweight'),
+            'updateearlylate': url_for('ddr_pages.updateearlylate'),
+            'updatebackgroundcombo': url_for('ddr_pages.updatebackgroundcombo'),
+            'updatesettings': url_for('ddr_pages.updatesettings'),
+        },
+    )
+
+
+@ddr_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update name
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 8:
+        raise Exception('Invalid profile name!')
+    if re.match(r'^[-&$\\.\\?!A-Z0-9 ]*$', name) is None:
+        raise Exception('Invalid profile name!')
+    profile = frontend.update_name(profile, name)
+    g.data.local.user.put_profile(GameConstants.DDR, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
+
+
+@ddr_pages.route('/options/weight/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updateweight() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    weight = int(float(request.get_json()['weight']) * 10)
+    enabled = request.get_json()['enabled']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update weight
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if enabled:
+        if weight <= 0 or weight > 9999:
+            raise Exception('Invalid weight!')
+    profile = frontend.update_weight(profile, weight, enabled)
+    g.data.local.user.put_profile(GameConstants.DDR, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'weight': weight,
+        'enabled': enabled,
+    }
+
+
+@ddr_pages.route('/options/earlylate/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updateearlylate() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    value = request.get_json()['value']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update early/late indicator
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile = frontend.update_early_late(profile, value)
+    g.data.local.user.put_profile(GameConstants.DDR, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'value': value != 0,
+    }
+
+
+@ddr_pages.route('/options/backgroundcombo/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatebackgroundcombo() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    value = request.get_json()['value']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update combo position
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile = frontend.update_background_combo(profile, value)
+    g.data.local.user.put_profile(GameConstants.DDR, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'value': value != 0,
+    }
+
+
+@ddr_pages.route('/options/settings/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatesettings() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    settings = request.get_json()['settings']
+    version = int(request.get_json()['version'])
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and settings dict that needs updating
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile = frontend.update_settings(profile, settings)
+    g.data.local.user.put_profile(GameConstants.DDR, version, user.id, profile)
+
+    # Return updated settings
+    info = frontend.get_all_player_info([user.id])[user.id]
+    return {
+        'player': info,
+        'version': version,
+    }
+
+
+@ddr_pages.route('/rivals')
+@loginrequired
+def viewrivals() -> Response:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    rivals, info = frontend.get_rivals(g.userID)
+
+    return render_react(
+        'DDR Rivals',
+        'ddr/rivals.react.js',
+        {
+            'userid': str(g.userID),
+            'rivals': rivals,
+            'max_active_rivals': frontend.max_active_rivals,
+            'players': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('ddr_pages.listrivals'),
+            'search': url_for('ddr_pages.searchrivals'),
+            'player': url_for('ddr_pages.viewplayer', userid=-1),
+            'addrival': url_for('ddr_pages.addrival'),
+            'removerival': url_for('ddr_pages.removerival'),
+            'setactiverival': url_for('ddr_pages.setactiverival'),
+            'setinactiverival': url_for('ddr_pages.setinactiverival'),
+        },
+    )
+
+
+@ddr_pages.route('/rivals/list')
+@jsonify
+@loginrequired
+def listrivals() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    rivals, info = frontend.get_rivals(g.userID)
+
+    return {
+        'rivals': rivals,
+        'players': info,
+    }
+
+
+@ddr_pages.route('/rivals/search', methods=['POST'])
+@jsonify
+@loginrequired
+def searchrivals() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    name = request.get_json()['term']
+
+    # Try to treat the term as an extid
+    extid = ID.parse_extid(name)
+
+    matches = set()
+    profiles = g.data.remote.user.get_all_profiles(GameConstants.DDR, version)
+    for (userid, profile) in profiles:
+        if profile.get_int('extid') == extid or profile.get_str('name').lower() == name.lower():
+            matches.add(userid)
+
+    info = frontend.get_all_player_info(list(matches), allow_remote=True)
+    return {
+        'results': info,
+    }
+
+
+@ddr_pages.route('/rivals/add', methods=['POST'])
+@jsonify
+@loginrequired
+def addrival() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Find a slot to put the rival into
+    occupied: List[Optional[Link]] = [None] * 10
+    for link in g.data.local.user.get_links(GameConstants.DDR, version, userid):
+        if link.type[:7] != 'friend_':
+            continue
+
+        pos = int(link.type[7:])
+        if pos >= 0 and pos < 10:
+            occupied[pos] = link
+
+    # Put rival in the first slot
+    newrivalpos = -1
+    for i in range(len(occupied)):
+        if occupied[i] is None:
+            newrivalpos = i
+            break
+
+    if newrivalpos == -1:
+        raise Exception('No room for another rival!')
+
+    # Add this rival link
+    profile = g.data.remote.user.get_profile(GameConstants.DDR, version, other_userid)
+    if profile is None:
+        raise Exception('Unable to find profile for rival!')
+
+    g.data.local.user.put_link(
+        GameConstants.DDR,
+        version,
+        userid,
+        'friend_{}'.format(newrivalpos),
+        other_userid,
+        {},
+    )
+
+    # Now return updated rival info
+    rivals, info = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': info,
+    }
+
+
+@ddr_pages.route('/rivals/remove', methods=['POST'])
+@jsonify
+@loginrequired
+def removerival() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    other_userid = UserID(int(request.get_json()['userid']))
+    position = int(request.get_json()['position'])
+    userid = g.userID
+
+    # Remove this rival link
+    g.data.local.user.destroy_link(
+        GameConstants.DDR,
+        version,
+        userid,
+        'friend_{}'.format(position),
+        other_userid,
+    )
+
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, userid)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile = frontend.deactivate_rival(profile, position)
+    g.data.local.user.put_profile(GameConstants.DDR, version, userid, profile)
+
+    # Now return updated rival info
+    rivals, info = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': info,
+    }
+
+
+@ddr_pages.route('/rivals/activate', methods=['POST'])
+@jsonify
+@loginrequired
+def setactiverival() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    position = int(request.get_json()['position'])
+    userid = g.userID
+
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, userid)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile = frontend.activate_rival(profile, position)
+    g.data.local.user.put_profile(GameConstants.DDR, version, userid, profile)
+
+    # Now return updated rival info
+    rivals, info = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': info,
+    }
+
+
+@ddr_pages.route('/rivals/inactivate', methods=['POST'])
+@jsonify
+@loginrequired
+def setinactiverival() -> Dict[str, Any]:
+    frontend = DDRFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    position = int(request.get_json()['position'])
+    userid = g.userID
+
+    profile = g.data.local.user.get_profile(GameConstants.DDR, version, userid)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile = frontend.deactivate_rival(profile, position)
+    g.data.local.user.put_profile(GameConstants.DDR, version, userid, profile)
+
+    # Now return updated rival info
+    rivals, info = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': info,
+    }
diff --git a/bemani/frontend/home/__init__.py b/bemani/frontend/home/__init__.py
new file mode 100644
index 0000000..b7b7399
--- /dev/null
+++ b/bemani/frontend/home/__init__.py
@@ -0,0 +1 @@
+from bemani.frontend.home.home import home_pages
diff --git a/bemani/frontend/home/home.py b/bemani/frontend/home/home.py
new file mode 100644
index 0000000..020180a
--- /dev/null
+++ b/bemani/frontend/home/home.py
@@ -0,0 +1,34 @@
+from flask import Blueprint, Response, g  # type: ignore
+from typing import Dict, Any
+
+from bemani.data import News
+from bemani.frontend.app import loginrequired, render_react
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+home_pages = Blueprint(
+    'home_pages',
+    __name__,
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+def format_news(news: News) -> Dict[str, Any]:
+    return {
+        'timestamp': news.timestamp,
+        'title': news.title,
+        'body': news.body,
+    }
+
+
+@home_pages.route('/')
+@loginrequired
+def viewhome() -> Response:
+    return render_react(
+        g.config.get('name', 'e-AMUSEMENT Network'),
+        'home.react.js',
+        {
+            'news': [format_news(news) for news in g.data.local.network.get_all_news()],
+        }
+    )
diff --git a/bemani/frontend/iidx/__init__.py b/bemani/frontend/iidx/__init__.py
new file mode 100644
index 0000000..8c8a0bd
--- /dev/null
+++ b/bemani/frontend/iidx/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.iidx.endpoints import iidx_pages
+from bemani.frontend.iidx.cache import IIDXCache
diff --git a/bemani/frontend/iidx/cache.py b/bemani/frontend/iidx/cache.py
new file mode 100644
index 0000000..73cf839
--- /dev/null
+++ b/bemani/frontend/iidx/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.iidx.iidx import IIDXFrontend
+
+
+class IIDXCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = IIDXFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/iidx/endpoints.py b/bemani/frontend/iidx/endpoints.py
new file mode 100644
index 0000000..d9e2bf5
--- /dev/null
+++ b/bemani/frontend/iidx/endpoints.py
@@ -0,0 +1,611 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import ID, GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.iidx.iidx import IIDXFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+iidx_pages = Blueprint(
+    'iidx_pages',
+    __name__,
+    url_prefix='/iidx',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@iidx_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global IIDX Scores',
+        'iidx/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'showdjnames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('iidx_pages.listnetworkscores'),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('iidx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@iidx_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@iidx_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    djinfo = frontend.get_latest_player_info([userid]).get(userid)
+    if djinfo is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        'dj {}\'s IIDX Scores'.format(djinfo['name']),
+        'iidx/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'showdjnames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('iidx_pages.listscores', userid=userid),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('iidx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@iidx_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@iidx_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+
+    return render_react(
+        'Global IIDX Records',
+        'iidx/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'showdjnames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('iidx_pages.listnetworkrecords'),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('iidx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@iidx_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@iidx_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    djinfo = frontend.get_latest_player_info([userid]).get(userid)
+    if djinfo is None:
+        abort(404)
+
+    return render_react(
+        'dj {}\'s IIDX Records'.format(djinfo['name']),
+        'iidx/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+            'showdjnames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('iidx_pages.listrecords', userid=userid),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('iidx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@iidx_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@iidx_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    versions = sorted(
+        [version for (game, version, name) in frontend.all_games()],
+        reverse=True,
+    )
+    name = None
+    artist = None
+    genre = None
+    difficulties = [0, 0, 0, 0, 0, 0]
+    notecounts = [0, 0, 0, 0, 0, 0]
+
+    for version in versions:
+        for omniadd in [0, 10000]:
+            for chart in [0, 1, 2, 3, 4, 5]:
+                details = g.data.local.music.get_song(GameConstants.IIDX, version + omniadd, musicid, chart)
+                if details is not None:
+                    name = details.name
+                    artist = details.artist
+                    genre = details.genre
+                    difficulties[chart] = details.data.get_int('difficulty', 13)
+                    notecounts[chart] = details.data.get_int('notecount', 5730)
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top IIDX Scores for {} - {}'.format(artist, name),
+        'iidx/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'genre': genre,
+            'difficulties': difficulties,
+            'notecounts': notecounts,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('iidx_pages.listtopscores', musicid=musicid),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@iidx_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@iidx_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All IIDX Players',
+        'iidx/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('iidx_pages.listplayers'),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@iidx_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@iidx_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    djinfo = frontend.get_all_player_info([userid])[userid]
+    if not djinfo:
+        abort(404)
+    latest_version = sorted(djinfo.keys(), reverse=True)[0]
+
+    for version in djinfo:
+        sp_rival = g.data.local.user.get_link(GameConstants.IIDX, version, g.userID, 'sp_rival', userid)
+        dp_rival = g.data.local.user.get_link(GameConstants.IIDX, version, g.userID, 'dp_rival', userid)
+        djinfo[version]['sp_rival'] = sp_rival is not None
+        djinfo[version]['dp_rival'] = dp_rival is not None
+
+    return render_react(
+        'dj {}\'s IIDX Profile'.format(djinfo[latest_version]['name']),
+        'iidx/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': djinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('iidx_pages.listplayer', userid=userid),
+            'records': url_for('iidx_pages.viewrecords', userid=userid),
+            'scores': url_for('iidx_pages.viewscores', userid=userid),
+            'addrival': url_for('iidx_pages.addrival'),
+            'removerival': url_for('iidx_pages.removerival'),
+        },
+    )
+
+
+@iidx_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    djinfo = frontend.get_all_player_info([userid])[userid]
+
+    for version in djinfo:
+        sp_rival = g.data.local.user.get_link(GameConstants.IIDX, version, g.userID, 'sp_rival', userid)
+        dp_rival = g.data.local.user.get_link(GameConstants.IIDX, version, g.userID, 'dp_rival', userid)
+        djinfo[version]['sp_rival'] = sp_rival is not None
+        djinfo[version]['dp_rival'] = dp_rival is not None
+
+    return {
+        'player': djinfo,
+    }
+
+
+@iidx_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    djinfo = frontend.get_all_player_info([userid])[userid]
+    if not djinfo:
+        abort(404)
+
+    return render_react(
+        'IIDX Game Settings',
+        'iidx/settings.react.js',
+        {
+            'player': djinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updateflags': url_for('iidx_pages.updateflags'),
+            'updatesettings': url_for('iidx_pages.updatesettings'),
+            'updatename': url_for('iidx_pages.updatename'),
+            'updateprefecture': url_for('iidx_pages.updateprefecture'),
+            'leavearcade': url_for('iidx_pages.leavearcade'),
+        },
+    )
+
+
+@iidx_pages.route('/options/flags/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updateflags() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    flags = request.get_json()['flags']
+    version = int(request.get_json()['version'])
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and settings dict that needs updating
+    profile = g.data.local.user.get_profile(GameConstants.IIDX, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    settings_dict = profile.get_dict('settings')
+
+    # Set bits for flags based on frontend
+    flagint = 0
+    flagint += 0x001 if flags['grade'] else 0
+    flagint += 0x002 if flags['status'] else 0
+    flagint += 0x004 if flags['difficulty'] else 0
+    flagint += 0x008 if flags['alphabet'] else 0
+    flagint += 0x010 if flags['rival_played'] else 0
+    flagint += 0x040 if flags['rival_win_lose'] else 0
+    flagint += 0x080 if flags['rival_info'] else 0
+    flagint += 0x100 if flags['hide_play_count'] else 0
+    settings_dict.replace_int('flags', flagint)
+
+    # Update special case flags
+    settings_dict.replace_int('disable_song_preview', 1 if flags['disable_song_preview'] else 0)
+    settings_dict.replace_int('effector_lock', 1 if flags['effector_lock'] else 0)
+
+    # Update the settings dict
+    profile.replace_dict('settings', settings_dict)
+    g.data.local.user.put_profile(GameConstants.IIDX, version, user.id, profile)
+
+    # Return updated flags
+    return {
+        'flags': frontend.format_flags(settings_dict),
+        'version': version,
+    }
+
+
+@iidx_pages.route('/options/settings/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatesettings() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    settings = request.get_json()['settings']
+    version = int(request.get_json()['version'])
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and settings dict that needs updating
+    profile = g.data.local.user.get_profile(GameConstants.IIDX, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    settings_dict = profile.get_dict('settings')
+
+    for setting in settings:
+        settings_dict.replace_int(setting, settings[setting])
+
+    # Update the settings dict
+    profile.replace_dict('settings', settings_dict)
+    g.data.local.user.put_profile(GameConstants.IIDX, version, user.id, profile)
+
+    # Return updated settings
+    return {
+        'settings': frontend.format_settings(settings_dict),
+        'version': version,
+    }
+
+
+@iidx_pages.route('/options/arcade/leave', methods=['POST'])
+@jsonify
+@loginrequired
+def leavearcade() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and nuke the shop location
+    profile = g.data.local.user.get_profile(GameConstants.IIDX, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if 'shop_location' in profile:
+        del profile['shop_location']
+    g.data.local.user.put_profile(GameConstants.IIDX, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+    }
+
+
+@iidx_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update dj name
+    profile = g.data.local.user.get_profile(GameConstants.IIDX, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 6:
+        raise Exception('Invalid profile name!')
+    if re.match(r'^[-&$#\.\?\*!A-Z0-9]*$', name) is None:
+        raise Exception('Invalid profile name!')
+    profile.replace_str('name', name)
+    g.data.local.user.put_profile(GameConstants.IIDX, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
+
+
+@iidx_pages.route('/options/prefecture/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updateprefecture() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    prefecture = int(request.get_json()['prefecture'])
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update prefecture
+    profile = g.data.local.user.get_profile(GameConstants.IIDX, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    profile.replace_int('pid', prefecture)
+    g.data.local.user.put_profile(GameConstants.IIDX, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'prefecture': prefecture,
+    }
+
+
+@iidx_pages.route('/rivals')
+@loginrequired
+def viewrivals() -> Response:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    rivals, djinfo = frontend.get_rivals(g.userID)
+
+    return render_react(
+        'IIDX Rivals',
+        'iidx/rivals.react.js',
+        {
+            'userid': str(g.userID),
+            'rivals': rivals,
+            'players': djinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('iidx_pages.listrivals'),
+            'search': url_for('iidx_pages.searchrivals'),
+            'player': url_for('iidx_pages.viewplayer', userid=-1),
+            'addrival': url_for('iidx_pages.addrival'),
+            'removerival': url_for('iidx_pages.removerival'),
+        },
+    )
+
+
+@iidx_pages.route('/rivals/list')
+@jsonify
+@loginrequired
+def listrivals() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    rivals, djinfo = frontend.get_rivals(g.userID)
+
+    return {
+        'rivals': rivals,
+        'players': djinfo,
+    }
+
+
+@iidx_pages.route('/rivals/search', methods=['POST'])
+@jsonify
+@loginrequired
+def searchrivals() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    djname = request.get_json()['term']
+
+    # Try to treat the term as an extid
+    extid = ID.parse_extid(djname)
+
+    matches = set()
+    profiles = g.data.remote.user.get_all_profiles(GameConstants.IIDX, version)
+    for (userid, profile) in profiles:
+        if profile.get_int('extid') == extid or profile.get_str('name').lower() == djname.lower():
+            matches.add(userid)
+
+    djinfo = frontend.get_all_player_info(list(matches), allow_remote=True)
+    return {
+        'results': djinfo,
+    }
+
+
+@iidx_pages.route('/rivals/add', methods=['POST'])
+@jsonify
+@loginrequired
+def addrival() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    rivaltype = request.get_json()['type']
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Add this rival link
+    if rivaltype != 'sp_rival' and rivaltype != 'dp_rival':
+        raise Exception('Invalid rival type {}!'.format(rivaltype))
+    profile = g.data.remote.user.get_profile(GameConstants.IIDX, version, other_userid)
+    if profile is None:
+        raise Exception('Unable to find profile for rival!')
+
+    g.data.local.user.put_link(
+        GameConstants.IIDX,
+        version,
+        userid,
+        rivaltype,
+        other_userid,
+        {},
+    )
+
+    # Now return updated rival info
+    rivals, djinfo = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': djinfo,
+    }
+
+
+@iidx_pages.route('/rivals/remove', methods=['POST'])
+@jsonify
+@loginrequired
+def removerival() -> Dict[str, Any]:
+    frontend = IIDXFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    rivaltype = request.get_json()['type']
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Remove this rival link
+    if rivaltype != 'sp_rival' and rivaltype != 'dp_rival':
+        raise Exception('Invalid rival type {}!'.format(rivaltype))
+
+    g.data.local.user.destroy_link(
+        GameConstants.IIDX,
+        version,
+        userid,
+        rivaltype,
+        other_userid,
+    )
+
+    # Now return updated rival info
+    rivals, djinfo = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': djinfo,
+    }
diff --git a/bemani/frontend/iidx/iidx.py b/bemani/frontend/iidx/iidx.py
new file mode 100644
index 0000000..a52bfd5
--- /dev/null
+++ b/bemani/frontend/iidx/iidx.py
@@ -0,0 +1,234 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, Iterator, Optional, Tuple
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.backend.iidx import IIDXFactory, IIDXBase
+from bemani.common import ValidatedDict, GameConstants
+from bemani.data import Attempt, Data, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class IIDXFrontend(FrontendBase):
+
+    game = GameConstants.IIDX
+
+    valid_charts = [
+        IIDXBase.CHART_TYPE_N7,
+        IIDXBase.CHART_TYPE_H7,
+        IIDXBase.CHART_TYPE_A7,
+        IIDXBase.CHART_TYPE_N14,
+        IIDXBase.CHART_TYPE_H14,
+        IIDXBase.CHART_TYPE_A14,
+    ]
+
+    valid_rival_types = [
+        'sp_rival',
+        'dp_rival',
+    ]
+
+    def __init__(self, data: Data, config: Dict[str, Any], cache: Cache) -> None:
+        super().__init__(data, config, cache)
+        self.machines: Dict[int, str] = {}
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from IIDXFactory.all_games()
+
+    def get_duplicate_id(self, musicid: int, chart: int) -> Optional[Tuple[int, int]]:
+        modern_to_legacy_map = {
+            23066: 4213,
+            22068: 9203,
+            22052: 10203,
+            22039: 12201,
+            21201: 12204,
+            21064: 12206,
+            23077: 13215,
+            22025: 14202,
+            21068: 14210,
+            22069: 14211,
+            23070: 14214,
+            23069: 15202,
+            21063: 15204,
+            21065: 15205,
+            22028: 15207,
+            22049: 15208,
+            22043: 15209,
+            23060: 15211,
+            21062: 15215,
+            21067: 16207,
+            23062: 16209,
+            21066: 16212,
+            23030: 22096,
+            23051: 22097,
+        }
+        # Some charts were changed, and others kept the same on these
+        if chart in [0, 1, 2]:
+            modern_to_legacy_map[23065] = 9206
+        oldid = modern_to_legacy_map.get(musicid)
+        oldchart = chart
+        if oldid == 12204:
+            if oldchart == 1:
+                oldchart = 2
+            elif oldchart == 2:
+                oldchart = 1
+        if oldid is not None:
+            return (oldid, oldchart)
+        else:
+            return None
+
+    def format_dan_rank(self, rank: int) -> str:
+        if rank == -1:
+            return '--'
+
+        return {
+            IIDXBase.DAN_RANK_7_KYU: '七級',
+            IIDXBase.DAN_RANK_6_KYU: '六級',
+            IIDXBase.DAN_RANK_5_KYU: '五級',
+            IIDXBase.DAN_RANK_4_KYU: '四級',
+            IIDXBase.DAN_RANK_3_KYU: '三級',
+            IIDXBase.DAN_RANK_2_KYU: '二級',
+            IIDXBase.DAN_RANK_1_KYU: '一級',
+            IIDXBase.DAN_RANK_1_DAN: '初段',
+            IIDXBase.DAN_RANK_2_DAN: '二段',
+            IIDXBase.DAN_RANK_3_DAN: '三段',
+            IIDXBase.DAN_RANK_4_DAN: '四段',
+            IIDXBase.DAN_RANK_5_DAN: '五段',
+            IIDXBase.DAN_RANK_6_DAN: '六段',
+            IIDXBase.DAN_RANK_7_DAN: '七段',
+            IIDXBase.DAN_RANK_8_DAN: '八段',
+            IIDXBase.DAN_RANK_9_DAN: '九段',
+            IIDXBase.DAN_RANK_10_DAN: '十段',
+            IIDXBase.DAN_RANK_CHUDEN: '中伝',
+            IIDXBase.DAN_RANK_KAIDEN: '皆伝',
+        }[rank]
+
+    def format_flags(self, settings_dict: ValidatedDict) -> Dict[str, Any]:
+        flags = settings_dict.get_int('flags')
+        return {
+            'grade': (flags & 0x001) != 0,
+            'status': (flags & 0x002) != 0,
+            'difficulty': (flags & 0x004) != 0,
+            'alphabet': (flags & 0x008) != 0,
+            'rival_played': (flags & 0x010) != 0,
+            'rival_win_lose': (flags & 0x040) != 0,
+            'rival_info': (flags & 0x080) != 0,
+            'hide_play_count': (flags & 0x100) != 0,
+            'disable_song_preview': settings_dict.get_int('disable_song_preview') != 0,
+            'effector_lock': settings_dict.get_int('effector_lock') != 0,
+        }
+
+    def format_settings(self, settings_dict: ValidatedDict) -> Dict[str, Any]:
+        return {
+            'frame': settings_dict.get_int('frame'),
+            'turntable': settings_dict.get_int('turntable'),
+            'burst': settings_dict.get_int('burst'),
+            'bgm': settings_dict.get_int('bgm'),
+            'towel': settings_dict.get_int('towel'),
+            'judge_pos': settings_dict.get_int('judge_pos'),
+            'voice': settings_dict.get_int('voice'),
+            'noteskin': settings_dict.get_int('noteskin'),
+            'full_combo': settings_dict.get_int('full_combo'),
+            'beam': settings_dict.get_int('beam'),
+            'judge': settings_dict.get_int('judge'),
+            'pacemaker': settings_dict.get_int('pacemaker'),
+            'effector_preset': settings_dict.get_int('effector_preset'),
+        }
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        formatted_profile.update({
+            'arcade': "",
+            'prefecture': profile.get_int('pid', 51),
+            'settings': self.format_settings(profile.get_dict('settings')),
+            'flags': self.format_flags(profile.get_dict('settings')),
+            'sdjp': playstats.get_int('single_dj_points'),
+            'ddjp': playstats.get_int('double_dj_points'),
+            'sp': playstats.get_int('single_plays'),
+            'dp': playstats.get_int('double_plays'),
+            'sdan': self.format_dan_rank(profile.get_int('sgrade', -1)),
+            'ddan': self.format_dan_rank(profile.get_int('dgrade', -1)),
+            'srank': profile.get_int('sgrade', -1),
+            'drank': profile.get_int('dgrade', -1),
+        })
+        if 'shop_location' in profile:
+            shop_id = profile.get_int('shop_location')
+            if shop_id in self.machines:
+                formatted_profile['arcade'] = self.machines[shop_id]
+            else:
+                pcbid = self.data.local.machine.from_machine_id(shop_id)
+                if pcbid is not None:
+                    machine = self.data.local.machine.get_machine(pcbid)
+                    self.machines[shop_id] = machine.name
+                    formatted_profile['arcade'] = machine.name
+        return formatted_profile
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['miss_count'] = score.data.get_int('miss_count')
+        formatted_score['lamp'] = score.data.get_int('clear_status')
+        formatted_score['status'] = {
+            IIDXBase.CLEAR_STATUS_NO_PLAY: 'NO PLAY',
+            IIDXBase.CLEAR_STATUS_FAILED: 'FAILED',
+            IIDXBase.CLEAR_STATUS_ASSIST_CLEAR: 'ASSIST CLEAR',
+            IIDXBase.CLEAR_STATUS_EASY_CLEAR: 'EASY CLEAR',
+            IIDXBase.CLEAR_STATUS_CLEAR: 'CLEAR',
+            IIDXBase.CLEAR_STATUS_HARD_CLEAR: 'HARD CLEAR',
+            IIDXBase.CLEAR_STATUS_EX_HARD_CLEAR: 'EX HARD CLEAR',
+            IIDXBase.CLEAR_STATUS_FULL_COMBO: 'FULL COMBO',
+        }.get(score.data.get_int('clear_status'), 'NO PLAY')
+        return formatted_score
+
+    def format_top_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['miss_count'] = score.data.get_int('miss_count')
+        formatted_score['lamp'] = score.data.get_int('clear_status')
+        formatted_score['ghost'] = [x for x in (score.data.get_bytes('ghost') or b'')]
+        formatted_score['status'] = {
+            IIDXBase.CLEAR_STATUS_NO_PLAY: 'NO PLAY',
+            IIDXBase.CLEAR_STATUS_FAILED: 'FAILED',
+            IIDXBase.CLEAR_STATUS_ASSIST_CLEAR: 'ASSIST CLEAR',
+            IIDXBase.CLEAR_STATUS_EASY_CLEAR: 'EASY CLEAR',
+            IIDXBase.CLEAR_STATUS_CLEAR: 'CLEAR',
+            IIDXBase.CLEAR_STATUS_HARD_CLEAR: 'HARD CLEAR',
+            IIDXBase.CLEAR_STATUS_EX_HARD_CLEAR: 'EX HARD CLEAR',
+            IIDXBase.CLEAR_STATUS_FULL_COMBO: 'FULL COMBO',
+        }.get(score.data.get_int('clear_status'), 'NO PLAY')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['miss_count'] = attempt.data.get_int('miss_count')
+        formatted_attempt['status'] = {
+            IIDXBase.CLEAR_STATUS_NO_PLAY: 'NO PLAY',
+            IIDXBase.CLEAR_STATUS_FAILED: 'FAILED',
+            IIDXBase.CLEAR_STATUS_ASSIST_CLEAR: 'ASSIST CLEAR',
+            IIDXBase.CLEAR_STATUS_EASY_CLEAR: 'EASY CLEAR',
+            IIDXBase.CLEAR_STATUS_CLEAR: 'CLEAR',
+            IIDXBase.CLEAR_STATUS_HARD_CLEAR: 'HARD CLEAR',
+            IIDXBase.CLEAR_STATUS_EX_HARD_CLEAR: 'EX HARD CLEAR',
+            IIDXBase.CLEAR_STATUS_FULL_COMBO: 'FULL COMBO',
+        }.get(attempt.data.get_int('clear_status'), 'NO PLAY')
+        return formatted_attempt
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0, 0, 0, 0, 0, 0]
+        notecounts = [0, 0, 0, 0, 0, 0]
+        difficulties[song.chart] = song.data.get_int('difficulty', 13)
+        notecounts[song.chart] = song.data.get_int('notecount', 5730)
+
+        formatted_song = super().format_song(song)
+        formatted_song['bpm_min'] = song.data.get_int('bpm_min', 120)
+        formatted_song['bpm_max'] = song.data.get_int('bpm_max', 120)
+        formatted_song['difficulties'] = difficulties
+        formatted_song['notecounts'] = notecounts
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if (
+            existing['difficulties'][new.chart] == 0 or
+            existing['notecounts'][new.chart] == 0
+        ):
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 13)
+            new_song['notecounts'][new.chart] = new.data.get_int('notecount', 5730)
+        return new_song
diff --git a/bemani/frontend/jubeat/__init__.py b/bemani/frontend/jubeat/__init__.py
new file mode 100644
index 0000000..06c76b6
--- /dev/null
+++ b/bemani/frontend/jubeat/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.jubeat.endpoints import jubeat_pages
+from bemani.frontend.jubeat.cache import JubeatCache
diff --git a/bemani/frontend/jubeat/cache.py b/bemani/frontend/jubeat/cache.py
new file mode 100644
index 0000000..1304101
--- /dev/null
+++ b/bemani/frontend/jubeat/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.jubeat.jubeat import JubeatFrontend
+
+
+class JubeatCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = JubeatFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/jubeat/endpoints.py b/bemani/frontend/jubeat/endpoints.py
new file mode 100644
index 0000000..4152e19
--- /dev/null
+++ b/bemani/frontend/jubeat/endpoints.py
@@ -0,0 +1,340 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.jubeat.jubeat import JubeatFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+jubeat_pages = Blueprint(
+    'jubeat_pages',
+    __name__,
+    url_prefix='/jubeat',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@jubeat_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global Jubeat Scores',
+        'jubeat/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'versions': {version: name for (game, version, name) in frontend.sanitized_games()},
+            'shownames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('jubeat_pages.listnetworkscores'),
+            'player': url_for('jubeat_pages.viewplayer', userid=-1),
+            'individual_score': url_for('jubeat_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@jubeat_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@jubeat_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        '{}\'s Jubeat Scores'.format(info['name']),
+        'jubeat/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': {version: name for (game, version, name) in frontend.sanitized_games()},
+            'shownames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('jubeat_pages.listscores', userid=userid),
+            'player': url_for('jubeat_pages.viewplayer', userid=-1),
+            'individual_score': url_for('jubeat_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@jubeat_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@jubeat_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+
+    return render_react(
+        'Global Jubeat Records',
+        'jubeat/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': {version: name for (game, version, name) in frontend.sanitized_games()},
+            'shownames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('jubeat_pages.listnetworkrecords'),
+            'player': url_for('jubeat_pages.viewplayer', userid=-1),
+            'individual_score': url_for('jubeat_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@jubeat_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@jubeat_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    return render_react(
+        '{}\'s Jubeat Records'.format(info['name']),
+        'jubeat/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': {version: name for (game, version, name) in frontend.sanitized_games()},
+            'shownames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('jubeat_pages.listrecords', userid=userid),
+            'player': url_for('jubeat_pages.viewplayer', userid=-1),
+            'individual_score': url_for('jubeat_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@jubeat_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@jubeat_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    versions = sorted(
+        [version for (game, version, name) in frontend.all_games()],
+        reverse=True,
+    )
+    name = None
+    artist = None
+    genre = None
+    difficulties = [0, 0, 0]
+
+    for version in versions:
+        for chart in [0, 1, 2]:
+            details = g.data.local.music.get_song(GameConstants.JUBEAT, version, musicid, chart)
+            if details is not None:
+                name = details.name
+                artist = details.artist
+                genre = details.genre
+                difficulties[chart] = details.data.get_int('difficulty', 13)
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top Jubeat Scores for {} - {}'.format(artist, name),
+        'jubeat/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'genre': genre,
+            'difficulties': difficulties,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('jubeat_pages.listtopscores', musicid=musicid),
+            'player': url_for('jubeat_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@jubeat_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@jubeat_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All Jubeat Players',
+        'jubeat/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('jubeat_pages.listplayers'),
+            'player': url_for('jubeat_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@jubeat_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@jubeat_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+    latest_version = sorted(info.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s Jubeat Profile'.format(info[latest_version]['name']),
+        'jubeat/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('jubeat_pages.listplayer', userid=userid),
+            'records': url_for('jubeat_pages.viewrecords', userid=userid),
+            'scores': url_for('jubeat_pages.viewscores', userid=userid),
+        },
+    )
+
+
+@jubeat_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': info,
+    }
+
+
+@jubeat_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = JubeatFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+
+    return render_react(
+        'Jubeat Game Settings',
+        'jubeat/settings.react.js',
+        {
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('jubeat_pages.updatename'),
+        },
+    )
+
+
+@jubeat_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update name
+    profile = g.data.local.user.get_profile(GameConstants.JUBEAT, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 8:
+        raise Exception('Invalid profile name!')
+    if re.match(r'^[-&\.\*A-Z0-9]*$', name) is None:
+        raise Exception('Invalid profile name!')
+    profile.replace_str('name', name)
+    g.data.local.user.put_profile(GameConstants.JUBEAT, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
diff --git a/bemani/frontend/jubeat/jubeat.py b/bemani/frontend/jubeat/jubeat.py
new file mode 100644
index 0000000..0e2f7f8
--- /dev/null
+++ b/bemani/frontend/jubeat/jubeat.py
@@ -0,0 +1,87 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, Iterator, Tuple
+
+from bemani.backend.jubeat import JubeatFactory, JubeatBase
+from bemani.common import ValidatedDict, GameConstants, VersionConstants
+from bemani.data import Attempt, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class JubeatFrontend(FrontendBase):
+
+    game = GameConstants.JUBEAT
+
+    valid_charts = [
+        JubeatBase.CHART_TYPE_BASIC,
+        JubeatBase.CHART_TYPE_ADVANCED,
+        JubeatBase.CHART_TYPE_EXTREME,
+    ]
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from JubeatFactory.all_games()
+
+    def sanitized_games(self) -> Iterator[Tuple[str, int, str]]:
+        mapping = {
+            VersionConstants.JUBEAT: 1,
+            VersionConstants.JUBEAT_RIPPLES: 2,
+            VersionConstants.JUBEAT_KNIT: 3,
+            VersionConstants.JUBEAT_COPIOUS: 4,
+            VersionConstants.JUBEAT_SAUCER: 5,
+            VersionConstants.JUBEAT_PROP: 6,
+            VersionConstants.JUBEAT_QUBELL: 7,
+            VersionConstants.JUBEAT_CLAN: 8,
+            VersionConstants.JUBEAT_FESTO: 9,
+        }
+
+        for (game, version, name) in self.all_games():
+            if version in mapping:
+                yield (game, mapping[version], name)
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['combo'] = score.data.get_int('combo', -1)
+        formatted_score['medal'] = score.data.get_int('medal')
+        formatted_score['status'] = {
+            JubeatBase.PLAY_MEDAL_FAILED: "FAILED",
+            JubeatBase.PLAY_MEDAL_CLEARED: "CLEARED",
+            JubeatBase.PLAY_MEDAL_NEARLY_FULL_COMBO: "NEARLY FULL COMBO",
+            JubeatBase.PLAY_MEDAL_FULL_COMBO: "FULL COMBO",
+            JubeatBase.PLAY_MEDAL_NEARLY_EXCELLENT: "NEARLY EXCELLENT",
+            JubeatBase.PLAY_MEDAL_EXCELLENT: "EXCELLENT",
+        }.get(score.data.get_int('medal'), 'NO PLAY')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['combo'] = attempt.data.get_int('combo', -1)
+        formatted_attempt['medal'] = attempt.data.get_int('medal')
+        formatted_attempt['status'] = {
+            JubeatBase.PLAY_MEDAL_FAILED: "FAILED",
+            JubeatBase.PLAY_MEDAL_CLEARED: "CLEARED",
+            JubeatBase.PLAY_MEDAL_NEARLY_FULL_COMBO: "NEARLY FULL COMBO",
+            JubeatBase.PLAY_MEDAL_FULL_COMBO: "FULL COMBO",
+            JubeatBase.PLAY_MEDAL_NEARLY_EXCELLENT: "NEARLY EXCELLENT",
+            JubeatBase.PLAY_MEDAL_EXCELLENT: "EXCELLENT",
+        }.get(attempt.data.get_int('medal'), 'NO PLAY')
+        return formatted_attempt
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        formatted_profile['plays'] = playstats.get_int('total_plays')
+        return formatted_profile
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0, 0, 0]
+        difficulties[song.chart] = song.data.get_int('difficulty', 13)
+
+        formatted_song = super().format_song(song)
+        formatted_song['bpm_min'] = song.data.get_int('bpm_min', 120)
+        formatted_song['bpm_max'] = song.data.get_int('bpm_max', 120)
+        formatted_song['difficulties'] = difficulties
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if existing['difficulties'][new.chart] == 0:
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 13)
+        return new_song
diff --git a/bemani/frontend/museca/__init__.py b/bemani/frontend/museca/__init__.py
new file mode 100644
index 0000000..4e7dc3c
--- /dev/null
+++ b/bemani/frontend/museca/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.museca.endpoints import museca_pages
+from bemani.frontend.museca.cache import MusecaCache
diff --git a/bemani/frontend/museca/cache.py b/bemani/frontend/museca/cache.py
new file mode 100644
index 0000000..372958b
--- /dev/null
+++ b/bemani/frontend/museca/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.museca.museca import MusecaFrontend
+
+
+class MusecaCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = MusecaFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/museca/endpoints.py b/bemani/frontend/museca/endpoints.py
new file mode 100644
index 0000000..0102efa
--- /dev/null
+++ b/bemani/frontend/museca/endpoints.py
@@ -0,0 +1,348 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.museca.museca import MusecaFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+museca_pages = Blueprint(
+    'museca_pages',
+    __name__,
+    url_prefix='/museca',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@museca_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global MÚSECA Scores',
+        'museca/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'shownames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('museca_pages.listnetworkscores'),
+            'player': url_for('museca_pages.viewplayer', userid=-1),
+            'individual_score': url_for('museca_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@museca_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@museca_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        '{}\'s MÚSECA Scores'.format(info['name']),
+        'museca/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'shownames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('museca_pages.listscores', userid=userid),
+            'player': url_for('museca_pages.viewplayer', userid=-1),
+            'individual_score': url_for('museca_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@museca_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@museca_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+    versions[0] = 'CS and Licenses'
+
+    return render_react(
+        'Global MÚSECA Records',
+        'museca/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': versions,
+            'shownames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('museca_pages.listnetworkrecords'),
+            'player': url_for('museca_pages.viewplayer', userid=-1),
+            'individual_score': url_for('museca_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@museca_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@museca_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+
+    return render_react(
+        '{}\'s MÚSECA Records'.format(info['name']),
+        'museca/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': versions,
+            'shownames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('museca_pages.listrecords', userid=userid),
+            'player': url_for('museca_pages.viewplayer', userid=-1),
+            'individual_score': url_for('museca_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@museca_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@museca_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    versions = sorted(
+        [version for (game, version, name) in frontend.all_games()],
+        reverse=True,
+    )
+    name = None
+    artist = None
+    difficulties = [0, 0, 0, 0, 0]
+
+    for version in versions:
+        for chart in [0, 1, 2, 3, 4]:
+            details = g.data.local.music.get_song(GameConstants.MUSECA, version, musicid, chart)
+            if details is not None:
+                if name is None:
+                    name = details.name
+                if artist is None:
+                    artist = details.artist
+                if difficulties[chart] == 0:
+                    difficulties[chart] = details.data.get_int('difficulty')
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top MÚSECA Scores for {} - {}'.format(artist, name),
+        'museca/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'difficulties': difficulties,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('museca_pages.listtopscores', musicid=musicid),
+            'player': url_for('museca_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@museca_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@museca_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All MÚSECA Players',
+        'museca/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('museca_pages.listplayers'),
+            'player': url_for('museca_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@museca_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@museca_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+    latest_version = sorted(info.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s MÚSECA Profile'.format(info[latest_version]['name']),
+        'museca/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('museca_pages.listplayer', userid=userid),
+            'records': url_for('museca_pages.viewrecords', userid=userid),
+            'scores': url_for('museca_pages.viewscores', userid=userid),
+        },
+    )
+
+
+@museca_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': info,
+    }
+
+
+@museca_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = MusecaFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+
+    return render_react(
+        'MÚSECA Game Settings',
+        'museca/settings.react.js',
+        {
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('museca_pages.updatename'),
+        },
+    )
+
+
+@museca_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update name
+    profile = g.data.local.user.get_profile(GameConstants.MUSECA, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 8:
+        raise Exception('Invalid profile name!')
+    if re.match(
+        "^[" +
+        "0-9" +
+        "A-Z" +
+        "!?#$&*-. " +
+        "]*$",
+        name,
+    ) is None:
+        raise Exception('Invalid profile name!')
+    profile.replace_str('name', name)
+    g.data.local.user.put_profile(GameConstants.MUSECA, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
diff --git a/bemani/frontend/museca/museca.py b/bemani/frontend/museca/museca.py
new file mode 100644
index 0000000..3a76bf1
--- /dev/null
+++ b/bemani/frontend/museca/museca.py
@@ -0,0 +1,93 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, Iterator, Tuple
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.backend.museca import MusecaFactory, MusecaBase
+from bemani.common import GameConstants, ValidatedDict
+from bemani.data import Attempt, Data, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class MusecaFrontend(FrontendBase):
+
+    game = GameConstants.MUSECA
+
+    valid_charts = [
+        MusecaBase.CHART_TYPE_GREEN,
+        MusecaBase.CHART_TYPE_ORANGE,
+        MusecaBase.CHART_TYPE_RED,
+    ]
+
+    def __init__(self, data: Data, config: Dict[str, Any], cache: Cache) -> None:
+        super().__init__(data, config, cache)
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from MusecaFactory.all_games()
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['combo'] = score.data.get_int('combo', -1)
+        formatted_score['grade'] = {
+            MusecaBase.GRADE_DEATH: 'Death (没)',
+            MusecaBase.GRADE_POOR: 'Poor (拙)',
+            MusecaBase.GRADE_MEDIOCRE: 'Mediocre (凡)',
+            MusecaBase.GRADE_GOOD: 'Good (佳)',
+            MusecaBase.GRADE_GREAT: 'Great (良)',
+            MusecaBase.GRADE_EXCELLENT: 'Excellent (優)',
+            MusecaBase.GRADE_SUPERB: 'Superb (秀)',
+            MusecaBase.GRADE_MASTERPIECE: 'Masterpiece (傑)',
+            MusecaBase.GRADE_PERFECT: 'Perfect (傑)',
+        }.get(score.data.get_int('grade'), 'No Play')
+        formatted_score['clear_type'] = {
+            MusecaBase.CLEAR_TYPE_FAILED: 'Failed',
+            MusecaBase.CLEAR_TYPE_CLEARED: 'Cleared',
+            MusecaBase.CLEAR_TYPE_FULL_COMBO: 'Full Combo',
+        }.get(score.data.get_int('clear_type'), 'Failed')
+        formatted_score['medal'] = score.data.get_int('clear_type')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['combo'] = attempt.data.get_int('combo', -1)
+        formatted_attempt['grade'] = {
+            MusecaBase.GRADE_DEATH: 'Death (没)',
+            MusecaBase.GRADE_POOR: 'Poor (拙)',
+            MusecaBase.GRADE_MEDIOCRE: 'Mediocre (凡)',
+            MusecaBase.GRADE_GOOD: 'Good (佳)',
+            MusecaBase.GRADE_GREAT: 'Great (良)',
+            MusecaBase.GRADE_EXCELLENT: 'Excellent (優)',
+            MusecaBase.GRADE_SUPERB: 'Superb (秀)',
+            MusecaBase.GRADE_MASTERPIECE: 'Masterpiece (傑)',
+            MusecaBase.GRADE_PERFECT: 'Perfect (傑)',
+        }.get(attempt.data.get_int('grade'), 'No Play')
+        formatted_attempt['clear_type'] = {
+            MusecaBase.CLEAR_TYPE_FAILED: 'Failed',
+            MusecaBase.CLEAR_TYPE_CLEARED: 'Cleared',
+            MusecaBase.CLEAR_TYPE_FULL_COMBO: 'Full Combo',
+        }.get(attempt.data.get_int('clear_type'), 'Failed')
+        formatted_attempt['medal'] = attempt.data.get_int('clear_type')
+        return formatted_attempt
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        formatted_profile['plays'] = playstats.get_int('total_plays')
+        return formatted_profile
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0, 0, 0]
+        difficulties[song.chart] = song.data.get_int('difficulty', 21)
+
+        formatted_song = super().format_song(song)
+        formatted_song['difficulties'] = difficulties
+        formatted_song['category'] = song.version
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if existing['difficulties'][new.chart] == 0:
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 21)
+        # Set the category to the earliest seen version of this song
+        if existing['category'] > new.version:
+            new_song['category'] = new.version
+        return new_song
diff --git a/bemani/frontend/popn/__init__.py b/bemani/frontend/popn/__init__.py
new file mode 100644
index 0000000..08839c7
--- /dev/null
+++ b/bemani/frontend/popn/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.popn.endpoints import popn_pages
+from bemani.frontend.popn.cache import PopnMusicCache
diff --git a/bemani/frontend/popn/cache.py b/bemani/frontend/popn/cache.py
new file mode 100644
index 0000000..b80dbe3
--- /dev/null
+++ b/bemani/frontend/popn/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.popn.popn import PopnMusicFrontend
+
+
+class PopnMusicCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = PopnMusicFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/popn/endpoints.py b/bemani/frontend/popn/endpoints.py
new file mode 100644
index 0000000..5026776
--- /dev/null
+++ b/bemani/frontend/popn/endpoints.py
@@ -0,0 +1,356 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.popn.popn import PopnMusicFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+popn_pages = Blueprint(
+    'popn_pages',
+    __name__,
+    url_prefix='/popn',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@popn_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global Pop\'n Music Scores',
+        'popn/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'shownames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('popn_pages.listnetworkscores'),
+            'player': url_for('popn_pages.viewplayer', userid=-1),
+            'individual_score': url_for('popn_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@popn_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@popn_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        '{}\'s Pop\'n Music Scores'.format(info['name']),
+        'popn/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'shownames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('popn_pages.listscores', userid=userid),
+            'player': url_for('popn_pages.viewplayer', userid=-1),
+            'individual_score': url_for('popn_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@popn_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@popn_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+    versions[0] = 'CS and Licenses'
+
+    return render_react(
+        'Global Pop\'n Music Records',
+        'popn/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': versions,
+            'shownames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('popn_pages.listnetworkrecords'),
+            'player': url_for('popn_pages.viewplayer', userid=-1),
+            'individual_score': url_for('popn_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@popn_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@popn_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+    versions[0] = 'CS and Licenses'
+
+    return render_react(
+        '{}\'s Pop\'n Music Records'.format(info['name']),
+        'popn/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': versions,
+            'shownames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('popn_pages.listrecords', userid=userid),
+            'player': url_for('popn_pages.viewplayer', userid=-1),
+            'individual_score': url_for('popn_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@popn_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@popn_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    versions = sorted(
+        [version for (game, version, name) in frontend.all_games()],
+        reverse=True,
+    )
+    name = None
+    artist = None
+    genre = None
+    difficulties = [0, 0, 0, 0]
+
+    for version in versions:
+        for chart in [0, 1, 2, 3]:
+            details = g.data.local.music.get_song(GameConstants.POPN_MUSIC, version, musicid, chart)
+            if details is not None:
+                if name is None:
+                    name = details.name
+                if artist is None:
+                    artist = details.artist
+                if genre is None:
+                    genre = details.genre
+                if difficulties[chart] == 0:
+                    difficulties[chart] = details.data.get_int('difficulty')
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top Pop\'n Music Scores for {} - {}'.format(artist, name),
+        'popn/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'genre': genre,
+            'difficulties': difficulties,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('popn_pages.listtopscores', musicid=musicid),
+            'player': url_for('popn_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@popn_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@popn_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All Pop\'n Music Players',
+        'popn/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('popn_pages.listplayers'),
+            'player': url_for('popn_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@popn_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@popn_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+    latest_version = sorted(info.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s Pop\'n Music Profile'.format(info[latest_version]['name']),
+        'popn/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('popn_pages.listplayer', userid=userid),
+            'records': url_for('popn_pages.viewrecords', userid=userid),
+            'scores': url_for('popn_pages.viewscores', userid=userid),
+        },
+    )
+
+
+@popn_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': info,
+    }
+
+
+@popn_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = PopnMusicFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+
+    return render_react(
+        'Pop\'n Music Game Settings',
+        'popn/settings.react.js',
+        {
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('popn_pages.updatename'),
+        },
+    )
+
+
+@popn_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update name
+    profile = g.data.local.user.get_profile(GameConstants.POPN_MUSIC, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 6:
+        raise Exception('Invalid profile name!')
+    if re.match(
+        "^[" +
+        "\uFF20-\uFF3A" +  # widetext A-Z and @
+        "\uFF41-\uFF5A" +  # widetext a-z
+        "\uFF10-\uFF19" +  # widetext 0-9
+        "\uFF0C\uFF0E\uFF3F" +  # widetext ,._
+        "\u3041-\u308D\u308F\u3092\u3093" +  # hiragana
+        "\u30A1-\u30ED\u30EF\u30F2\u30F3\u30FC" +  # katakana
+        "]*$",
+        name,
+    ) is None:
+        raise Exception('Invalid profile name!')
+    profile.replace_str('name', name)
+    g.data.local.user.put_profile(GameConstants.POPN_MUSIC, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
diff --git a/bemani/frontend/popn/popn.py b/bemani/frontend/popn/popn.py
new file mode 100644
index 0000000..2796782
--- /dev/null
+++ b/bemani/frontend/popn/popn.py
@@ -0,0 +1,80 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, Iterator, Tuple
+
+from bemani.backend.popn import PopnMusicFactory, PopnMusicBase
+from bemani.common import ValidatedDict, GameConstants
+from bemani.data import Attempt, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class PopnMusicFrontend(FrontendBase):
+
+    game = GameConstants.POPN_MUSIC
+
+    valid_charts = [
+        PopnMusicBase.CHART_TYPE_EASY,
+        PopnMusicBase.CHART_TYPE_NORMAL,
+        PopnMusicBase.CHART_TYPE_HYPER,
+        PopnMusicBase.CHART_TYPE_EX,
+    ]
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from PopnMusicFactory.all_games()
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['combo'] = score.data.get_int('combo', -1)
+        formatted_score['medal'] = score.data.get_int('medal')
+        formatted_score['status'] = {
+            PopnMusicBase.PLAY_MEDAL_CIRCLE_FAILED: "○ Failed",
+            PopnMusicBase.PLAY_MEDAL_DIAMOND_FAILED: "◇ Failed",
+            PopnMusicBase.PLAY_MEDAL_STAR_FAILED: "☆ Failed",
+            PopnMusicBase.PLAY_MEDAL_EASY_CLEAR: "Easy Clear",
+            PopnMusicBase.PLAY_MEDAL_CIRCLE_CLEARED: "○ Cleared",
+            PopnMusicBase.PLAY_MEDAL_DIAMOND_CLEARED: "◇ Cleared",
+            PopnMusicBase.PLAY_MEDAL_STAR_CLEARED: "☆ Cleared",
+            PopnMusicBase.PLAY_MEDAL_CIRCLE_FULL_COMBO: "○ Full Combo",
+            PopnMusicBase.PLAY_MEDAL_DIAMOND_FULL_COMBO: "◇ Full Combo",
+            PopnMusicBase.PLAY_MEDAL_STAR_FULL_COMBO: "☆ Full Combo",
+            PopnMusicBase.PLAY_MEDAL_PERFECT: "Perfect",
+        }.get(score.data.get_int('medal'), 'No Play')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['combo'] = attempt.data.get_int('combo', -1)
+        formatted_attempt['medal'] = attempt.data.get_int('medal')
+        formatted_attempt['status'] = {
+            PopnMusicBase.PLAY_MEDAL_CIRCLE_FAILED: "○ Failed",
+            PopnMusicBase.PLAY_MEDAL_DIAMOND_FAILED: "◇ Failed",
+            PopnMusicBase.PLAY_MEDAL_STAR_FAILED: "☆ Failed",
+            PopnMusicBase.PLAY_MEDAL_EASY_CLEAR: "Easy Clear",
+            PopnMusicBase.PLAY_MEDAL_CIRCLE_CLEARED: "○ Cleared",
+            PopnMusicBase.PLAY_MEDAL_DIAMOND_CLEARED: "◇ Cleared",
+            PopnMusicBase.PLAY_MEDAL_STAR_CLEARED: "☆ Cleared",
+            PopnMusicBase.PLAY_MEDAL_CIRCLE_FULL_COMBO: "○ Full Combo",
+            PopnMusicBase.PLAY_MEDAL_DIAMOND_FULL_COMBO: "◇ Full Combo",
+            PopnMusicBase.PLAY_MEDAL_STAR_FULL_COMBO: "☆ Full Combo",
+            PopnMusicBase.PLAY_MEDAL_PERFECT: "Perfect",
+        }.get(attempt.data.get_int('medal'), 'No Play')
+        return formatted_attempt
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        formatted_profile['plays'] = playstats.get_int('total_plays')
+        return formatted_profile
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0, 0, 0, 0]
+        difficulties[song.chart] = song.data.get_int('difficulty', 51)
+
+        formatted_song = super().format_song(song)
+        formatted_song['category'] = song.data.get_str('category')
+        formatted_song['difficulties'] = difficulties
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if existing['difficulties'][new.chart] == 0:
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 51)
+        return new_song
diff --git a/bemani/frontend/reflec/__init__.py b/bemani/frontend/reflec/__init__.py
new file mode 100644
index 0000000..85006e5
--- /dev/null
+++ b/bemani/frontend/reflec/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.reflec.endpoints import reflec_pages
+from bemani.frontend.reflec.cache import ReflecBeatCache
diff --git a/bemani/frontend/reflec/cache.py b/bemani/frontend/reflec/cache.py
new file mode 100644
index 0000000..03ef745
--- /dev/null
+++ b/bemani/frontend/reflec/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.reflec.reflec import ReflecBeatFrontend
+
+
+class ReflecBeatCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = ReflecBeatFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/reflec/endpoints.py b/bemani/frontend/reflec/endpoints.py
new file mode 100644
index 0000000..b000dd8
--- /dev/null
+++ b/bemani/frontend/reflec/endpoints.py
@@ -0,0 +1,504 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import ID, GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.reflec.reflec import ReflecBeatFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+reflec_pages = Blueprint(
+    'reflec_pages',
+    __name__,
+    url_prefix='/reflec',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+NO_RIVAL_SUPPORT = [1]
+
+
+@reflec_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global Reflec Beat Scores',
+        'reflec/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'shownames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('reflec_pages.listnetworkscores'),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+            'individual_score': url_for('reflec_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@reflec_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@reflec_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        '{}\'s Reflec Beat Scores'.format(info['name']),
+        'reflec/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'shownames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('reflec_pages.listscores', userid=userid),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+            'individual_score': url_for('reflec_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@reflec_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@reflec_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+    versions[0] = 'CS and Licenses'
+
+    return render_react(
+        'Global Reflec Beat Records',
+        'reflec/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': versions,
+            'shownames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('reflec_pages.listnetworkrecords'),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+            'individual_score': url_for('reflec_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@reflec_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@reflec_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+
+    return render_react(
+        '{}\'s Reflec Beat Records'.format(info['name']),
+        'reflec/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': versions,
+            'shownames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('reflec_pages.listrecords', userid=userid),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+            'individual_score': url_for('reflec_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@reflec_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@reflec_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    name = None
+    artist = None
+    difficulties = [0, 0, 0, 0]
+
+    for chart in [0, 1, 2, 3]:
+        details = g.data.local.music.get_song(GameConstants.REFLEC_BEAT, 0, musicid, chart)
+        if details is not None:
+            if name is None:
+                name = details.name
+            if artist is None:
+                artist = details.artist
+            if difficulties[chart] == 0:
+                difficulties[chart] = details.data.get_int('difficulty')
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top Reflec Beat Scores for {} - {}'.format(artist, name),
+        'reflec/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'difficulties': difficulties,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('reflec_pages.listtopscores', musicid=musicid),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@reflec_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@reflec_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All Reflec Beat Players',
+        'reflec/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('reflec_pages.listplayers'),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@reflec_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@reflec_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+    latest_version = sorted(info.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s Reflec Beat Profile'.format(info[latest_version]['name']),
+        'reflec/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('reflec_pages.listplayer', userid=userid),
+            'records': url_for('reflec_pages.viewrecords', userid=userid),
+            'scores': url_for('reflec_pages.viewscores', userid=userid),
+        },
+    )
+
+
+@reflec_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': info,
+    }
+
+
+@reflec_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+
+    return render_react(
+        'Reflec Beat Game Settings',
+        'reflec/settings.react.js',
+        {
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('reflec_pages.updatename'),
+        },
+    )
+
+
+@reflec_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update name
+    profile = g.data.local.user.get_profile(GameConstants.REFLEC_BEAT, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 8:
+        raise Exception('Invalid profile name!')
+    if version <= 3:
+        # Older reflec didn't allow for lowercase
+        if re.match(
+            "^[" +
+            "\uFF21-\uFF3A" +  # widetext A-Z
+            "\uFF10-\uFF19" +  # widetext 0-9
+            "\uFF0E\u2212\uFF3F\u30FB" +
+            "\uFF06\uFF01\uFF1F\uFF0F" +
+            "\uFF0A\uFF03\u266D\u2605" +
+            "\uFF20\u266A\u2193\u2191" +
+            "\u2192\u2190\uFF08\uFF09" +
+            "\u221E\u25C6\u25CF\u25BC" +
+            "\uFFE5\uFF3E\u2200\uFF05" +
+            "\u3000" +  # widetext space
+            "]*$",
+            name,
+        ) is None:
+            raise Exception('Invalid profile name!')
+    else:
+        # Newer reflec allows the same as older but
+        # also allows for lowercase widetext.
+        if re.match(
+            "^[" +
+            "\uFF21-\uFF3A" +  # widetext A-Z
+            "\uFF41-\uFF5A" +  # widetext a-z
+            "\uFF10-\uFF19" +  # widetext 0-9
+            "\uFF0E\u2212\uFF3F\u30FB" +
+            "\uFF06\uFF01\uFF1F\uFF0F" +
+            "\uFF0A\uFF03\u266D\u2605" +
+            "\uFF20\u266A\u2193\u2191" +
+            "\u2192\u2190\uFF08\uFF09" +
+            "\u221E\u25C6\u25CF\u25BC" +
+            "\uFFE5\uFF3E\u2200\uFF05" +
+            "\u3000" +  # widetext space
+            "]*$",
+            name,
+        ) is None:
+            raise Exception('Invalid profile name!')
+    profile.replace_str('name', name)
+    g.data.local.user.put_profile(GameConstants.REFLEC_BEAT, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
+
+
+@reflec_pages.route('/rivals')
+@loginrequired
+def viewrivals() -> Response:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    rivals, playerinfo = frontend.get_rivals(g.userID)
+
+    # Reflec Beat 1 has no rivals support
+    for no_rivals_support in NO_RIVAL_SUPPORT:
+        if no_rivals_support in rivals:
+            del rivals[no_rivals_support]
+
+    return render_react(
+        'Reflec Beat Rivals',
+        'reflec/rivals.react.js',
+        {
+            'userid': str(g.userID),
+            'rivals': rivals,
+            'players': playerinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games() if version not in NO_RIVAL_SUPPORT},
+        },
+        {
+            'refresh': url_for('reflec_pages.listrivals'),
+            'search': url_for('reflec_pages.searchrivals'),
+            'player': url_for('reflec_pages.viewplayer', userid=-1),
+            'addrival': url_for('reflec_pages.addrival'),
+            'removerival': url_for('reflec_pages.removerival'),
+        },
+    )
+
+
+@reflec_pages.route('/rivals/list')
+@jsonify
+@loginrequired
+def listrivals() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    rivals, playerinfo = frontend.get_rivals(g.userID)
+
+    # Reflec Beat 1 has no rivals support
+    for no_rivals_support in NO_RIVAL_SUPPORT:
+        if no_rivals_support in rivals:
+            del rivals[no_rivals_support]
+
+    return {
+        'rivals': rivals,
+        'players': playerinfo,
+    }
+
+
+@reflec_pages.route('/rivals/search', methods=['POST'])
+@jsonify
+@loginrequired
+def searchrivals() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    name = request.get_json()['term']
+
+    # Try to treat the term as an extid
+    extid = ID.parse_extid(name)
+
+    matches = set()
+    profiles = g.data.remote.user.get_all_profiles(GameConstants.REFLEC_BEAT, version)
+    for (userid, profile) in profiles:
+        if profile.get_int('extid') == extid or profile.get_str('name').lower() == name.lower():
+            matches.add(userid)
+
+    playerinfo = frontend.get_all_player_info(list(matches), allow_remote=True)
+    return {
+        'results': playerinfo,
+    }
+
+
+@reflec_pages.route('/rivals/add', methods=['POST'])
+@jsonify
+@loginrequired
+def addrival() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Add this rival link
+    profile = g.data.remote.user.get_profile(GameConstants.REFLEC_BEAT, version, other_userid)
+    if profile is None:
+        raise Exception('Unable to find profile for rival!')
+
+    g.data.local.user.put_link(
+        GameConstants.REFLEC_BEAT,
+        version,
+        userid,
+        'rival',
+        other_userid,
+        {},
+    )
+
+    # Now return updated rival info
+    rivals, playerinfo = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': playerinfo,
+    }
+
+
+@reflec_pages.route('/rivals/remove', methods=['POST'])
+@jsonify
+@loginrequired
+def removerival() -> Dict[str, Any]:
+    frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Remove this rival link
+    g.data.local.user.destroy_link(
+        GameConstants.REFLEC_BEAT,
+        version,
+        userid,
+        'rival',
+        other_userid,
+    )
+
+    # Now return updated rival info
+    rivals, playerinfo = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': playerinfo,
+    }
diff --git a/bemani/frontend/reflec/reflec.py b/bemani/frontend/reflec/reflec.py
new file mode 100644
index 0000000..c06ebe6
--- /dev/null
+++ b/bemani/frontend/reflec/reflec.py
@@ -0,0 +1,97 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, Iterator, Tuple
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.backend.reflec import ReflecBeatFactory, ReflecBeatBase
+from bemani.common import GameConstants, ValidatedDict
+from bemani.data import Attempt, Data, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class ReflecBeatFrontend(FrontendBase):
+
+    game = GameConstants.REFLEC_BEAT
+
+    version = 0  # We use a virtual version for ReflecBeat to tie charts together
+
+    valid_charts = [
+        ReflecBeatBase.CHART_TYPE_BASIC,
+        ReflecBeatBase.CHART_TYPE_MEDIUM,
+        ReflecBeatBase.CHART_TYPE_HARD,
+        ReflecBeatBase.CHART_TYPE_SPECIAL,
+    ]
+
+    valid_rival_types = [
+        'rival',
+    ]
+
+    def __init__(self, data: Data, config: Dict[str, Any], cache: Cache) -> None:
+        super().__init__(data, config, cache)
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from ReflecBeatFactory.all_games()
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['combo'] = score.data.get_int('combo', -1)
+        formatted_score['achievement_rate'] = score.data.get_int('achievement_rate', -1)
+        formatted_score['miss_count'] = score.data.get_int('miss_count', -1)
+        formatted_score['clear_type'] = {
+            ReflecBeatBase.CLEAR_TYPE_NO_PLAY: 'No Play',
+            ReflecBeatBase.CLEAR_TYPE_FAILED: 'Failed',
+            ReflecBeatBase.CLEAR_TYPE_CLEARED: 'Cleared',
+            ReflecBeatBase.CLEAR_TYPE_HARD_CLEARED: 'Hard Cleared',
+            ReflecBeatBase.CLEAR_TYPE_S_HARD_CLEARED: 'S-Hard Cleared',
+        }.get(score.data.get_int('clear_type'), 'Failed')
+        formatted_score['combo_type'] = {
+            ReflecBeatBase.COMBO_TYPE_NONE: '',
+            ReflecBeatBase.COMBO_TYPE_ALMOST_COMBO: 'Almost Full Combo',
+            ReflecBeatBase.COMBO_TYPE_FULL_COMBO: 'Full Combo',
+            ReflecBeatBase.COMBO_TYPE_FULL_COMBO_ALL_JUST: 'Full Combo + All Just',
+        }.get(score.data.get_int('combo_type'), '')
+        formatted_score['medal'] = score.data.get_int('combo_type') * 1000 + score.data.get_int('clear_type')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['combo'] = attempt.data.get_int('combo', -1)
+        formatted_attempt['achievement_rate'] = attempt.data.get_int('achievement_rate', -1)
+        formatted_attempt['miss_count'] = attempt.data.get_int('miss_count', -1)
+        formatted_attempt['clear_type'] = {
+            ReflecBeatBase.CLEAR_TYPE_NO_PLAY: 'No Play',
+            ReflecBeatBase.CLEAR_TYPE_FAILED: 'Failed',
+            ReflecBeatBase.CLEAR_TYPE_CLEARED: 'Cleared',
+            ReflecBeatBase.CLEAR_TYPE_HARD_CLEARED: 'Hard Cleared',
+            ReflecBeatBase.CLEAR_TYPE_S_HARD_CLEARED: 'S-Hard Cleared',
+        }.get(attempt.data.get_int('clear_type'), 'Failed')
+        formatted_attempt['combo_type'] = {
+            ReflecBeatBase.COMBO_TYPE_NONE: '',
+            ReflecBeatBase.COMBO_TYPE_ALMOST_COMBO: 'Almost Full Combo',
+            ReflecBeatBase.COMBO_TYPE_FULL_COMBO: 'Full Combo',
+            ReflecBeatBase.COMBO_TYPE_FULL_COMBO_ALL_JUST: 'Full Combo + All Just',
+        }.get(attempt.data.get_int('combo_type'), '')
+        formatted_attempt['medal'] = attempt.data.get_int('combo_type') * 1000 + attempt.data.get_int('clear_type')
+        return formatted_attempt
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        formatted_profile['plays'] = playstats.get_int('total_plays')
+        return formatted_profile
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0, 0, 0, 0]
+        difficulties[song.chart] = song.data.get_int('difficulty', 16)
+
+        formatted_song = super().format_song(song)
+        formatted_song['difficulties'] = difficulties
+        formatted_song['category'] = song.data.get_int('folder', 1)
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if existing['difficulties'][new.chart] == 0:
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 16)
+        if existing['category'] == 0:
+            new_song['category'] = new.data.get_int('folder', 1)
+        return new_song
diff --git a/bemani/frontend/sdvx/__init__.py b/bemani/frontend/sdvx/__init__.py
new file mode 100644
index 0000000..6b1cc54
--- /dev/null
+++ b/bemani/frontend/sdvx/__init__.py
@@ -0,0 +1,2 @@
+from bemani.frontend.sdvx.endpoints import sdvx_pages
+from bemani.frontend.sdvx.cache import SoundVoltexCache
diff --git a/bemani/frontend/sdvx/cache.py b/bemani/frontend/sdvx/cache.py
new file mode 100644
index 0000000..fbeb643
--- /dev/null
+++ b/bemani/frontend/sdvx/cache.py
@@ -0,0 +1,19 @@
+from typing import Dict, Any
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.data import Data
+from bemani.frontend.app import app
+from bemani.frontend.sdvx.sdvx import SoundVoltexFrontend
+
+
+class SoundVoltexCache:
+
+    @classmethod
+    def preload(cls, data: Data, config: Dict[str, Any]) -> None:
+        cache = Cache(app, config={
+            'CACHE_TYPE': 'filesystem',
+            'CACHE_DIR': config['cache_dir'],
+        })
+        frontend = SoundVoltexFrontend(data, config, cache)
+        frontend.get_all_songs(force_db_load=True)
diff --git a/bemani/frontend/sdvx/endpoints.py b/bemani/frontend/sdvx/endpoints.py
new file mode 100644
index 0000000..5cf9720
--- /dev/null
+++ b/bemani/frontend/sdvx/endpoints.py
@@ -0,0 +1,474 @@
+# vim: set fileencoding=utf-8
+import re
+from typing import Any, Dict
+from flask import Blueprint, request, Response, url_for, abort, g  # type: ignore
+
+from bemani.common import ID, GameConstants
+from bemani.data import UserID
+from bemani.frontend.app import loginrequired, jsonify, render_react
+from bemani.frontend.sdvx.sdvx import SoundVoltexFrontend
+from bemani.frontend.templates import templates_location
+from bemani.frontend.static import static_location
+
+sdvx_pages = Blueprint(
+    'sdvx_pages',
+    __name__,
+    url_prefix='/sdvx',
+    template_folder=templates_location,
+    static_folder=static_location,
+)
+
+
+@sdvx_pages.route('/scores')
+@loginrequired
+def viewnetworkscores() -> Response:
+    # Only load the last 100 results for the initial fetch, so we can render faster
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    network_scores = frontend.get_network_scores(limit=100)
+    if len(network_scores['attempts']) > 10:
+        network_scores['attempts'] = frontend.round_to_ten(network_scores['attempts'])
+
+    return render_react(
+        'Global SDVX Scores',
+        'sdvx/scores.react.js',
+        {
+            'attempts': network_scores['attempts'],
+            'songs': frontend.get_all_songs(),
+            'players': network_scores['players'],
+            'shownames': True,
+            'shownewrecords': False,
+        },
+        {
+            'refresh': url_for('sdvx_pages.listnetworkscores'),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('sdvx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@sdvx_pages.route('/scores/list')
+@jsonify
+@loginrequired
+def listnetworkscores() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_scores()
+
+
+@sdvx_pages.route('/scores/<int:userid>')
+@loginrequired
+def viewscores(userid: UserID) -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+
+    scores = frontend.get_scores(userid, limit=100)
+    if len(scores) > 10:
+        scores = frontend.round_to_ten(scores)
+
+    return render_react(
+        '{}\'s SDVX Scores'.format(info['name']),
+        'sdvx/scores.react.js',
+        {
+            'attempts': scores,
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'shownames': False,
+            'shownewrecords': True,
+        },
+        {
+            'refresh': url_for('sdvx_pages.listscores', userid=userid),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('sdvx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@sdvx_pages.route('/scores/<int:userid>/list')
+@jsonify
+@loginrequired
+def listscores(userid: UserID) -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return {
+        'attempts': frontend.get_scores(userid),
+        'players': {},
+    }
+
+
+@sdvx_pages.route('/records')
+@loginrequired
+def viewnetworkrecords() -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    network_records = frontend.get_network_records()
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+    versions[0] = 'CS and Licenses'
+
+    return render_react(
+        'Global SDVX Records',
+        'sdvx/records.react.js',
+        {
+            'records': network_records['records'],
+            'songs': frontend.get_all_songs(),
+            'players': network_records['players'],
+            'versions': versions,
+            'shownames': True,
+            'showpersonalsort': False,
+            'filterempty': False,
+        },
+        {
+            'refresh': url_for('sdvx_pages.listnetworkrecords'),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('sdvx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@sdvx_pages.route('/records/list')
+@jsonify
+@loginrequired
+def listnetworkrecords() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return frontend.get_network_records()
+
+
+@sdvx_pages.route('/records/<int:userid>')
+@loginrequired
+def viewrecords(userid: UserID) -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    info = frontend.get_latest_player_info([userid]).get(userid)
+    if info is None:
+        abort(404)
+    versions = {version: name for (game, version, name) in frontend.all_games()}
+
+    return render_react(
+        '{}\'s SDVX Records'.format(info['name']),
+        'sdvx/records.react.js',
+        {
+            'records': frontend.get_records(userid),
+            'songs': frontend.get_all_songs(),
+            'players': {},
+            'versions': versions,
+            'shownames': False,
+            'showpersonalsort': True,
+            'filterempty': True,
+        },
+        {
+            'refresh': url_for('sdvx_pages.listrecords', userid=userid),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+            'individual_score': url_for('sdvx_pages.viewtopscores', musicid=-1),
+        },
+    )
+
+
+@sdvx_pages.route('/records/<int:userid>/list')
+@jsonify
+@loginrequired
+def listrecords(userid: UserID) -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return {
+        'records': frontend.get_records(userid),
+        'players': {},
+    }
+
+
+@sdvx_pages.route('/topscores/<int:musicid>')
+@loginrequired
+def viewtopscores(musicid: int) -> Response:
+    # We just want to find the latest mix that this song exists in
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    versions = sorted(
+        [version for (game, version, name) in frontend.all_games()],
+        reverse=True,
+    )
+    name = None
+    artist = None
+    difficulties = [0, 0, 0, 0, 0]
+
+    for version in versions:
+        for chart in [0, 1, 2, 3, 4]:
+            details = g.data.local.music.get_song(GameConstants.SDVX, version, musicid, chart)
+            if details is not None:
+                if name is None:
+                    name = details.name
+                if artist is None:
+                    artist = details.artist
+                if difficulties[chart] == 0:
+                    difficulties[chart] = details.data.get_int('difficulty')
+
+    if name is None:
+        # Not a real song!
+        abort(404)
+
+    top_scores = frontend.get_top_scores(musicid)
+
+    return render_react(
+        'Top SDVX Scores for {} - {}'.format(artist, name),
+        'sdvx/topscores.react.js',
+        {
+            'name': name,
+            'artist': artist,
+            'difficulties': difficulties,
+            'players': top_scores['players'],
+            'topscores': top_scores['topscores'],
+        },
+        {
+            'refresh': url_for('sdvx_pages.listtopscores', musicid=musicid),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@sdvx_pages.route('/topscores/<int:musicid>/list')
+@jsonify
+@loginrequired
+def listtopscores(musicid: int) -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return frontend.get_top_scores(musicid)
+
+
+@sdvx_pages.route('/players')
+@loginrequired
+def viewplayers() -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return render_react(
+        'All SDVX Players',
+        'sdvx/allplayers.react.js',
+        {
+            'players': frontend.get_all_players()
+        },
+        {
+            'refresh': url_for('sdvx_pages.listplayers'),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+        },
+    )
+
+
+@sdvx_pages.route('/players/list')
+@jsonify
+@loginrequired
+def listplayers() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    return {
+        'players': frontend.get_all_players(),
+    }
+
+
+@sdvx_pages.route('/players/<int:userid>')
+@loginrequired
+def viewplayer(userid: UserID) -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+    latest_version = sorted(info.keys(), reverse=True)[0]
+
+    return render_react(
+        '{}\'s SDVX Profile'.format(info[latest_version]['name']),
+        'sdvx/player.react.js',
+        {
+            'playerid': userid,
+            'own_profile': userid == g.userID,
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('sdvx_pages.listplayer', userid=userid),
+            'records': url_for('sdvx_pages.viewrecords', userid=userid),
+            'scores': url_for('sdvx_pages.viewscores', userid=userid),
+        },
+    )
+
+
+@sdvx_pages.route('/players/<int:userid>/list')
+@jsonify
+@loginrequired
+def listplayer(userid: UserID) -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    info = frontend.get_all_player_info([userid])[userid]
+
+    return {
+        'player': info,
+    }
+
+
+@sdvx_pages.route('/options')
+@loginrequired
+def viewsettings() -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    userid = g.userID
+    info = frontend.get_all_player_info([userid])[userid]
+    if not info:
+        abort(404)
+
+    return render_react(
+        'SDVX Game Settings',
+        'sdvx/settings.react.js',
+        {
+            'player': info,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'updatename': url_for('sdvx_pages.updatename'),
+        },
+    )
+
+
+@sdvx_pages.route('/options/name/update', methods=['POST'])
+@jsonify
+@loginrequired
+def updatename() -> Dict[str, Any]:
+    version = int(request.get_json()['version'])
+    name = request.get_json()['name']
+    user = g.data.local.user.get_user(g.userID)
+    if user is None:
+        raise Exception('Unable to find user to update!')
+
+    # Grab profile and update name
+    profile = g.data.local.user.get_profile(GameConstants.SDVX, version, user.id)
+    if profile is None:
+        raise Exception('Unable to find profile to update!')
+    if len(name) == 0 or len(name) > 8:
+        raise Exception('Invalid profile name!')
+    if re.match(
+        "^[" +
+        "0-9" +
+        "A-Z" +
+        "!?#$&*-. " +
+        "]*$",
+        name,
+    ) is None:
+        raise Exception('Invalid profile name!')
+    profile.replace_str('name', name)
+    g.data.local.user.put_profile(GameConstants.SDVX, version, user.id, profile)
+
+    # Return that we updated
+    return {
+        'version': version,
+        'name': name,
+    }
+
+
+@sdvx_pages.route('/rivals')
+@loginrequired
+def viewrivals() -> Response:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    rivals, playerinfo = frontend.get_rivals(g.userID)
+
+    # There were no rivals in SDVX 1 or 2.
+    if 1 in rivals:
+        del rivals[1]
+    if 2 in rivals:
+        del rivals[2]
+
+    return render_react(
+        'SDVX Rivals',
+        'sdvx/rivals.react.js',
+        {
+            'userid': str(g.userID),
+            'rivals': rivals,
+            'players': playerinfo,
+            'versions': {version: name for (game, version, name) in frontend.all_games()},
+        },
+        {
+            'refresh': url_for('sdvx_pages.listrivals'),
+            'search': url_for('sdvx_pages.searchrivals'),
+            'player': url_for('sdvx_pages.viewplayer', userid=-1),
+            'addrival': url_for('sdvx_pages.addrival'),
+            'removerival': url_for('sdvx_pages.removerival'),
+        },
+    )
+
+
+@sdvx_pages.route('/rivals/list')
+@jsonify
+@loginrequired
+def listrivals() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    rivals, playerinfo = frontend.get_rivals(g.userID)
+
+    return {
+        'rivals': rivals,
+        'players': playerinfo,
+    }
+
+
+@sdvx_pages.route('/rivals/search', methods=['POST'])
+@jsonify
+@loginrequired
+def searchrivals() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    name = request.get_json()['term']
+
+    # Try to treat the term as an extid
+    extid = ID.parse_extid(name)
+
+    matches = set()
+    profiles = g.data.remote.user.get_all_profiles(GameConstants.SDVX, version)
+    for (userid, profile) in profiles:
+        if profile.get_int('extid') == extid or profile.get_str('name').lower() == name.lower():
+            matches.add(userid)
+
+    playerinfo = frontend.get_all_player_info(list(matches), allow_remote=True)
+    return {
+        'results': playerinfo,
+    }
+
+
+@sdvx_pages.route('/rivals/add', methods=['POST'])
+@jsonify
+@loginrequired
+def addrival() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Add this rival link
+    profile = g.data.remote.user.get_profile(GameConstants.SDVX, version, other_userid)
+    if profile is None:
+        raise Exception('Unable to find profile for rival!')
+
+    g.data.local.user.put_link(
+        GameConstants.SDVX,
+        version,
+        userid,
+        'rival',
+        other_userid,
+        {},
+    )
+
+    # Now return updated rival info
+    rivals, playerinfo = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': playerinfo,
+    }
+
+
+@sdvx_pages.route('/rivals/remove', methods=['POST'])
+@jsonify
+@loginrequired
+def removerival() -> Dict[str, Any]:
+    frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
+    version = int(request.get_json()['version'])
+    other_userid = UserID(int(request.get_json()['userid']))
+    userid = g.userID
+
+    # Remove this rival link
+    g.data.local.user.destroy_link(
+        GameConstants.SDVX,
+        version,
+        userid,
+        'rival',
+        other_userid,
+    )
+
+    # Now return updated rival info
+    rivals, playerinfo = frontend.get_rivals(userid)
+
+    return {
+        'rivals': rivals,
+        'players': playerinfo,
+    }
diff --git a/bemani/frontend/sdvx/sdvx.py b/bemani/frontend/sdvx/sdvx.py
new file mode 100644
index 0000000..3da6002
--- /dev/null
+++ b/bemani/frontend/sdvx/sdvx.py
@@ -0,0 +1,109 @@
+# vim: set fileencoding=utf-8
+from typing import Any, Dict, Iterator, Tuple
+
+from flask_caching import Cache  # type: ignore
+
+from bemani.backend.sdvx import SoundVoltexFactory, SoundVoltexBase
+from bemani.common import GameConstants, ValidatedDict
+from bemani.data import Attempt, Data, Score, Song, UserID
+from bemani.frontend.base import FrontendBase
+
+
+class SoundVoltexFrontend(FrontendBase):
+
+    game = GameConstants.SDVX
+
+    valid_charts = [
+        SoundVoltexBase.CHART_TYPE_NOVICE,
+        SoundVoltexBase.CHART_TYPE_ADVANCED,
+        SoundVoltexBase.CHART_TYPE_EXHAUST,
+        SoundVoltexBase.CHART_TYPE_INFINITE,
+        SoundVoltexBase.CHART_TYPE_MAXIMUM,
+    ]
+
+    valid_rival_types = [
+        'rival',
+    ]
+
+    def __init__(self, data: Data, config: Dict[str, Any], cache: Cache) -> None:
+        super().__init__(data, config, cache)
+
+    def all_games(self) -> Iterator[Tuple[str, int, str]]:
+        yield from SoundVoltexFactory.all_games()
+
+    def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
+        formatted_score = super().format_score(userid, score)
+        formatted_score['combo'] = score.data.get_int('combo', -1)
+        formatted_score['grade'] = {
+            SoundVoltexBase.GRADE_NO_PLAY: 'No Play',
+            SoundVoltexBase.GRADE_D: 'D',
+            SoundVoltexBase.GRADE_C: 'C',
+            SoundVoltexBase.GRADE_B: 'B',
+            SoundVoltexBase.GRADE_A: 'A',
+            SoundVoltexBase.GRADE_A_PLUS: 'A+',
+            SoundVoltexBase.GRADE_AA: 'AA',
+            SoundVoltexBase.GRADE_AA_PLUS: 'AA+',
+            SoundVoltexBase.GRADE_AAA: 'AAA',
+            SoundVoltexBase.GRADE_AAA_PLUS: 'AAA+',
+            SoundVoltexBase.GRADE_S: 'S',
+        }.get(score.data.get_int('grade'), 'No Play')
+        formatted_score['clear_type'] = {
+            SoundVoltexBase.CLEAR_TYPE_NO_PLAY: 'No Play',
+            SoundVoltexBase.CLEAR_TYPE_FAILED: 'Failed',
+            SoundVoltexBase.CLEAR_TYPE_CLEAR: 'Cleared',
+            SoundVoltexBase.CLEAR_TYPE_HARD_CLEAR: 'Hard Cleared',
+            SoundVoltexBase.CLEAR_TYPE_ULTIMATE_CHAIN: 'Ultimate Chain',
+            SoundVoltexBase.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: 'Perfect Ultimate Chain',
+        }.get(score.data.get_int('clear_type'), 'Failed')
+        formatted_score['medal'] = score.data.get_int('clear_type')
+        return formatted_score
+
+    def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
+        formatted_attempt = super().format_attempt(userid, attempt)
+        formatted_attempt['combo'] = attempt.data.get_int('combo', -1)
+        formatted_attempt['grade'] = {
+            SoundVoltexBase.GRADE_NO_PLAY: 'No Play',
+            SoundVoltexBase.GRADE_D: 'D',
+            SoundVoltexBase.GRADE_C: 'C',
+            SoundVoltexBase.GRADE_B: 'B',
+            SoundVoltexBase.GRADE_A: 'A',
+            SoundVoltexBase.GRADE_A_PLUS: 'A+',
+            SoundVoltexBase.GRADE_AA: 'AA',
+            SoundVoltexBase.GRADE_AA_PLUS: 'AA+',
+            SoundVoltexBase.GRADE_AAA: 'AAA',
+            SoundVoltexBase.GRADE_AAA_PLUS: 'AAA+',
+            SoundVoltexBase.GRADE_S: 'S',
+        }.get(attempt.data.get_int('grade'), 'No Play')
+        formatted_attempt['clear_type'] = {
+            SoundVoltexBase.CLEAR_TYPE_NO_PLAY: 'No Play',
+            SoundVoltexBase.CLEAR_TYPE_FAILED: 'Failed',
+            SoundVoltexBase.CLEAR_TYPE_CLEAR: 'Cleared',
+            SoundVoltexBase.CLEAR_TYPE_HARD_CLEAR: 'Hard Cleared',
+            SoundVoltexBase.CLEAR_TYPE_ULTIMATE_CHAIN: 'Ultimate Chain',
+            SoundVoltexBase.CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN: 'Perfect Ultimate Chain',
+        }.get(attempt.data.get_int('clear_type'), 'Failed')
+        formatted_attempt['medal'] = attempt.data.get_int('clear_type')
+        return formatted_attempt
+
+    def format_profile(self, profile: ValidatedDict, playstats: ValidatedDict) -> Dict[str, Any]:
+        formatted_profile = super().format_profile(profile, playstats)
+        formatted_profile['plays'] = playstats.get_int('total_plays')
+        return formatted_profile
+
+    def format_song(self, song: Song) -> Dict[str, Any]:
+        difficulties = [0, 0, 0, 0, 0]
+        difficulties[song.chart] = song.data.get_int('difficulty', 21)
+
+        formatted_song = super().format_song(song)
+        formatted_song['difficulties'] = difficulties
+        formatted_song['category'] = song.version
+        return formatted_song
+
+    def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
+        new_song = super().merge_song(existing, new)
+        if existing['difficulties'][new.chart] == 0:
+            new_song['difficulties'][new.chart] = new.data.get_int('difficulty', 21)
+        # Set the category to the earliest seen version of this song
+        if existing['category'] > new.version:
+            new_song['category'] = new.version
+        return new_song
diff --git a/bemani/frontend/static/__init__.py b/bemani/frontend/static/__init__.py
new file mode 100644
index 0000000..c1bf509
--- /dev/null
+++ b/bemani/frontend/static/__init__.py
@@ -0,0 +1,3 @@
+import os
+
+static_location = os.path.abspath(os.path.dirname(__file__))
diff --git a/bemani/frontend/static/ajax.js b/bemani/frontend/static/ajax.js
new file mode 100644
index 0000000..5a44856
--- /dev/null
+++ b/bemani/frontend/static/ajax.js
@@ -0,0 +1,33 @@
+var AJAX = {
+    get: function(url, resp) {
+        $.ajax({
+            dataType: "json",
+            contentType: "application/json; charset=utf-8",
+            url: url,
+            success: function(response) {
+                if (response.error) {
+                    Messages.error(response.message);
+                } else {
+                    resp(response);
+                }
+            },
+        });
+    },
+
+    post: function(url, data, resp) {
+        $.ajax({
+            type: "POST",
+            dataType: "json",
+            contentType: "application/json; charset=utf-8",
+            url: url,
+            data: JSON.stringify(data),
+            success: function(response) {
+                if (response.error) {
+                    Messages.error(response.message);
+                } else {
+                    resp(response);
+                }
+            },
+        });
+    },
+};
diff --git a/bemani/frontend/static/chart.bundle.min.js b/bemani/frontend/static/chart.bundle.min.js
new file mode 100644
index 0000000..f832ef4
--- /dev/null
+++ b/bemani/frontend/static/chart.bundle.min.js
@@ -0,0 +1,10 @@
+/*!
+ * Chart.js
+ * http://chartjs.org/
+ * Version: 2.7.1
+ *
+ * Copyright 2017 Nick Downie
+ * Released under the MIT license
+ * https://github.com/chartjs/Chart.js/blob/master/LICENSE.md
+ */
+!function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).Chart=t()}}(function(){return function t(e,n,i){function a(o,s){if(!n[o]){if(!e[o]){var l="function"==typeof require&&require;if(!s&&l)return l(o,!0);if(r)return r(o,!0);var u=new Error("Cannot find module '"+o+"'");throw u.code="MODULE_NOT_FOUND",u}var d=n[o]={exports:{}};e[o][0].call(d.exports,function(t){var n=e[o][1][t];return a(n||t)},d,d.exports,t,e,n,i)}return n[o].exports}for(var r="function"==typeof require&&require,o=0;o<i.length;o++)a(i[o]);return a}({1:[function(t,e,n){function i(t){if(t){var e=[0,0,0],n=1,i=t.match(/^#([a-fA-F0-9]{3})$/i);if(i){i=i[1];for(a=0;a<e.length;a++)e[a]=parseInt(i[a]+i[a],16)}else if(i=t.match(/^#([a-fA-F0-9]{6})$/i)){i=i[1];for(a=0;a<e.length;a++)e[a]=parseInt(i.slice(2*a,2*a+2),16)}else if(i=t.match(/^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i)){for(a=0;a<e.length;a++)e[a]=parseInt(i[a+1]);n=parseFloat(i[4])}else if(i=t.match(/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i)){for(a=0;a<e.length;a++)e[a]=Math.round(2.55*parseFloat(i[a+1]));n=parseFloat(i[4])}else if(i=t.match(/(\w+)/)){if("transparent"==i[1])return[0,0,0,0];if(!(e=c[i[1]]))return}for(var a=0;a<e.length;a++)e[a]=u(e[a],0,255);return n=n||0==n?u(n,0,1):1,e[3]=n,e}}function a(t){if(t){var e=t.match(/^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/);if(e){var n=parseFloat(e[4]);return[u(parseInt(e[1]),0,360),u(parseFloat(e[2]),0,100),u(parseFloat(e[3]),0,100),u(isNaN(n)?1:n,0,1)]}}}function r(t){if(t){var e=t.match(/^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/);if(e){var n=parseFloat(e[4]);return[u(parseInt(e[1]),0,360),u(parseFloat(e[2]),0,100),u(parseFloat(e[3]),0,100),u(isNaN(n)?1:n,0,1)]}}}function o(t,e){return void 0===e&&(e=void 0!==t[3]?t[3]:1),"rgba("+t[0]+", "+t[1]+", "+t[2]+", "+e+")"}function s(t,e){return"rgba("+Math.round(t[0]/255*100)+"%, "+Math.round(t[1]/255*100)+"%, "+Math.round(t[2]/255*100)+"%, "+(e||t[3]||1)+")"}function l(t,e){return void 0===e&&(e=void 0!==t[3]?t[3]:1),"hsla("+t[0]+", "+t[1]+"%, "+t[2]+"%, "+e+")"}function u(t,e,n){return Math.min(Math.max(e,t),n)}function d(t){var e=t.toString(16).toUpperCase();return e.length<2?"0"+e:e}var c=t(5);e.exports={getRgba:i,getHsla:a,getRgb:function(t){var e=i(t);return e&&e.slice(0,3)},getHsl:function(t){var e=a(t);return e&&e.slice(0,3)},getHwb:r,getAlpha:function(t){var e=i(t);return e?e[3]:(e=a(t))?e[3]:(e=r(t))?e[3]:void 0},hexString:function(t){return"#"+d(t[0])+d(t[1])+d(t[2])},rgbString:function(t,e){return e<1||t[3]&&t[3]<1?o(t,e):"rgb("+t[0]+", "+t[1]+", "+t[2]+")"},rgbaString:o,percentString:function(t,e){return e<1||t[3]&&t[3]<1?s(t,e):"rgb("+Math.round(t[0]/255*100)+"%, "+Math.round(t[1]/255*100)+"%, "+Math.round(t[2]/255*100)+"%)"},percentaString:s,hslString:function(t,e){return e<1||t[3]&&t[3]<1?l(t,e):"hsl("+t[0]+", "+t[1]+"%, "+t[2]+"%)"},hslaString:l,hwbString:function(t,e){return void 0===e&&(e=void 0!==t[3]?t[3]:1),"hwb("+t[0]+", "+t[1]+"%, "+t[2]+"%"+(void 0!==e&&1!==e?", "+e:"")+")"},keyword:function(t){return h[t.slice(0,3)]}};var h={};for(var f in c)h[c[f]]=f},{5:5}],2:[function(t,e,n){var i=t(4),a=t(1),r=function(t){if(t instanceof r)return t;if(!(this instanceof r))return new r(t);this.valid=!1,this.values={rgb:[0,0,0],hsl:[0,0,0],hsv:[0,0,0],hwb:[0,0,0],cmyk:[0,0,0,0],alpha:1};var e;"string"==typeof t?(e=a.getRgba(t))?this.setValues("rgb",e):(e=a.getHsla(t))?this.setValues("hsl",e):(e=a.getHwb(t))&&this.setValues("hwb",e):"object"==typeof t&&(void 0!==(e=t).r||void 0!==e.red?this.setValues("rgb",e):void 0!==e.l||void 0!==e.lightness?this.setValues("hsl",e):void 0!==e.v||void 0!==e.value?this.setValues("hsv",e):void 0!==e.w||void 0!==e.whiteness?this.setValues("hwb",e):void 0===e.c&&void 0===e.cyan||this.setValues("cmyk",e))};r.prototype={isValid:function(){return this.valid},rgb:function(){return this.setSpace("rgb",arguments)},hsl:function(){return this.setSpace("hsl",arguments)},hsv:function(){return this.setSpace("hsv",arguments)},hwb:function(){return this.setSpace("hwb",arguments)},cmyk:function(){return this.setSpace("cmyk",arguments)},rgbArray:function(){return this.values.rgb},hslArray:function(){return this.values.hsl},hsvArray:function(){return this.values.hsv},hwbArray:function(){var t=this.values;return 1!==t.alpha?t.hwb.concat([t.alpha]):t.hwb},cmykArray:function(){return this.values.cmyk},rgbaArray:function(){var t=this.values;return t.rgb.concat([t.alpha])},hslaArray:function(){var t=this.values;return t.hsl.concat([t.alpha])},alpha:function(t){return void 0===t?this.values.alpha:(this.setValues("alpha",t),this)},red:function(t){return this.setChannel("rgb",0,t)},green:function(t){return this.setChannel("rgb",1,t)},blue:function(t){return this.setChannel("rgb",2,t)},hue:function(t){return t&&(t=(t%=360)<0?360+t:t),this.setChannel("hsl",0,t)},saturation:function(t){return this.setChannel("hsl",1,t)},lightness:function(t){return this.setChannel("hsl",2,t)},saturationv:function(t){return this.setChannel("hsv",1,t)},whiteness:function(t){return this.setChannel("hwb",1,t)},blackness:function(t){return this.setChannel("hwb",2,t)},value:function(t){return this.setChannel("hsv",2,t)},cyan:function(t){return this.setChannel("cmyk",0,t)},magenta:function(t){return this.setChannel("cmyk",1,t)},yellow:function(t){return this.setChannel("cmyk",2,t)},black:function(t){return this.setChannel("cmyk",3,t)},hexString:function(){return a.hexString(this.values.rgb)},rgbString:function(){return a.rgbString(this.values.rgb,this.values.alpha)},rgbaString:function(){return a.rgbaString(this.values.rgb,this.values.alpha)},percentString:function(){return a.percentString(this.values.rgb,this.values.alpha)},hslString:function(){return a.hslString(this.values.hsl,this.values.alpha)},hslaString:function(){return a.hslaString(this.values.hsl,this.values.alpha)},hwbString:function(){return a.hwbString(this.values.hwb,this.values.alpha)},keyword:function(){return a.keyword(this.values.rgb,this.values.alpha)},rgbNumber:function(){var t=this.values.rgb;return t[0]<<16|t[1]<<8|t[2]},luminosity:function(){for(var t=this.values.rgb,e=[],n=0;n<t.length;n++){var i=t[n]/255;e[n]=i<=.03928?i/12.92:Math.pow((i+.055)/1.055,2.4)}return.2126*e[0]+.7152*e[1]+.0722*e[2]},contrast:function(t){var e=this.luminosity(),n=t.luminosity();return e>n?(e+.05)/(n+.05):(n+.05)/(e+.05)},level:function(t){var e=this.contrast(t);return e>=7.1?"AAA":e>=4.5?"AA":""},dark:function(){var t=this.values.rgb;return(299*t[0]+587*t[1]+114*t[2])/1e3<128},light:function(){return!this.dark()},negate:function(){for(var t=[],e=0;e<3;e++)t[e]=255-this.values.rgb[e];return this.setValues("rgb",t),this},lighten:function(t){var e=this.values.hsl;return e[2]+=e[2]*t,this.setValues("hsl",e),this},darken:function(t){var e=this.values.hsl;return e[2]-=e[2]*t,this.setValues("hsl",e),this},saturate:function(t){var e=this.values.hsl;return e[1]+=e[1]*t,this.setValues("hsl",e),this},desaturate:function(t){var e=this.values.hsl;return e[1]-=e[1]*t,this.setValues("hsl",e),this},whiten:function(t){var e=this.values.hwb;return e[1]+=e[1]*t,this.setValues("hwb",e),this},blacken:function(t){var e=this.values.hwb;return e[2]+=e[2]*t,this.setValues("hwb",e),this},greyscale:function(){var t=this.values.rgb,e=.3*t[0]+.59*t[1]+.11*t[2];return this.setValues("rgb",[e,e,e]),this},clearer:function(t){var e=this.values.alpha;return this.setValues("alpha",e-e*t),this},opaquer:function(t){var e=this.values.alpha;return this.setValues("alpha",e+e*t),this},rotate:function(t){var e=this.values.hsl,n=(e[0]+t)%360;return e[0]=n<0?360+n:n,this.setValues("hsl",e),this},mix:function(t,e){var n=this,i=t,a=void 0===e?.5:e,r=2*a-1,o=n.alpha()-i.alpha(),s=((r*o==-1?r:(r+o)/(1+r*o))+1)/2,l=1-s;return this.rgb(s*n.red()+l*i.red(),s*n.green()+l*i.green(),s*n.blue()+l*i.blue()).alpha(n.alpha()*a+i.alpha()*(1-a))},toJSON:function(){return this.rgb()},clone:function(){var t,e,n=new r,i=this.values,a=n.values;for(var o in i)i.hasOwnProperty(o)&&(t=i[o],"[object Array]"===(e={}.toString.call(t))?a[o]=t.slice(0):"[object Number]"===e?a[o]=t:console.error("unexpected color value:",t));return n}},r.prototype.spaces={rgb:["red","green","blue"],hsl:["hue","saturation","lightness"],hsv:["hue","saturation","value"],hwb:["hue","whiteness","blackness"],cmyk:["cyan","magenta","yellow","black"]},r.prototype.maxes={rgb:[255,255,255],hsl:[360,100,100],hsv:[360,100,100],hwb:[360,100,100],cmyk:[100,100,100,100]},r.prototype.getValues=function(t){for(var e=this.values,n={},i=0;i<t.length;i++)n[t.charAt(i)]=e[t][i];return 1!==e.alpha&&(n.a=e.alpha),n},r.prototype.setValues=function(t,e){var n,a=this.values,r=this.spaces,o=this.maxes,s=1;if(this.valid=!0,"alpha"===t)s=e;else if(e.length)a[t]=e.slice(0,t.length),s=e[t.length];else if(void 0!==e[t.charAt(0)]){for(n=0;n<t.length;n++)a[t][n]=e[t.charAt(n)];s=e.a}else if(void 0!==e[r[t][0]]){var l=r[t];for(n=0;n<t.length;n++)a[t][n]=e[l[n]];s=e.alpha}if(a.alpha=Math.max(0,Math.min(1,void 0===s?a.alpha:s)),"alpha"===t)return!1;var u;for(n=0;n<t.length;n++)u=Math.max(0,Math.min(o[t][n],a[t][n])),a[t][n]=Math.round(u);for(var d in r)d!==t&&(a[d]=i[t][d](a[t]));return!0},r.prototype.setSpace=function(t,e){var n=e[0];return void 0===n?this.getValues(t):("number"==typeof n&&(n=Array.prototype.slice.call(e)),this.setValues(t,n),this)},r.prototype.setChannel=function(t,e,n){var i=this.values[t];return void 0===n?i[e]:n===i[e]?this:(i[e]=n,this.setValues(t,i),this)},"undefined"!=typeof window&&(window.Color=r),e.exports=r},{1:1,4:4}],3:[function(t,e,n){function i(t){var e,n,i,a=t[0]/255,r=t[1]/255,o=t[2]/255,s=Math.min(a,r,o),l=Math.max(a,r,o),u=l-s;return l==s?e=0:a==l?e=(r-o)/u:r==l?e=2+(o-a)/u:o==l&&(e=4+(a-r)/u),(e=Math.min(60*e,360))<0&&(e+=360),i=(s+l)/2,n=l==s?0:i<=.5?u/(l+s):u/(2-l-s),[e,100*n,100*i]}function a(t){var e,n,i,a=t[0],r=t[1],o=t[2],s=Math.min(a,r,o),l=Math.max(a,r,o),u=l-s;return n=0==l?0:u/l*1e3/10,l==s?e=0:a==l?e=(r-o)/u:r==l?e=2+(o-a)/u:o==l&&(e=4+(a-r)/u),(e=Math.min(60*e,360))<0&&(e+=360),i=l/255*1e3/10,[e,n,i]}function o(t){var e=t[0],n=t[1],a=t[2];return[i(t)[0],100*(1/255*Math.min(e,Math.min(n,a))),100*(a=1-1/255*Math.max(e,Math.max(n,a)))]}function s(t){var e,n,i,a,r=t[0]/255,o=t[1]/255,s=t[2]/255;return a=Math.min(1-r,1-o,1-s),e=(1-r-a)/(1-a)||0,n=(1-o-a)/(1-a)||0,i=(1-s-a)/(1-a)||0,[100*e,100*n,100*i,100*a]}function l(t){return S[JSON.stringify(t)]}function u(t){var e=t[0]/255,n=t[1]/255,i=t[2]/255;return[100*(.4124*(e=e>.04045?Math.pow((e+.055)/1.055,2.4):e/12.92)+.3576*(n=n>.04045?Math.pow((n+.055)/1.055,2.4):n/12.92)+.1805*(i=i>.04045?Math.pow((i+.055)/1.055,2.4):i/12.92)),100*(.2126*e+.7152*n+.0722*i),100*(.0193*e+.1192*n+.9505*i)]}function d(t){var e,n,i,a=u(t),r=a[0],o=a[1],s=a[2];return r/=95.047,o/=100,s/=108.883,r=r>.008856?Math.pow(r,1/3):7.787*r+16/116,o=o>.008856?Math.pow(o,1/3):7.787*o+16/116,s=s>.008856?Math.pow(s,1/3):7.787*s+16/116,e=116*o-16,n=500*(r-o),i=200*(o-s),[e,n,i]}function c(t){var e,n,i,a,r,o=t[0]/360,s=t[1]/100,l=t[2]/100;if(0==s)return r=255*l,[r,r,r];e=2*l-(n=l<.5?l*(1+s):l+s-l*s),a=[0,0,0];for(var u=0;u<3;u++)(i=o+1/3*-(u-1))<0&&i++,i>1&&i--,r=6*i<1?e+6*(n-e)*i:2*i<1?n:3*i<2?e+(n-e)*(2/3-i)*6:e,a[u]=255*r;return a}function h(t){var e=t[0]/60,n=t[1]/100,i=t[2]/100,a=Math.floor(e)%6,r=e-Math.floor(e),o=255*i*(1-n),s=255*i*(1-n*r),l=255*i*(1-n*(1-r)),i=255*i;switch(a){case 0:return[i,l,o];case 1:return[s,i,o];case 2:return[o,i,l];case 3:return[o,s,i];case 4:return[l,o,i];case 5:return[i,o,s]}}function f(t){var e,n,i,a,o=t[0]/360,s=t[1]/100,l=t[2]/100,u=s+l;switch(u>1&&(s/=u,l/=u),e=Math.floor(6*o),n=1-l,i=6*o-e,0!=(1&e)&&(i=1-i),a=s+i*(n-s),e){default:case 6:case 0:r=n,g=a,b=s;break;case 1:r=a,g=n,b=s;break;case 2:r=s,g=n,b=a;break;case 3:r=s,g=a,b=n;break;case 4:r=a,g=s,b=n;break;case 5:r=n,g=s,b=a}return[255*r,255*g,255*b]}function m(t){var e,n,i,a=t[0]/100,r=t[1]/100,o=t[2]/100,s=t[3]/100;return e=1-Math.min(1,a*(1-s)+s),n=1-Math.min(1,r*(1-s)+s),i=1-Math.min(1,o*(1-s)+s),[255*e,255*n,255*i]}function p(t){var e,n,i,a=t[0]/100,r=t[1]/100,o=t[2]/100;return e=3.2406*a+-1.5372*r+-.4986*o,n=-.9689*a+1.8758*r+.0415*o,i=.0557*a+-.204*r+1.057*o,e=e>.0031308?1.055*Math.pow(e,1/2.4)-.055:e*=12.92,n=n>.0031308?1.055*Math.pow(n,1/2.4)-.055:n*=12.92,i=i>.0031308?1.055*Math.pow(i,1/2.4)-.055:i*=12.92,e=Math.min(Math.max(0,e),1),n=Math.min(Math.max(0,n),1),i=Math.min(Math.max(0,i),1),[255*e,255*n,255*i]}function v(t){var e,n,i,a=t[0],r=t[1],o=t[2];return a/=95.047,r/=100,o/=108.883,a=a>.008856?Math.pow(a,1/3):7.787*a+16/116,r=r>.008856?Math.pow(r,1/3):7.787*r+16/116,o=o>.008856?Math.pow(o,1/3):7.787*o+16/116,e=116*r-16,n=500*(a-r),i=200*(r-o),[e,n,i]}function y(t){var e,n,i,a,r=t[0],o=t[1],s=t[2];return r<=8?a=(n=100*r/903.3)/100*7.787+16/116:(n=100*Math.pow((r+16)/116,3),a=Math.pow(n/100,1/3)),e=e/95.047<=.008856?e=95.047*(o/500+a-16/116)/7.787:95.047*Math.pow(o/500+a,3),i=i/108.883<=.008859?i=108.883*(a-s/200-16/116)/7.787:108.883*Math.pow(a-s/200,3),[e,n,i]}function x(t){var e,n,i,a=t[0],r=t[1],o=t[2];return e=Math.atan2(o,r),(n=360*e/2/Math.PI)<0&&(n+=360),i=Math.sqrt(r*r+o*o),[a,i,n]}function _(t){return p(y(t))}function k(t){var e,n,i,a=t[0],r=t[1];return i=t[2]/360*2*Math.PI,e=r*Math.cos(i),n=r*Math.sin(i),[a,e,n]}function w(t){return M[t]}e.exports={rgb2hsl:i,rgb2hsv:a,rgb2hwb:o,rgb2cmyk:s,rgb2keyword:l,rgb2xyz:u,rgb2lab:d,rgb2lch:function(t){return x(d(t))},hsl2rgb:c,hsl2hsv:function(t){var e,n,i=t[0],a=t[1]/100,r=t[2]/100;return 0===r?[0,0,0]:(r*=2,a*=r<=1?r:2-r,n=(r+a)/2,e=2*a/(r+a),[i,100*e,100*n])},hsl2hwb:function(t){return o(c(t))},hsl2cmyk:function(t){return s(c(t))},hsl2keyword:function(t){return l(c(t))},hsv2rgb:h,hsv2hsl:function(t){var e,n,i=t[0],a=t[1]/100,r=t[2]/100;return n=(2-a)*r,e=a*r,e/=n<=1?n:2-n,e=e||0,n/=2,[i,100*e,100*n]},hsv2hwb:function(t){return o(h(t))},hsv2cmyk:function(t){return s(h(t))},hsv2keyword:function(t){return l(h(t))},hwb2rgb:f,hwb2hsl:function(t){return i(f(t))},hwb2hsv:function(t){return a(f(t))},hwb2cmyk:function(t){return s(f(t))},hwb2keyword:function(t){return l(f(t))},cmyk2rgb:m,cmyk2hsl:function(t){return i(m(t))},cmyk2hsv:function(t){return a(m(t))},cmyk2hwb:function(t){return o(m(t))},cmyk2keyword:function(t){return l(m(t))},keyword2rgb:w,keyword2hsl:function(t){return i(w(t))},keyword2hsv:function(t){return a(w(t))},keyword2hwb:function(t){return o(w(t))},keyword2cmyk:function(t){return s(w(t))},keyword2lab:function(t){return d(w(t))},keyword2xyz:function(t){return u(w(t))},xyz2rgb:p,xyz2lab:v,xyz2lch:function(t){return x(v(t))},lab2xyz:y,lab2rgb:_,lab2lch:x,lch2lab:k,lch2xyz:function(t){return y(k(t))},lch2rgb:function(t){return _(k(t))}};var M={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},S={};for(var D in M)S[JSON.stringify(M[D])]=D},{}],4:[function(t,e,n){var i=t(3),a=function(){return new u};for(var r in i){a[r+"Raw"]=function(t){return function(e){return"number"==typeof e&&(e=Array.prototype.slice.call(arguments)),i[t](e)}}(r);var o=/(\w+)2(\w+)/.exec(r),s=o[1],l=o[2];(a[s]=a[s]||{})[l]=a[r]=function(t){return function(e){"number"==typeof e&&(e=Array.prototype.slice.call(arguments));var n=i[t](e);if("string"==typeof n||void 0===n)return n;for(var a=0;a<n.length;a++)n[a]=Math.round(n[a]);return n}}(r)}var u=function(){this.convs={}};u.prototype.routeSpace=function(t,e){var n=e[0];return void 0===n?this.getValues(t):("number"==typeof n&&(n=Array.prototype.slice.call(e)),this.setValues(t,n))},u.prototype.setValues=function(t,e){return this.space=t,this.convs={},this.convs[t]=e,this},u.prototype.getValues=function(t){var e=this.convs[t];if(!e){var n=this.space,i=this.convs[n];e=a[n][t](i),this.convs[t]=e}return e},["rgb","hsl","hsv","cmyk","keyword"].forEach(function(t){u.prototype[t]=function(e){return this.routeSpace(t,arguments)}}),e.exports=a},{3:3}],5:[function(t,e,n){"use strict";e.exports={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}},{}],6:[function(t,e,n){!function(t,i){"object"==typeof n&&void 0!==e?e.exports=i():t.moment=i()}(this,function(){"use strict";function n(){return xe.apply(null,arguments)}function i(t){return t instanceof Array||"[object Array]"===Object.prototype.toString.call(t)}function a(t){return null!=t&&"[object Object]"===Object.prototype.toString.call(t)}function r(t){var e;for(e in t)return!1;return!0}function o(t){return void 0===t}function s(t){return"number"==typeof t||"[object Number]"===Object.prototype.toString.call(t)}function l(t){return t instanceof Date||"[object Date]"===Object.prototype.toString.call(t)}function u(t,e){var n,i=[];for(n=0;n<t.length;++n)i.push(e(t[n],n));return i}function d(t,e){return Object.prototype.hasOwnProperty.call(t,e)}function c(t,e){for(var n in e)d(e,n)&&(t[n]=e[n]);return d(e,"toString")&&(t.toString=e.toString),d(e,"valueOf")&&(t.valueOf=e.valueOf),t}function h(t,e,n,i){return Yt(t,e,n,i,!0).utc()}function f(){return{empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],meridiem:null,rfc2822:!1,weekdayMismatch:!1}}function g(t){return null==t._pf&&(t._pf=f()),t._pf}function m(t){if(null==t._isValid){var e=g(t),n=ke.call(e.parsedDateParts,function(t){return null!=t}),i=!isNaN(t._d.getTime())&&e.overflow<0&&!e.empty&&!e.invalidMonth&&!e.invalidWeekday&&!e.nullInput&&!e.invalidFormat&&!e.userInvalidated&&(!e.meridiem||e.meridiem&&n);if(t._strict&&(i=i&&0===e.charsLeftOver&&0===e.unusedTokens.length&&void 0===e.bigHour),null!=Object.isFrozen&&Object.isFrozen(t))return i;t._isValid=i}return t._isValid}function p(t){var e=h(NaN);return null!=t?c(g(e),t):g(e).userInvalidated=!0,e}function v(t,e){var n,i,a;if(o(e._isAMomentObject)||(t._isAMomentObject=e._isAMomentObject),o(e._i)||(t._i=e._i),o(e._f)||(t._f=e._f),o(e._l)||(t._l=e._l),o(e._strict)||(t._strict=e._strict),o(e._tzm)||(t._tzm=e._tzm),o(e._isUTC)||(t._isUTC=e._isUTC),o(e._offset)||(t._offset=e._offset),o(e._pf)||(t._pf=g(e)),o(e._locale)||(t._locale=e._locale),we.length>0)for(n=0;n<we.length;n++)o(a=e[i=we[n]])||(t[i]=a);return t}function y(t){v(this,t),this._d=new Date(null!=t._d?t._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),!1===Me&&(Me=!0,n.updateOffset(this),Me=!1)}function b(t){return t instanceof y||null!=t&&null!=t._isAMomentObject}function x(t){return t<0?Math.ceil(t)||0:Math.floor(t)}function _(t){var e=+t,n=0;return 0!==e&&isFinite(e)&&(n=x(e)),n}function k(t,e,n){var i,a=Math.min(t.length,e.length),r=Math.abs(t.length-e.length),o=0;for(i=0;i<a;i++)(n&&t[i]!==e[i]||!n&&_(t[i])!==_(e[i]))&&o++;return o+r}function w(t){!1===n.suppressDeprecationWarnings&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+t)}function M(t,e){var i=!0;return c(function(){if(null!=n.deprecationHandler&&n.deprecationHandler(null,t),i){for(var a,r=[],o=0;o<arguments.length;o++){if(a="","object"==typeof arguments[o]){a+="\n["+o+"] ";for(var s in arguments[0])a+=s+": "+arguments[0][s]+", ";a=a.slice(0,-2)}else a=arguments[o];r.push(a)}w(t+"\nArguments: "+Array.prototype.slice.call(r).join("")+"\n"+(new Error).stack),i=!1}return e.apply(this,arguments)},e)}function S(t,e){null!=n.deprecationHandler&&n.deprecationHandler(t,e),Se[t]||(w(e),Se[t]=!0)}function D(t){return t instanceof Function||"[object Function]"===Object.prototype.toString.call(t)}function C(t,e){var n,i=c({},t);for(n in e)d(e,n)&&(a(t[n])&&a(e[n])?(i[n]={},c(i[n],t[n]),c(i[n],e[n])):null!=e[n]?i[n]=e[n]:delete i[n]);for(n in t)d(t,n)&&!d(e,n)&&a(t[n])&&(i[n]=c({},i[n]));return i}function P(t){null!=t&&this.set(t)}function T(t,e){var n=t.toLowerCase();Te[n]=Te[n+"s"]=Te[e]=t}function A(t){return"string"==typeof t?Te[t]||Te[t.toLowerCase()]:void 0}function I(t){var e,n,i={};for(n in t)d(t,n)&&(e=A(n))&&(i[e]=t[n]);return i}function O(t,e){Ae[t]=e}function F(t){var e=[];for(var n in t)e.push({unit:n,priority:Ae[n]});return e.sort(function(t,e){return t.priority-e.priority}),e}function R(t,e){return function(i){return null!=i?(W(this,t,i),n.updateOffset(this,e),this):L(this,t)}}function L(t,e){return t.isValid()?t._d["get"+(t._isUTC?"UTC":"")+e]():NaN}function W(t,e,n){t.isValid()&&t._d["set"+(t._isUTC?"UTC":"")+e](n)}function Y(t,e,n){var i=""+Math.abs(t),a=e-i.length;return(t>=0?n?"+":"":"-")+Math.pow(10,Math.max(0,a)).toString().substr(1)+i}function N(t,e,n,i){var a=i;"string"==typeof i&&(a=function(){return this[i]()}),t&&(Re[t]=a),e&&(Re[e[0]]=function(){return Y(a.apply(this,arguments),e[1],e[2])}),n&&(Re[n]=function(){return this.localeData().ordinal(a.apply(this,arguments),t)})}function z(t){return t.match(/\[[\s\S]/)?t.replace(/^\[|\]$/g,""):t.replace(/\\/g,"")}function B(t){var e,n,i=t.match(Ie);for(e=0,n=i.length;e<n;e++)Re[i[e]]?i[e]=Re[i[e]]:i[e]=z(i[e]);return function(e){var a,r="";for(a=0;a<n;a++)r+=D(i[a])?i[a].call(e,t):i[a];return r}}function V(t,e){return t.isValid()?(e=H(e,t.localeData()),Fe[e]=Fe[e]||B(e),Fe[e](t)):t.localeData().invalidDate()}function H(t,e){var n=5;for(Oe.lastIndex=0;n>=0&&Oe.test(t);)t=t.replace(Oe,function(t){return e.longDateFormat(t)||t}),Oe.lastIndex=0,n-=1;return t}function E(t,e,n){Ke[t]=D(e)?e:function(t,i){return t&&n?n:e}}function j(t,e){return d(Ke,t)?Ke[t](e._strict,e._locale):new RegExp(U(t))}function U(t){return q(t.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(t,e,n,i,a){return e||n||i||a}))}function q(t){return t.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}function G(t,e){var n,i=e;for("string"==typeof t&&(t=[t]),s(e)&&(i=function(t,n){n[e]=_(t)}),n=0;n<t.length;n++)Qe[t[n]]=i}function Z(t,e){G(t,function(t,n,i,a){i._w=i._w||{},e(t,i._w,i,a)})}function X(t,e,n){null!=e&&d(Qe,t)&&Qe[t](e,n._a,n,t)}function J(t,e){return new Date(Date.UTC(t,e+1,0)).getUTCDate()}function K(t,e,n){var i,a,r,o=t.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],i=0;i<12;++i)r=h([2e3,i]),this._shortMonthsParse[i]=this.monthsShort(r,"").toLocaleLowerCase(),this._longMonthsParse[i]=this.months(r,"").toLocaleLowerCase();return n?"MMM"===e?-1!==(a=un.call(this._shortMonthsParse,o))?a:null:-1!==(a=un.call(this._longMonthsParse,o))?a:null:"MMM"===e?-1!==(a=un.call(this._shortMonthsParse,o))?a:-1!==(a=un.call(this._longMonthsParse,o))?a:null:-1!==(a=un.call(this._longMonthsParse,o))?a:-1!==(a=un.call(this._shortMonthsParse,o))?a:null}function Q(t,e){var n;if(!t.isValid())return t;if("string"==typeof e)if(/^\d+$/.test(e))e=_(e);else if(e=t.localeData().monthsParse(e),!s(e))return t;return n=Math.min(t.date(),J(t.year(),e)),t._d["set"+(t._isUTC?"UTC":"")+"Month"](e,n),t}function $(t){return null!=t?(Q(this,t),n.updateOffset(this,!0),this):L(this,"Month")}function tt(){function t(t,e){return e.length-t.length}var e,n,i=[],a=[],r=[];for(e=0;e<12;e++)n=h([2e3,e]),i.push(this.monthsShort(n,"")),a.push(this.months(n,"")),r.push(this.months(n,"")),r.push(this.monthsShort(n,""));for(i.sort(t),a.sort(t),r.sort(t),e=0;e<12;e++)i[e]=q(i[e]),a[e]=q(a[e]);for(e=0;e<24;e++)r[e]=q(r[e]);this._monthsRegex=new RegExp("^("+r.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+a.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+i.join("|")+")","i")}function et(t){return nt(t)?366:365}function nt(t){return t%4==0&&t%100!=0||t%400==0}function it(t,e,n,i,a,r,o){var s=new Date(t,e,n,i,a,r,o);return t<100&&t>=0&&isFinite(s.getFullYear())&&s.setFullYear(t),s}function at(t){var e=new Date(Date.UTC.apply(null,arguments));return t<100&&t>=0&&isFinite(e.getUTCFullYear())&&e.setUTCFullYear(t),e}function rt(t,e,n){var i=7+e-n;return-((7+at(t,0,i).getUTCDay()-e)%7)+i-1}function ot(t,e,n,i,a){var r,o,s=1+7*(e-1)+(7+n-i)%7+rt(t,i,a);return s<=0?o=et(r=t-1)+s:s>et(t)?(r=t+1,o=s-et(t)):(r=t,o=s),{year:r,dayOfYear:o}}function st(t,e,n){var i,a,r=rt(t.year(),e,n),o=Math.floor((t.dayOfYear()-r-1)/7)+1;return o<1?i=o+lt(a=t.year()-1,e,n):o>lt(t.year(),e,n)?(i=o-lt(t.year(),e,n),a=t.year()+1):(a=t.year(),i=o),{week:i,year:a}}function lt(t,e,n){var i=rt(t,e,n),a=rt(t+1,e,n);return(et(t)-i+a)/7}function ut(t,e){return"string"!=typeof t?t:isNaN(t)?"number"==typeof(t=e.weekdaysParse(t))?t:null:parseInt(t,10)}function dt(t,e){return"string"==typeof t?e.weekdaysParse(t)%7||7:isNaN(t)?null:t}function ct(t,e,n){var i,a,r,o=t.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],i=0;i<7;++i)r=h([2e3,1]).day(i),this._minWeekdaysParse[i]=this.weekdaysMin(r,"").toLocaleLowerCase(),this._shortWeekdaysParse[i]=this.weekdaysShort(r,"").toLocaleLowerCase(),this._weekdaysParse[i]=this.weekdays(r,"").toLocaleLowerCase();return n?"dddd"===e?-1!==(a=un.call(this._weekdaysParse,o))?a:null:"ddd"===e?-1!==(a=un.call(this._shortWeekdaysParse,o))?a:null:-1!==(a=un.call(this._minWeekdaysParse,o))?a:null:"dddd"===e?-1!==(a=un.call(this._weekdaysParse,o))?a:-1!==(a=un.call(this._shortWeekdaysParse,o))?a:-1!==(a=un.call(this._minWeekdaysParse,o))?a:null:"ddd"===e?-1!==(a=un.call(this._shortWeekdaysParse,o))?a:-1!==(a=un.call(this._weekdaysParse,o))?a:-1!==(a=un.call(this._minWeekdaysParse,o))?a:null:-1!==(a=un.call(this._minWeekdaysParse,o))?a:-1!==(a=un.call(this._weekdaysParse,o))?a:-1!==(a=un.call(this._shortWeekdaysParse,o))?a:null}function ht(){function t(t,e){return e.length-t.length}var e,n,i,a,r,o=[],s=[],l=[],u=[];for(e=0;e<7;e++)n=h([2e3,1]).day(e),i=this.weekdaysMin(n,""),a=this.weekdaysShort(n,""),r=this.weekdays(n,""),o.push(i),s.push(a),l.push(r),u.push(i),u.push(a),u.push(r);for(o.sort(t),s.sort(t),l.sort(t),u.sort(t),e=0;e<7;e++)s[e]=q(s[e]),l[e]=q(l[e]),u[e]=q(u[e]);this._weekdaysRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+l.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+s.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+o.join("|")+")","i")}function ft(){return this.hours()%12||12}function gt(t,e){N(t,0,0,function(){return this.localeData().meridiem(this.hours(),this.minutes(),e)})}function mt(t,e){return e._meridiemParse}function pt(t){return t?t.toLowerCase().replace("_","-"):t}function vt(t){for(var e,n,i,a,r=0;r<t.length;){for(e=(a=pt(t[r]).split("-")).length,n=(n=pt(t[r+1]))?n.split("-"):null;e>0;){if(i=yt(a.slice(0,e).join("-")))return i;if(n&&n.length>=e&&k(a,n,!0)>=e-1)break;e--}r++}return null}function yt(n){var i=null;if(!Sn[n]&&void 0!==e&&e&&e.exports)try{i=kn._abbr,t("./locale/"+n),bt(i)}catch(t){}return Sn[n]}function bt(t,e){var n;return t&&(n=o(e)?_t(t):xt(t,e))&&(kn=n),kn._abbr}function xt(t,e){if(null!==e){var n=Mn;if(e.abbr=t,null!=Sn[t])S("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),n=Sn[t]._config;else if(null!=e.parentLocale){if(null==Sn[e.parentLocale])return Dn[e.parentLocale]||(Dn[e.parentLocale]=[]),Dn[e.parentLocale].push({name:t,config:e}),null;n=Sn[e.parentLocale]._config}return Sn[t]=new P(C(n,e)),Dn[t]&&Dn[t].forEach(function(t){xt(t.name,t.config)}),bt(t),Sn[t]}return delete Sn[t],null}function _t(t){var e;if(t&&t._locale&&t._locale._abbr&&(t=t._locale._abbr),!t)return kn;if(!i(t)){if(e=yt(t))return e;t=[t]}return vt(t)}function kt(t){var e,n=t._a;return n&&-2===g(t).overflow&&(e=n[tn]<0||n[tn]>11?tn:n[en]<1||n[en]>J(n[$e],n[tn])?en:n[nn]<0||n[nn]>24||24===n[nn]&&(0!==n[an]||0!==n[rn]||0!==n[on])?nn:n[an]<0||n[an]>59?an:n[rn]<0||n[rn]>59?rn:n[on]<0||n[on]>999?on:-1,g(t)._overflowDayOfYear&&(e<$e||e>en)&&(e=en),g(t)._overflowWeeks&&-1===e&&(e=sn),g(t)._overflowWeekday&&-1===e&&(e=ln),g(t).overflow=e),t}function wt(t){var e,n,i,a,r,o,s=t._i,l=Cn.exec(s)||Pn.exec(s);if(l){for(g(t).iso=!0,e=0,n=An.length;e<n;e++)if(An[e][1].exec(l[1])){a=An[e][0],i=!1!==An[e][2];break}if(null==a)return void(t._isValid=!1);if(l[3]){for(e=0,n=In.length;e<n;e++)if(In[e][1].exec(l[3])){r=(l[2]||" ")+In[e][0];break}if(null==r)return void(t._isValid=!1)}if(!i&&null!=r)return void(t._isValid=!1);if(l[4]){if(!Tn.exec(l[4]))return void(t._isValid=!1);o="Z"}t._f=a+(r||"")+(o||""),At(t)}else t._isValid=!1}function Mt(t){var e,n,i,a,r,o,s,l,u={" GMT":" +0000"," EDT":" -0400"," EST":" -0500"," CDT":" -0500"," CST":" -0600"," MDT":" -0600"," MST":" -0700"," PDT":" -0700"," PST":" -0800"};if(e=t._i.replace(/\([^\)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").replace(/^\s|\s$/g,""),n=Fn.exec(e)){if(i=n[1]?"ddd"+(5===n[1].length?", ":" "):"",a="D MMM "+(n[2].length>10?"YYYY ":"YY "),r="HH:mm"+(n[4]?":ss":""),n[1]){var d=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"][new Date(n[2]).getDay()];if(n[1].substr(0,3)!==d)return g(t).weekdayMismatch=!0,void(t._isValid=!1)}switch(n[5].length){case 2:s=0===l?" +0000":((l="YXWVUTSRQPONZABCDEFGHIKLM".indexOf(n[5][1].toUpperCase())-12)<0?" -":" +")+(""+l).replace(/^-?/,"0").match(/..$/)[0]+"00";break;case 4:s=u[n[5]];break;default:s=u[" GMT"]}n[5]=s,t._i=n.splice(1).join(""),o=" ZZ",t._f=i+a+r+o,At(t),g(t).rfc2822=!0}else t._isValid=!1}function St(t){var e=On.exec(t._i);null===e?(wt(t),!1===t._isValid&&(delete t._isValid,Mt(t),!1===t._isValid&&(delete t._isValid,n.createFromInputFallback(t)))):t._d=new Date(+e[1])}function Dt(t,e,n){return null!=t?t:null!=e?e:n}function Ct(t){var e=new Date(n.now());return t._useUTC?[e.getUTCFullYear(),e.getUTCMonth(),e.getUTCDate()]:[e.getFullYear(),e.getMonth(),e.getDate()]}function Pt(t){var e,n,i,a,r=[];if(!t._d){for(i=Ct(t),t._w&&null==t._a[en]&&null==t._a[tn]&&Tt(t),null!=t._dayOfYear&&(a=Dt(t._a[$e],i[$e]),(t._dayOfYear>et(a)||0===t._dayOfYear)&&(g(t)._overflowDayOfYear=!0),n=at(a,0,t._dayOfYear),t._a[tn]=n.getUTCMonth(),t._a[en]=n.getUTCDate()),e=0;e<3&&null==t._a[e];++e)t._a[e]=r[e]=i[e];for(;e<7;e++)t._a[e]=r[e]=null==t._a[e]?2===e?1:0:t._a[e];24===t._a[nn]&&0===t._a[an]&&0===t._a[rn]&&0===t._a[on]&&(t._nextDay=!0,t._a[nn]=0),t._d=(t._useUTC?at:it).apply(null,r),null!=t._tzm&&t._d.setUTCMinutes(t._d.getUTCMinutes()-t._tzm),t._nextDay&&(t._a[nn]=24)}}function Tt(t){var e,n,i,a,r,o,s,l;if(null!=(e=t._w).GG||null!=e.W||null!=e.E)r=1,o=4,n=Dt(e.GG,t._a[$e],st(Nt(),1,4).year),i=Dt(e.W,1),((a=Dt(e.E,1))<1||a>7)&&(l=!0);else{r=t._locale._week.dow,o=t._locale._week.doy;var u=st(Nt(),r,o);n=Dt(e.gg,t._a[$e],u.year),i=Dt(e.w,u.week),null!=e.d?((a=e.d)<0||a>6)&&(l=!0):null!=e.e?(a=e.e+r,(e.e<0||e.e>6)&&(l=!0)):a=r}i<1||i>lt(n,r,o)?g(t)._overflowWeeks=!0:null!=l?g(t)._overflowWeekday=!0:(s=ot(n,i,a,r,o),t._a[$e]=s.year,t._dayOfYear=s.dayOfYear)}function At(t){if(t._f!==n.ISO_8601)if(t._f!==n.RFC_2822){t._a=[],g(t).empty=!0;var e,i,a,r,o,s=""+t._i,l=s.length,u=0;for(a=H(t._f,t._locale).match(Ie)||[],e=0;e<a.length;e++)r=a[e],(i=(s.match(j(r,t))||[])[0])&&((o=s.substr(0,s.indexOf(i))).length>0&&g(t).unusedInput.push(o),s=s.slice(s.indexOf(i)+i.length),u+=i.length),Re[r]?(i?g(t).empty=!1:g(t).unusedTokens.push(r),X(r,i,t)):t._strict&&!i&&g(t).unusedTokens.push(r);g(t).charsLeftOver=l-u,s.length>0&&g(t).unusedInput.push(s),t._a[nn]<=12&&!0===g(t).bigHour&&t._a[nn]>0&&(g(t).bigHour=void 0),g(t).parsedDateParts=t._a.slice(0),g(t).meridiem=t._meridiem,t._a[nn]=It(t._locale,t._a[nn],t._meridiem),Pt(t),kt(t)}else Mt(t);else wt(t)}function It(t,e,n){var i;return null==n?e:null!=t.meridiemHour?t.meridiemHour(e,n):null!=t.isPM?((i=t.isPM(n))&&e<12&&(e+=12),i||12!==e||(e=0),e):e}function Ot(t){var e,n,i,a,r;if(0===t._f.length)return g(t).invalidFormat=!0,void(t._d=new Date(NaN));for(a=0;a<t._f.length;a++)r=0,e=v({},t),null!=t._useUTC&&(e._useUTC=t._useUTC),e._f=t._f[a],At(e),m(e)&&(r+=g(e).charsLeftOver,r+=10*g(e).unusedTokens.length,g(e).score=r,(null==i||r<i)&&(i=r,n=e));c(t,n||e)}function Ft(t){if(!t._d){var e=I(t._i);t._a=u([e.year,e.month,e.day||e.date,e.hour,e.minute,e.second,e.millisecond],function(t){return t&&parseInt(t,10)}),Pt(t)}}function Rt(t){var e=new y(kt(Lt(t)));return e._nextDay&&(e.add(1,"d"),e._nextDay=void 0),e}function Lt(t){var e=t._i,n=t._f;return t._locale=t._locale||_t(t._l),null===e||void 0===n&&""===e?p({nullInput:!0}):("string"==typeof e&&(t._i=e=t._locale.preparse(e)),b(e)?new y(kt(e)):(l(e)?t._d=e:i(n)?Ot(t):n?At(t):Wt(t),m(t)||(t._d=null),t))}function Wt(t){var e=t._i;o(e)?t._d=new Date(n.now()):l(e)?t._d=new Date(e.valueOf()):"string"==typeof e?St(t):i(e)?(t._a=u(e.slice(0),function(t){return parseInt(t,10)}),Pt(t)):a(e)?Ft(t):s(e)?t._d=new Date(e):n.createFromInputFallback(t)}function Yt(t,e,n,o,s){var l={};return!0!==n&&!1!==n||(o=n,n=void 0),(a(t)&&r(t)||i(t)&&0===t.length)&&(t=void 0),l._isAMomentObject=!0,l._useUTC=l._isUTC=s,l._l=n,l._i=t,l._f=e,l._strict=o,Rt(l)}function Nt(t,e,n,i){return Yt(t,e,n,i,!1)}function zt(t,e){var n,a;if(1===e.length&&i(e[0])&&(e=e[0]),!e.length)return Nt();for(n=e[0],a=1;a<e.length;++a)e[a].isValid()&&!e[a][t](n)||(n=e[a]);return n}function Bt(t){for(var e in t)if(-1===Wn.indexOf(e)||null!=t[e]&&isNaN(t[e]))return!1;for(var n=!1,i=0;i<Wn.length;++i)if(t[Wn[i]]){if(n)return!1;parseFloat(t[Wn[i]])!==_(t[Wn[i]])&&(n=!0)}return!0}function Vt(t){var e=I(t),n=e.year||0,i=e.quarter||0,a=e.month||0,r=e.week||0,o=e.day||0,s=e.hour||0,l=e.minute||0,u=e.second||0,d=e.millisecond||0;this._isValid=Bt(e),this._milliseconds=+d+1e3*u+6e4*l+1e3*s*60*60,this._days=+o+7*r,this._months=+a+3*i+12*n,this._data={},this._locale=_t(),this._bubble()}function Ht(t){return t instanceof Vt}function Et(t){return t<0?-1*Math.round(-1*t):Math.round(t)}function jt(t,e){N(t,0,0,function(){var t=this.utcOffset(),n="+";return t<0&&(t=-t,n="-"),n+Y(~~(t/60),2)+e+Y(~~t%60,2)})}function Ut(t,e){var n=(e||"").match(t);if(null===n)return null;var i=((n[n.length-1]||[])+"").match(Yn)||["-",0,0],a=60*i[1]+_(i[2]);return 0===a?0:"+"===i[0]?a:-a}function qt(t,e){var i,a;return e._isUTC?(i=e.clone(),a=(b(t)||l(t)?t.valueOf():Nt(t).valueOf())-i.valueOf(),i._d.setTime(i._d.valueOf()+a),n.updateOffset(i,!1),i):Nt(t).local()}function Gt(t){return 15*-Math.round(t._d.getTimezoneOffset()/15)}function Zt(){return!!this.isValid()&&(this._isUTC&&0===this._offset)}function Xt(t,e){var n,i,a,r=t,o=null;return Ht(t)?r={ms:t._milliseconds,d:t._days,M:t._months}:s(t)?(r={},e?r[e]=t:r.milliseconds=t):(o=Nn.exec(t))?(n="-"===o[1]?-1:1,r={y:0,d:_(o[en])*n,h:_(o[nn])*n,m:_(o[an])*n,s:_(o[rn])*n,ms:_(Et(1e3*o[on]))*n}):(o=zn.exec(t))?(n="-"===o[1]?-1:1,r={y:Jt(o[2],n),M:Jt(o[3],n),w:Jt(o[4],n),d:Jt(o[5],n),h:Jt(o[6],n),m:Jt(o[7],n),s:Jt(o[8],n)}):null==r?r={}:"object"==typeof r&&("from"in r||"to"in r)&&(a=Qt(Nt(r.from),Nt(r.to)),(r={}).ms=a.milliseconds,r.M=a.months),i=new Vt(r),Ht(t)&&d(t,"_locale")&&(i._locale=t._locale),i}function Jt(t,e){var n=t&&parseFloat(t.replace(",","."));return(isNaN(n)?0:n)*e}function Kt(t,e){var n={milliseconds:0,months:0};return n.months=e.month()-t.month()+12*(e.year()-t.year()),t.clone().add(n.months,"M").isAfter(e)&&--n.months,n.milliseconds=+e-+t.clone().add(n.months,"M"),n}function Qt(t,e){var n;return t.isValid()&&e.isValid()?(e=qt(e,t),t.isBefore(e)?n=Kt(t,e):((n=Kt(e,t)).milliseconds=-n.milliseconds,n.months=-n.months),n):{milliseconds:0,months:0}}function $t(t,e){return function(n,i){var a,r;return null===i||isNaN(+i)||(S(e,"moment()."+e+"(period, number) is deprecated. Please use moment()."+e+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),r=n,n=i,i=r),n="string"==typeof n?+n:n,a=Xt(n,i),te(this,a,t),this}}function te(t,e,i,a){var r=e._milliseconds,o=Et(e._days),s=Et(e._months);t.isValid()&&(a=null==a||a,r&&t._d.setTime(t._d.valueOf()+r*i),o&&W(t,"Date",L(t,"Date")+o*i),s&&Q(t,L(t,"Month")+s*i),a&&n.updateOffset(t,o||s))}function ee(t,e){var n,i=12*(e.year()-t.year())+(e.month()-t.month()),a=t.clone().add(i,"months");return n=e-a<0?(e-a)/(a-t.clone().add(i-1,"months")):(e-a)/(t.clone().add(i+1,"months")-a),-(i+n)||0}function ne(t){var e;return void 0===t?this._locale._abbr:(null!=(e=_t(t))&&(this._locale=e),this)}function ie(){return this._locale}function ae(t,e){N(0,[t,t.length],0,e)}function re(t,e,n,i,a){var r;return null==t?st(this,i,a).year:(r=lt(t,i,a),e>r&&(e=r),oe.call(this,t,e,n,i,a))}function oe(t,e,n,i,a){var r=ot(t,e,n,i,a),o=at(r.year,0,r.dayOfYear);return this.year(o.getUTCFullYear()),this.month(o.getUTCMonth()),this.date(o.getUTCDate()),this}function se(t){return t}function le(t,e,n,i){var a=_t(),r=h().set(i,e);return a[n](r,t)}function ue(t,e,n){if(s(t)&&(e=t,t=void 0),t=t||"",null!=e)return le(t,e,n,"month");var i,a=[];for(i=0;i<12;i++)a[i]=le(t,i,n,"month");return a}function de(t,e,n,i){"boolean"==typeof t?(s(e)&&(n=e,e=void 0),e=e||""):(n=e=t,t=!1,s(e)&&(n=e,e=void 0),e=e||"");var a=_t(),r=t?a._week.dow:0;if(null!=n)return le(e,(n+r)%7,i,"day");var o,l=[];for(o=0;o<7;o++)l[o]=le(e,(o+r)%7,i,"day");return l}function ce(t,e,n,i){var a=Xt(e,n);return t._milliseconds+=i*a._milliseconds,t._days+=i*a._days,t._months+=i*a._months,t._bubble()}function he(t){return t<0?Math.floor(t):Math.ceil(t)}function fe(t){return 4800*t/146097}function ge(t){return 146097*t/4800}function me(t){return function(){return this.as(t)}}function pe(t){return function(){return this.isValid()?this._data[t]:NaN}}function ve(t,e,n,i,a){return a.relativeTime(e||1,!!n,t,i)}function ye(t,e,n){var i=Xt(t).abs(),a=hi(i.as("s")),r=hi(i.as("m")),o=hi(i.as("h")),s=hi(i.as("d")),l=hi(i.as("M")),u=hi(i.as("y")),d=a<=fi.ss&&["s",a]||a<fi.s&&["ss",a]||r<=1&&["m"]||r<fi.m&&["mm",r]||o<=1&&["h"]||o<fi.h&&["hh",o]||s<=1&&["d"]||s<fi.d&&["dd",s]||l<=1&&["M"]||l<fi.M&&["MM",l]||u<=1&&["y"]||["yy",u];return d[2]=e,d[3]=+t>0,d[4]=n,ve.apply(null,d)}function be(){if(!this.isValid())return this.localeData().invalidDate();var t,e,n,i=gi(this._milliseconds)/1e3,a=gi(this._days),r=gi(this._months);e=x((t=x(i/60))/60),i%=60,t%=60;var o=n=x(r/12),s=r%=12,l=a,u=e,d=t,c=i,h=this.asSeconds();return h?(h<0?"-":"")+"P"+(o?o+"Y":"")+(s?s+"M":"")+(l?l+"D":"")+(u||d||c?"T":"")+(u?u+"H":"")+(d?d+"M":"")+(c?c+"S":""):"P0D"}var xe,_e,ke=_e=Array.prototype.some?Array.prototype.some:function(t){for(var e=Object(this),n=e.length>>>0,i=0;i<n;i++)if(i in e&&t.call(this,e[i],i,e))return!0;return!1},we=n.momentProperties=[],Me=!1,Se={};n.suppressDeprecationWarnings=!1,n.deprecationHandler=null;var De,Ce,Pe=De=Object.keys?Object.keys:function(t){var e,n=[];for(e in t)d(t,e)&&n.push(e);return n},Te={},Ae={},Ie=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,Oe=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,Fe={},Re={},Le=/\d/,We=/\d\d/,Ye=/\d{3}/,Ne=/\d{4}/,ze=/[+-]?\d{6}/,Be=/\d\d?/,Ve=/\d\d\d\d?/,He=/\d\d\d\d\d\d?/,Ee=/\d{1,3}/,je=/\d{1,4}/,Ue=/[+-]?\d{1,6}/,qe=/\d+/,Ge=/[+-]?\d+/,Ze=/Z|[+-]\d\d:?\d\d/gi,Xe=/Z|[+-]\d\d(?::?\d\d)?/gi,Je=/[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i,Ke={},Qe={},$e=0,tn=1,en=2,nn=3,an=4,rn=5,on=6,sn=7,ln=8,un=Ce=Array.prototype.indexOf?Array.prototype.indexOf:function(t){var e;for(e=0;e<this.length;++e)if(this[e]===t)return e;return-1};N("M",["MM",2],"Mo",function(){return this.month()+1}),N("MMM",0,0,function(t){return this.localeData().monthsShort(this,t)}),N("MMMM",0,0,function(t){return this.localeData().months(this,t)}),T("month","M"),O("month",8),E("M",Be),E("MM",Be,We),E("MMM",function(t,e){return e.monthsShortRegex(t)}),E("MMMM",function(t,e){return e.monthsRegex(t)}),G(["M","MM"],function(t,e){e[tn]=_(t)-1}),G(["MMM","MMMM"],function(t,e,n,i){var a=n._locale.monthsParse(t,i,n._strict);null!=a?e[tn]=a:g(n).invalidMonth=t});var dn=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,cn="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),hn="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),fn=Je,gn=Je;N("Y",0,0,function(){var t=this.year();return t<=9999?""+t:"+"+t}),N(0,["YY",2],0,function(){return this.year()%100}),N(0,["YYYY",4],0,"year"),N(0,["YYYYY",5],0,"year"),N(0,["YYYYYY",6,!0],0,"year"),T("year","y"),O("year",1),E("Y",Ge),E("YY",Be,We),E("YYYY",je,Ne),E("YYYYY",Ue,ze),E("YYYYYY",Ue,ze),G(["YYYYY","YYYYYY"],$e),G("YYYY",function(t,e){e[$e]=2===t.length?n.parseTwoDigitYear(t):_(t)}),G("YY",function(t,e){e[$e]=n.parseTwoDigitYear(t)}),G("Y",function(t,e){e[$e]=parseInt(t,10)}),n.parseTwoDigitYear=function(t){return _(t)+(_(t)>68?1900:2e3)};var mn=R("FullYear",!0);N("w",["ww",2],"wo","week"),N("W",["WW",2],"Wo","isoWeek"),T("week","w"),T("isoWeek","W"),O("week",5),O("isoWeek",5),E("w",Be),E("ww",Be,We),E("W",Be),E("WW",Be,We),Z(["w","ww","W","WW"],function(t,e,n,i){e[i.substr(0,1)]=_(t)});N("d",0,"do","day"),N("dd",0,0,function(t){return this.localeData().weekdaysMin(this,t)}),N("ddd",0,0,function(t){return this.localeData().weekdaysShort(this,t)}),N("dddd",0,0,function(t){return this.localeData().weekdays(this,t)}),N("e",0,0,"weekday"),N("E",0,0,"isoWeekday"),T("day","d"),T("weekday","e"),T("isoWeekday","E"),O("day",11),O("weekday",11),O("isoWeekday",11),E("d",Be),E("e",Be),E("E",Be),E("dd",function(t,e){return e.weekdaysMinRegex(t)}),E("ddd",function(t,e){return e.weekdaysShortRegex(t)}),E("dddd",function(t,e){return e.weekdaysRegex(t)}),Z(["dd","ddd","dddd"],function(t,e,n,i){var a=n._locale.weekdaysParse(t,i,n._strict);null!=a?e.d=a:g(n).invalidWeekday=t}),Z(["d","e","E"],function(t,e,n,i){e[i]=_(t)});var pn="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),vn="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),yn="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),bn=Je,xn=Je,_n=Je;N("H",["HH",2],0,"hour"),N("h",["hh",2],0,ft),N("k",["kk",2],0,function(){return this.hours()||24}),N("hmm",0,0,function(){return""+ft.apply(this)+Y(this.minutes(),2)}),N("hmmss",0,0,function(){return""+ft.apply(this)+Y(this.minutes(),2)+Y(this.seconds(),2)}),N("Hmm",0,0,function(){return""+this.hours()+Y(this.minutes(),2)}),N("Hmmss",0,0,function(){return""+this.hours()+Y(this.minutes(),2)+Y(this.seconds(),2)}),gt("a",!0),gt("A",!1),T("hour","h"),O("hour",13),E("a",mt),E("A",mt),E("H",Be),E("h",Be),E("k",Be),E("HH",Be,We),E("hh",Be,We),E("kk",Be,We),E("hmm",Ve),E("hmmss",He),E("Hmm",Ve),E("Hmmss",He),G(["H","HH"],nn),G(["k","kk"],function(t,e,n){var i=_(t);e[nn]=24===i?0:i}),G(["a","A"],function(t,e,n){n._isPm=n._locale.isPM(t),n._meridiem=t}),G(["h","hh"],function(t,e,n){e[nn]=_(t),g(n).bigHour=!0}),G("hmm",function(t,e,n){var i=t.length-2;e[nn]=_(t.substr(0,i)),e[an]=_(t.substr(i)),g(n).bigHour=!0}),G("hmmss",function(t,e,n){var i=t.length-4,a=t.length-2;e[nn]=_(t.substr(0,i)),e[an]=_(t.substr(i,2)),e[rn]=_(t.substr(a)),g(n).bigHour=!0}),G("Hmm",function(t,e,n){var i=t.length-2;e[nn]=_(t.substr(0,i)),e[an]=_(t.substr(i))}),G("Hmmss",function(t,e,n){var i=t.length-4,a=t.length-2;e[nn]=_(t.substr(0,i)),e[an]=_(t.substr(i,2)),e[rn]=_(t.substr(a))});var kn,wn=R("Hours",!0),Mn={calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},longDateFormat:{LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},invalidDate:"Invalid date",ordinal:"%d",dayOfMonthOrdinalParse:/\d{1,2}/,relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},months:cn,monthsShort:hn,week:{dow:0,doy:6},weekdays:pn,weekdaysMin:yn,weekdaysShort:vn,meridiemParse:/[ap]\.?m?\.?/i},Sn={},Dn={},Cn=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Pn=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Tn=/Z|[+-]\d\d(?::?\d\d)?/,An=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/]],In=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],On=/^\/?Date\((\-?\d+)/i,Fn=/^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d?\d\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?:\d\d)?\d\d\s)(\d\d:\d\d)(\:\d\d)?(\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\d{4}))$/;n.createFromInputFallback=M("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged and will be removed in an upcoming major release. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",function(t){t._d=new Date(t._i+(t._useUTC?" UTC":""))}),n.ISO_8601=function(){},n.RFC_2822=function(){};var Rn=M("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",function(){var t=Nt.apply(null,arguments);return this.isValid()&&t.isValid()?t<this?this:t:p()}),Ln=M("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",function(){var t=Nt.apply(null,arguments);return this.isValid()&&t.isValid()?t>this?this:t:p()}),Wn=["year","quarter","month","week","day","hour","minute","second","millisecond"];jt("Z",":"),jt("ZZ",""),E("Z",Xe),E("ZZ",Xe),G(["Z","ZZ"],function(t,e,n){n._useUTC=!0,n._tzm=Ut(Xe,t)});var Yn=/([\+\-]|\d\d)/gi;n.updateOffset=function(){};var Nn=/^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/,zn=/^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;Xt.fn=Vt.prototype,Xt.invalid=function(){return Xt(NaN)};var Bn=$t(1,"add"),Vn=$t(-1,"subtract");n.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",n.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var Hn=M("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",function(t){return void 0===t?this.localeData():this.locale(t)});N(0,["gg",2],0,function(){return this.weekYear()%100}),N(0,["GG",2],0,function(){return this.isoWeekYear()%100}),ae("gggg","weekYear"),ae("ggggg","weekYear"),ae("GGGG","isoWeekYear"),ae("GGGGG","isoWeekYear"),T("weekYear","gg"),T("isoWeekYear","GG"),O("weekYear",1),O("isoWeekYear",1),E("G",Ge),E("g",Ge),E("GG",Be,We),E("gg",Be,We),E("GGGG",je,Ne),E("gggg",je,Ne),E("GGGGG",Ue,ze),E("ggggg",Ue,ze),Z(["gggg","ggggg","GGGG","GGGGG"],function(t,e,n,i){e[i.substr(0,2)]=_(t)}),Z(["gg","GG"],function(t,e,i,a){e[a]=n.parseTwoDigitYear(t)}),N("Q",0,"Qo","quarter"),T("quarter","Q"),O("quarter",7),E("Q",Le),G("Q",function(t,e){e[tn]=3*(_(t)-1)}),N("D",["DD",2],"Do","date"),T("date","D"),O("date",9),E("D",Be),E("DD",Be,We),E("Do",function(t,e){return t?e._dayOfMonthOrdinalParse||e._ordinalParse:e._dayOfMonthOrdinalParseLenient}),G(["D","DD"],en),G("Do",function(t,e){e[en]=_(t.match(Be)[0],10)});var En=R("Date",!0);N("DDD",["DDDD",3],"DDDo","dayOfYear"),T("dayOfYear","DDD"),O("dayOfYear",4),E("DDD",Ee),E("DDDD",Ye),G(["DDD","DDDD"],function(t,e,n){n._dayOfYear=_(t)}),N("m",["mm",2],0,"minute"),T("minute","m"),O("minute",14),E("m",Be),E("mm",Be,We),G(["m","mm"],an);var jn=R("Minutes",!1);N("s",["ss",2],0,"second"),T("second","s"),O("second",15),E("s",Be),E("ss",Be,We),G(["s","ss"],rn);var Un=R("Seconds",!1);N("S",0,0,function(){return~~(this.millisecond()/100)}),N(0,["SS",2],0,function(){return~~(this.millisecond()/10)}),N(0,["SSS",3],0,"millisecond"),N(0,["SSSS",4],0,function(){return 10*this.millisecond()}),N(0,["SSSSS",5],0,function(){return 100*this.millisecond()}),N(0,["SSSSSS",6],0,function(){return 1e3*this.millisecond()}),N(0,["SSSSSSS",7],0,function(){return 1e4*this.millisecond()}),N(0,["SSSSSSSS",8],0,function(){return 1e5*this.millisecond()}),N(0,["SSSSSSSSS",9],0,function(){return 1e6*this.millisecond()}),T("millisecond","ms"),O("millisecond",16),E("S",Ee,Le),E("SS",Ee,We),E("SSS",Ee,Ye);var qn;for(qn="SSSS";qn.length<=9;qn+="S")E(qn,qe);for(qn="S";qn.length<=9;qn+="S")G(qn,function(t,e){e[on]=_(1e3*("0."+t))});var Gn=R("Milliseconds",!1);N("z",0,0,"zoneAbbr"),N("zz",0,0,"zoneName");var Zn=y.prototype;Zn.add=Bn,Zn.calendar=function(t,e){var i=t||Nt(),a=qt(i,this).startOf("day"),r=n.calendarFormat(this,a)||"sameElse",o=e&&(D(e[r])?e[r].call(this,i):e[r]);return this.format(o||this.localeData().calendar(r,this,Nt(i)))},Zn.clone=function(){return new y(this)},Zn.diff=function(t,e,n){var i,a,r,o;return this.isValid()&&(i=qt(t,this)).isValid()?(a=6e4*(i.utcOffset()-this.utcOffset()),"year"===(e=A(e))||"month"===e||"quarter"===e?(o=ee(this,i),"quarter"===e?o/=3:"year"===e&&(o/=12)):(r=this-i,o="second"===e?r/1e3:"minute"===e?r/6e4:"hour"===e?r/36e5:"day"===e?(r-a)/864e5:"week"===e?(r-a)/6048e5:r),n?o:x(o)):NaN},Zn.endOf=function(t){return void 0===(t=A(t))||"millisecond"===t?this:("date"===t&&(t="day"),this.startOf(t).add(1,"isoWeek"===t?"week":t).subtract(1,"ms"))},Zn.format=function(t){t||(t=this.isUtc()?n.defaultFormatUtc:n.defaultFormat);var e=V(this,t);return this.localeData().postformat(e)},Zn.from=function(t,e){return this.isValid()&&(b(t)&&t.isValid()||Nt(t).isValid())?Xt({to:this,from:t}).locale(this.locale()).humanize(!e):this.localeData().invalidDate()},Zn.fromNow=function(t){return this.from(Nt(),t)},Zn.to=function(t,e){return this.isValid()&&(b(t)&&t.isValid()||Nt(t).isValid())?Xt({from:this,to:t}).locale(this.locale()).humanize(!e):this.localeData().invalidDate()},Zn.toNow=function(t){return this.to(Nt(),t)},Zn.get=function(t){return t=A(t),D(this[t])?this[t]():this},Zn.invalidAt=function(){return g(this).overflow},Zn.isAfter=function(t,e){var n=b(t)?t:Nt(t);return!(!this.isValid()||!n.isValid())&&("millisecond"===(e=A(o(e)?"millisecond":e))?this.valueOf()>n.valueOf():n.valueOf()<this.clone().startOf(e).valueOf())},Zn.isBefore=function(t,e){var n=b(t)?t:Nt(t);return!(!this.isValid()||!n.isValid())&&("millisecond"===(e=A(o(e)?"millisecond":e))?this.valueOf()<n.valueOf():this.clone().endOf(e).valueOf()<n.valueOf())},Zn.isBetween=function(t,e,n,i){return("("===(i=i||"()")[0]?this.isAfter(t,n):!this.isBefore(t,n))&&(")"===i[1]?this.isBefore(e,n):!this.isAfter(e,n))},Zn.isSame=function(t,e){var n,i=b(t)?t:Nt(t);return!(!this.isValid()||!i.isValid())&&("millisecond"===(e=A(e||"millisecond"))?this.valueOf()===i.valueOf():(n=i.valueOf(),this.clone().startOf(e).valueOf()<=n&&n<=this.clone().endOf(e).valueOf()))},Zn.isSameOrAfter=function(t,e){return this.isSame(t,e)||this.isAfter(t,e)},Zn.isSameOrBefore=function(t,e){return this.isSame(t,e)||this.isBefore(t,e)},Zn.isValid=function(){return m(this)},Zn.lang=Hn,Zn.locale=ne,Zn.localeData=ie,Zn.max=Ln,Zn.min=Rn,Zn.parsingFlags=function(){return c({},g(this))},Zn.set=function(t,e){if("object"==typeof t)for(var n=F(t=I(t)),i=0;i<n.length;i++)this[n[i].unit](t[n[i].unit]);else if(t=A(t),D(this[t]))return this[t](e);return this},Zn.startOf=function(t){switch(t=A(t)){case"year":this.month(0);case"quarter":case"month":this.date(1);case"week":case"isoWeek":case"day":case"date":this.hours(0);case"hour":this.minutes(0);case"minute":this.seconds(0);case"second":this.milliseconds(0)}return"week"===t&&this.weekday(0),"isoWeek"===t&&this.isoWeekday(1),"quarter"===t&&this.month(3*Math.floor(this.month()/3)),this},Zn.subtract=Vn,Zn.toArray=function(){var t=this;return[t.year(),t.month(),t.date(),t.hour(),t.minute(),t.second(),t.millisecond()]},Zn.toObject=function(){var t=this;return{years:t.year(),months:t.month(),date:t.date(),hours:t.hours(),minutes:t.minutes(),seconds:t.seconds(),milliseconds:t.milliseconds()}},Zn.toDate=function(){return new Date(this.valueOf())},Zn.toISOString=function(){if(!this.isValid())return null;var t=this.clone().utc();return t.year()<0||t.year()>9999?V(t,"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]"):D(Date.prototype.toISOString)?this.toDate().toISOString():V(t,"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]")},Zn.inspect=function(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var t="moment",e="";this.isLocal()||(t=0===this.utcOffset()?"moment.utc":"moment.parseZone",e="Z");var n="["+t+'("]',i=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",a=e+'[")]';return this.format(n+i+"-MM-DD[T]HH:mm:ss.SSS"+a)},Zn.toJSON=function(){return this.isValid()?this.toISOString():null},Zn.toString=function(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")},Zn.unix=function(){return Math.floor(this.valueOf()/1e3)},Zn.valueOf=function(){return this._d.valueOf()-6e4*(this._offset||0)},Zn.creationData=function(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}},Zn.year=mn,Zn.isLeapYear=function(){return nt(this.year())},Zn.weekYear=function(t){return re.call(this,t,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)},Zn.isoWeekYear=function(t){return re.call(this,t,this.isoWeek(),this.isoWeekday(),1,4)},Zn.quarter=Zn.quarters=function(t){return null==t?Math.ceil((this.month()+1)/3):this.month(3*(t-1)+this.month()%3)},Zn.month=$,Zn.daysInMonth=function(){return J(this.year(),this.month())},Zn.week=Zn.weeks=function(t){var e=this.localeData().week(this);return null==t?e:this.add(7*(t-e),"d")},Zn.isoWeek=Zn.isoWeeks=function(t){var e=st(this,1,4).week;return null==t?e:this.add(7*(t-e),"d")},Zn.weeksInYear=function(){var t=this.localeData()._week;return lt(this.year(),t.dow,t.doy)},Zn.isoWeeksInYear=function(){return lt(this.year(),1,4)},Zn.date=En,Zn.day=Zn.days=function(t){if(!this.isValid())return null!=t?this:NaN;var e=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=t?(t=ut(t,this.localeData()),this.add(t-e,"d")):e},Zn.weekday=function(t){if(!this.isValid())return null!=t?this:NaN;var e=(this.day()+7-this.localeData()._week.dow)%7;return null==t?e:this.add(t-e,"d")},Zn.isoWeekday=function(t){if(!this.isValid())return null!=t?this:NaN;if(null!=t){var e=dt(t,this.localeData());return this.day(this.day()%7?e:e-7)}return this.day()||7},Zn.dayOfYear=function(t){var e=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==t?e:this.add(t-e,"d")},Zn.hour=Zn.hours=wn,Zn.minute=Zn.minutes=jn,Zn.second=Zn.seconds=Un,Zn.millisecond=Zn.milliseconds=Gn,Zn.utcOffset=function(t,e,i){var a,r=this._offset||0;if(!this.isValid())return null!=t?this:NaN;if(null!=t){if("string"==typeof t){if(null===(t=Ut(Xe,t)))return this}else Math.abs(t)<16&&!i&&(t*=60);return!this._isUTC&&e&&(a=Gt(this)),this._offset=t,this._isUTC=!0,null!=a&&this.add(a,"m"),r!==t&&(!e||this._changeInProgress?te(this,Xt(t-r,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,n.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?r:Gt(this)},Zn.utc=function(t){return this.utcOffset(0,t)},Zn.local=function(t){return this._isUTC&&(this.utcOffset(0,t),this._isUTC=!1,t&&this.subtract(Gt(this),"m")),this},Zn.parseZone=function(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var t=Ut(Ze,this._i);null!=t?this.utcOffset(t):this.utcOffset(0,!0)}return this},Zn.hasAlignedHourOffset=function(t){return!!this.isValid()&&(t=t?Nt(t).utcOffset():0,(this.utcOffset()-t)%60==0)},Zn.isDST=function(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()},Zn.isLocal=function(){return!!this.isValid()&&!this._isUTC},Zn.isUtcOffset=function(){return!!this.isValid()&&this._isUTC},Zn.isUtc=Zt,Zn.isUTC=Zt,Zn.zoneAbbr=function(){return this._isUTC?"UTC":""},Zn.zoneName=function(){return this._isUTC?"Coordinated Universal Time":""},Zn.dates=M("dates accessor is deprecated. Use date instead.",En),Zn.months=M("months accessor is deprecated. Use month instead",$),Zn.years=M("years accessor is deprecated. Use year instead",mn),Zn.zone=M("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",function(t,e){return null!=t?("string"!=typeof t&&(t=-t),this.utcOffset(t,e),this):-this.utcOffset()}),Zn.isDSTShifted=M("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",function(){if(!o(this._isDSTShifted))return this._isDSTShifted;var t={};if(v(t,this),(t=Lt(t))._a){var e=t._isUTC?h(t._a):Nt(t._a);this._isDSTShifted=this.isValid()&&k(t._a,e.toArray())>0}else this._isDSTShifted=!1;return this._isDSTShifted});var Xn=P.prototype;Xn.calendar=function(t,e,n){var i=this._calendar[t]||this._calendar.sameElse;return D(i)?i.call(e,n):i},Xn.longDateFormat=function(t){var e=this._longDateFormat[t],n=this._longDateFormat[t.toUpperCase()];return e||!n?e:(this._longDateFormat[t]=n.replace(/MMMM|MM|DD|dddd/g,function(t){return t.slice(1)}),this._longDateFormat[t])},Xn.invalidDate=function(){return this._invalidDate},Xn.ordinal=function(t){return this._ordinal.replace("%d",t)},Xn.preparse=se,Xn.postformat=se,Xn.relativeTime=function(t,e,n,i){var a=this._relativeTime[n];return D(a)?a(t,e,n,i):a.replace(/%d/i,t)},Xn.pastFuture=function(t,e){var n=this._relativeTime[t>0?"future":"past"];return D(n)?n(e):n.replace(/%s/i,e)},Xn.set=function(t){var e,n;for(n in t)D(e=t[n])?this[n]=e:this["_"+n]=e;this._config=t,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)},Xn.months=function(t,e){return t?i(this._months)?this._months[t.month()]:this._months[(this._months.isFormat||dn).test(e)?"format":"standalone"][t.month()]:i(this._months)?this._months:this._months.standalone},Xn.monthsShort=function(t,e){return t?i(this._monthsShort)?this._monthsShort[t.month()]:this._monthsShort[dn.test(e)?"format":"standalone"][t.month()]:i(this._monthsShort)?this._monthsShort:this._monthsShort.standalone},Xn.monthsParse=function(t,e,n){var i,a,r;if(this._monthsParseExact)return K.call(this,t,e,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),i=0;i<12;i++){if(a=h([2e3,i]),n&&!this._longMonthsParse[i]&&(this._longMonthsParse[i]=new RegExp("^"+this.months(a,"").replace(".","")+"$","i"),this._shortMonthsParse[i]=new RegExp("^"+this.monthsShort(a,"").replace(".","")+"$","i")),n||this._monthsParse[i]||(r="^"+this.months(a,"")+"|^"+this.monthsShort(a,""),this._monthsParse[i]=new RegExp(r.replace(".",""),"i")),n&&"MMMM"===e&&this._longMonthsParse[i].test(t))return i;if(n&&"MMM"===e&&this._shortMonthsParse[i].test(t))return i;if(!n&&this._monthsParse[i].test(t))return i}},Xn.monthsRegex=function(t){return this._monthsParseExact?(d(this,"_monthsRegex")||tt.call(this),t?this._monthsStrictRegex:this._monthsRegex):(d(this,"_monthsRegex")||(this._monthsRegex=gn),this._monthsStrictRegex&&t?this._monthsStrictRegex:this._monthsRegex)},Xn.monthsShortRegex=function(t){return this._monthsParseExact?(d(this,"_monthsRegex")||tt.call(this),t?this._monthsShortStrictRegex:this._monthsShortRegex):(d(this,"_monthsShortRegex")||(this._monthsShortRegex=fn),this._monthsShortStrictRegex&&t?this._monthsShortStrictRegex:this._monthsShortRegex)},Xn.week=function(t){return st(t,this._week.dow,this._week.doy).week},Xn.firstDayOfYear=function(){return this._week.doy},Xn.firstDayOfWeek=function(){return this._week.dow},Xn.weekdays=function(t,e){return t?i(this._weekdays)?this._weekdays[t.day()]:this._weekdays[this._weekdays.isFormat.test(e)?"format":"standalone"][t.day()]:i(this._weekdays)?this._weekdays:this._weekdays.standalone},Xn.weekdaysMin=function(t){return t?this._weekdaysMin[t.day()]:this._weekdaysMin},Xn.weekdaysShort=function(t){return t?this._weekdaysShort[t.day()]:this._weekdaysShort},Xn.weekdaysParse=function(t,e,n){var i,a,r;if(this._weekdaysParseExact)return ct.call(this,t,e,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),i=0;i<7;i++){if(a=h([2e3,1]).day(i),n&&!this._fullWeekdaysParse[i]&&(this._fullWeekdaysParse[i]=new RegExp("^"+this.weekdays(a,"").replace(".",".?")+"$","i"),this._shortWeekdaysParse[i]=new RegExp("^"+this.weekdaysShort(a,"").replace(".",".?")+"$","i"),this._minWeekdaysParse[i]=new RegExp("^"+this.weekdaysMin(a,"").replace(".",".?")+"$","i")),this._weekdaysParse[i]||(r="^"+this.weekdays(a,"")+"|^"+this.weekdaysShort(a,"")+"|^"+this.weekdaysMin(a,""),this._weekdaysParse[i]=new RegExp(r.replace(".",""),"i")),n&&"dddd"===e&&this._fullWeekdaysParse[i].test(t))return i;if(n&&"ddd"===e&&this._shortWeekdaysParse[i].test(t))return i;if(n&&"dd"===e&&this._minWeekdaysParse[i].test(t))return i;if(!n&&this._weekdaysParse[i].test(t))return i}},Xn.weekdaysRegex=function(t){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||ht.call(this),t?this._weekdaysStrictRegex:this._weekdaysRegex):(d(this,"_weekdaysRegex")||(this._weekdaysRegex=bn),this._weekdaysStrictRegex&&t?this._weekdaysStrictRegex:this._weekdaysRegex)},Xn.weekdaysShortRegex=function(t){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||ht.call(this),t?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(d(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=xn),this._weekdaysShortStrictRegex&&t?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)},Xn.weekdaysMinRegex=function(t){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||ht.call(this),t?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(d(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=_n),this._weekdaysMinStrictRegex&&t?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)},Xn.isPM=function(t){return"p"===(t+"").toLowerCase().charAt(0)},Xn.meridiem=function(t,e,n){return t>11?n?"pm":"PM":n?"am":"AM"},bt("en",{dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(t){var e=t%10;return t+(1===_(t%100/10)?"th":1===e?"st":2===e?"nd":3===e?"rd":"th")}}),n.lang=M("moment.lang is deprecated. Use moment.locale instead.",bt),n.langData=M("moment.langData is deprecated. Use moment.localeData instead.",_t);var Jn=Math.abs,Kn=me("ms"),Qn=me("s"),$n=me("m"),ti=me("h"),ei=me("d"),ni=me("w"),ii=me("M"),ai=me("y"),ri=pe("milliseconds"),oi=pe("seconds"),si=pe("minutes"),li=pe("hours"),ui=pe("days"),di=pe("months"),ci=pe("years"),hi=Math.round,fi={ss:44,s:45,m:45,h:22,d:26,M:11},gi=Math.abs,mi=Vt.prototype;return mi.isValid=function(){return this._isValid},mi.abs=function(){var t=this._data;return this._milliseconds=Jn(this._milliseconds),this._days=Jn(this._days),this._months=Jn(this._months),t.milliseconds=Jn(t.milliseconds),t.seconds=Jn(t.seconds),t.minutes=Jn(t.minutes),t.hours=Jn(t.hours),t.months=Jn(t.months),t.years=Jn(t.years),this},mi.add=function(t,e){return ce(this,t,e,1)},mi.subtract=function(t,e){return ce(this,t,e,-1)},mi.as=function(t){if(!this.isValid())return NaN;var e,n,i=this._milliseconds;if("month"===(t=A(t))||"year"===t)return e=this._days+i/864e5,n=this._months+fe(e),"month"===t?n:n/12;switch(e=this._days+Math.round(ge(this._months)),t){case"week":return e/7+i/6048e5;case"day":return e+i/864e5;case"hour":return 24*e+i/36e5;case"minute":return 1440*e+i/6e4;case"second":return 86400*e+i/1e3;case"millisecond":return Math.floor(864e5*e)+i;default:throw new Error("Unknown unit "+t)}},mi.asMilliseconds=Kn,mi.asSeconds=Qn,mi.asMinutes=$n,mi.asHours=ti,mi.asDays=ei,mi.asWeeks=ni,mi.asMonths=ii,mi.asYears=ai,mi.valueOf=function(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*_(this._months/12):NaN},mi._bubble=function(){var t,e,n,i,a,r=this._milliseconds,o=this._days,s=this._months,l=this._data;return r>=0&&o>=0&&s>=0||r<=0&&o<=0&&s<=0||(r+=864e5*he(ge(s)+o),o=0,s=0),l.milliseconds=r%1e3,t=x(r/1e3),l.seconds=t%60,e=x(t/60),l.minutes=e%60,n=x(e/60),l.hours=n%24,o+=x(n/24),a=x(fe(o)),s+=a,o-=he(ge(a)),i=x(s/12),s%=12,l.days=o,l.months=s,l.years=i,this},mi.get=function(t){return t=A(t),this.isValid()?this[t+"s"]():NaN},mi.milliseconds=ri,mi.seconds=oi,mi.minutes=si,mi.hours=li,mi.days=ui,mi.weeks=function(){return x(this.days()/7)},mi.months=di,mi.years=ci,mi.humanize=function(t){if(!this.isValid())return this.localeData().invalidDate();var e=this.localeData(),n=ye(this,!t,e);return t&&(n=e.pastFuture(+this,n)),e.postformat(n)},mi.toISOString=be,mi.toString=be,mi.toJSON=be,mi.locale=ne,mi.localeData=ie,mi.toIsoString=M("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",be),mi.lang=Hn,N("X",0,0,"unix"),N("x",0,0,"valueOf"),E("x",Ge),E("X",/[+-]?\d+(\.\d{1,3})?/),G("X",function(t,e,n){n._d=new Date(1e3*parseFloat(t,10))}),G("x",function(t,e,n){n._d=new Date(_(t))}),n.version="2.18.1",function(t){xe=t}(Nt),n.fn=Zn,n.min=function(){return zt("isBefore",[].slice.call(arguments,0))},n.max=function(){return zt("isAfter",[].slice.call(arguments,0))},n.now=function(){return Date.now?Date.now():+new Date},n.utc=h,n.unix=function(t){return Nt(1e3*t)},n.months=function(t,e){return ue(t,e,"months")},n.isDate=l,n.locale=bt,n.invalid=p,n.duration=Xt,n.isMoment=b,n.weekdays=function(t,e,n){return de(t,e,n,"weekdays")},n.parseZone=function(){return Nt.apply(null,arguments).parseZone()},n.localeData=_t,n.isDuration=Ht,n.monthsShort=function(t,e){return ue(t,e,"monthsShort")},n.weekdaysMin=function(t,e,n){return de(t,e,n,"weekdaysMin")},n.defineLocale=xt,n.updateLocale=function(t,e){if(null!=e){var n,i=Mn;null!=Sn[t]&&(i=Sn[t]._config),(n=new P(e=C(i,e))).parentLocale=Sn[t],Sn[t]=n,bt(t)}else null!=Sn[t]&&(null!=Sn[t].parentLocale?Sn[t]=Sn[t].parentLocale:null!=Sn[t]&&delete Sn[t]);return Sn[t]},n.locales=function(){return Pe(Sn)},n.weekdaysShort=function(t,e,n){return de(t,e,n,"weekdaysShort")},n.normalizeUnits=A,n.relativeTimeRounding=function(t){return void 0===t?hi:"function"==typeof t&&(hi=t,!0)},n.relativeTimeThreshold=function(t,e){return void 0!==fi[t]&&(void 0===e?fi[t]:(fi[t]=e,"s"===t&&(fi.ss=e-1),!0))},n.calendarFormat=function(t,e){var n=t.diff(e,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"},n.prototype=Zn,n})},{}],7:[function(t,e,n){var i=t(29)();i.helpers=t(45),t(27)(i),i.defaults=t(25),i.Element=t(26),i.elements=t(40),i.Interaction=t(28),i.platform=t(48),t(31)(i),t(22)(i),t(23)(i),t(24)(i),t(30)(i),t(33)(i),t(32)(i),t(35)(i),t(54)(i),t(52)(i),t(53)(i),t(55)(i),t(56)(i),t(57)(i),t(15)(i),t(16)(i),t(17)(i),t(18)(i),t(19)(i),t(20)(i),t(21)(i),t(8)(i),t(9)(i),t(10)(i),t(11)(i),t(12)(i),t(13)(i),t(14)(i);var a=[];a.push(t(49)(i),t(50)(i),t(51)(i)),i.plugins.register(a),i.platform.initialize(),e.exports=i,"undefined"!=typeof window&&(window.Chart=i),i.canvasHelpers=i.helpers.canvas},{10:10,11:11,12:12,13:13,14:14,15:15,16:16,17:17,18:18,19:19,20:20,21:21,22:22,23:23,24:24,25:25,26:26,27:27,28:28,29:29,30:30,31:31,32:32,33:33,35:35,40:40,45:45,48:48,49:49,50:50,51:51,52:52,53:53,54:54,55:55,56:56,57:57,8:8,9:9}],8:[function(t,e,n){"use strict";e.exports=function(t){t.Bar=function(e,n){return n.type="bar",new t(e,n)}}},{}],9:[function(t,e,n){"use strict";e.exports=function(t){t.Bubble=function(e,n){return n.type="bubble",new t(e,n)}}},{}],10:[function(t,e,n){"use strict";e.exports=function(t){t.Doughnut=function(e,n){return n.type="doughnut",new t(e,n)}}},{}],11:[function(t,e,n){"use strict";e.exports=function(t){t.Line=function(e,n){return n.type="line",new t(e,n)}}},{}],12:[function(t,e,n){"use strict";e.exports=function(t){t.PolarArea=function(e,n){return n.type="polarArea",new t(e,n)}}},{}],13:[function(t,e,n){"use strict";e.exports=function(t){t.Radar=function(e,n){return n.type="radar",new t(e,n)}}},{}],14:[function(t,e,n){"use strict";e.exports=function(t){t.Scatter=function(e,n){return n.type="scatter",new t(e,n)}}},{}],15:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("bar",{hover:{mode:"label"},scales:{xAxes:[{type:"category",categoryPercentage:.8,barPercentage:.9,offset:!0,gridLines:{offsetGridLines:!0}}],yAxes:[{type:"linear"}]}}),i._set("horizontalBar",{hover:{mode:"index",axis:"y"},scales:{xAxes:[{type:"linear",position:"bottom"}],yAxes:[{position:"left",type:"category",categoryPercentage:.8,barPercentage:.9,offset:!0,gridLines:{offsetGridLines:!0}}]},elements:{rectangle:{borderSkipped:"left"}},tooltips:{callbacks:{title:function(t,e){var n="";return t.length>0&&(t[0].yLabel?n=t[0].yLabel:e.labels.length>0&&t[0].index<e.labels.length&&(n=e.labels[t[0].index])),n},label:function(t,e){return(e.datasets[t.datasetIndex].label||"")+": "+t.xLabel}},mode:"index",axis:"y"}}),e.exports=function(t){t.controllers.bar=t.DatasetController.extend({dataElementType:a.Rectangle,initialize:function(){var e,n=this;t.DatasetController.prototype.initialize.apply(n,arguments),(e=n.getMeta()).stack=n.getDataset().stack,e.bar=!0},update:function(t){var e,n,i=this,a=i.getMeta().data;for(i._ruler=i.getRuler(),e=0,n=a.length;e<n;++e)i.updateElement(a[e],e,t)},updateElement:function(t,e,n){var i=this,a=i.chart,o=i.getMeta(),s=i.getDataset(),l=t.custom||{},u=a.options.elements.rectangle;t._xScale=i.getScaleForId(o.xAxisID),t._yScale=i.getScaleForId(o.yAxisID),t._datasetIndex=i.index,t._index=e,t._model={datasetLabel:s.label,label:a.data.labels[e],borderSkipped:l.borderSkipped?l.borderSkipped:u.borderSkipped,backgroundColor:l.backgroundColor?l.backgroundColor:r.valueAtIndexOrDefault(s.backgroundColor,e,u.backgroundColor),borderColor:l.borderColor?l.borderColor:r.valueAtIndexOrDefault(s.borderColor,e,u.borderColor),borderWidth:l.borderWidth?l.borderWidth:r.valueAtIndexOrDefault(s.borderWidth,e,u.borderWidth)},i.updateElementGeometry(t,e,n),t.pivot()},updateElementGeometry:function(t,e,n){var i=this,a=t._model,r=i.getValueScale(),o=r.getBasePixel(),s=r.isHorizontal(),l=i._ruler||i.getRuler(),u=i.calculateBarValuePixels(i.index,e),d=i.calculateBarIndexPixels(i.index,e,l);a.horizontal=s,a.base=n?o:u.base,a.x=s?n?o:u.head:d.center,a.y=s?d.center:n?o:u.head,a.height=s?d.size:void 0,a.width=s?void 0:d.size},getValueScaleId:function(){return this.getMeta().yAxisID},getIndexScaleId:function(){return this.getMeta().xAxisID},getValueScale:function(){return this.getScaleForId(this.getValueScaleId())},getIndexScale:function(){return this.getScaleForId(this.getIndexScaleId())},getStackCount:function(t){var e,n,i=this,a=i.chart,r=i.getIndexScale().options.stacked,o=void 0===t?a.data.datasets.length:t+1,s=[];for(e=0;e<o;++e)(n=a.getDatasetMeta(e)).bar&&a.isDatasetVisible(e)&&(!1===r||!0===r&&-1===s.indexOf(n.stack)||void 0===r&&(void 0===n.stack||-1===s.indexOf(n.stack)))&&s.push(n.stack);return s.length},getStackIndex:function(t){return this.getStackCount(t)-1},getRuler:function(){var t,e,n=this,i=n.getIndexScale(),a=n.getStackCount(),r=n.index,o=[],s=i.isHorizontal(),l=s?i.left:i.top,u=l+(s?i.width:i.height);for(t=0,e=n.getMeta().data.length;t<e;++t)o.push(i.getPixelForValue(null,t,r));return{pixels:o,start:l,end:u,stackCount:a,scale:i}},calculateBarValuePixels:function(t,e){var n,i,a,r,o,s,l=this,u=l.chart,d=l.getMeta(),c=l.getValueScale(),h=u.data.datasets,f=c.getRightValue(h[t].data[e]),g=c.options.stacked,m=d.stack,p=0;if(g||void 0===g&&void 0!==m)for(n=0;n<t;++n)(i=u.getDatasetMeta(n)).bar&&i.stack===m&&i.controller.getValueScaleId()===c.id&&u.isDatasetVisible(n)&&(a=c.getRightValue(h[n].data[e]),(f<0&&a<0||f>=0&&a>0)&&(p+=a));return r=c.getPixelForValue(p),o=c.getPixelForValue(p+f),s=(o-r)/2,{size:s,base:r,head:o,center:o+s/2}},calculateBarIndexPixels:function(t,e,n){var i,a,o,s,l,u,d=this,c=n.scale.options,h=d.getStackIndex(t),f=n.pixels,g=f[e],m=f.length,p=n.start,v=n.end;return 1===m?(i=g>p?g-p:v-g,a=g<v?v-g:g-p):(e>0&&(i=(g-f[e-1])/2,e===m-1&&(a=i)),e<m-1&&(a=(f[e+1]-g)/2,0===e&&(i=a))),o=i*c.categoryPercentage,s=a*c.categoryPercentage,l=(o+s)/n.stackCount,u=l*c.barPercentage,u=Math.min(r.valueOrDefault(c.barThickness,u),r.valueOrDefault(c.maxBarThickness,1/0)),g-=o,g+=l*h,g+=(l-u)/2,{size:u,base:g,head:g+u,center:g+u/2}},draw:function(){var t=this,e=t.chart,n=t.getValueScale(),i=t.getMeta().data,a=t.getDataset(),o=i.length,s=0;for(r.canvas.clipArea(e.ctx,e.chartArea);s<o;++s)isNaN(n.getRightValue(a.data[s]))||i[s].draw();r.canvas.unclipArea(e.ctx)},setHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t._index,i=t.custom||{},a=t._model;a.backgroundColor=i.hoverBackgroundColor?i.hoverBackgroundColor:r.valueAtIndexOrDefault(e.hoverBackgroundColor,n,r.getHoverColor(a.backgroundColor)),a.borderColor=i.hoverBorderColor?i.hoverBorderColor:r.valueAtIndexOrDefault(e.hoverBorderColor,n,r.getHoverColor(a.borderColor)),a.borderWidth=i.hoverBorderWidth?i.hoverBorderWidth:r.valueAtIndexOrDefault(e.hoverBorderWidth,n,a.borderWidth)},removeHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t._index,i=t.custom||{},a=t._model,o=this.chart.options.elements.rectangle;a.backgroundColor=i.backgroundColor?i.backgroundColor:r.valueAtIndexOrDefault(e.backgroundColor,n,o.backgroundColor),a.borderColor=i.borderColor?i.borderColor:r.valueAtIndexOrDefault(e.borderColor,n,o.borderColor),a.borderWidth=i.borderWidth?i.borderWidth:r.valueAtIndexOrDefault(e.borderWidth,n,o.borderWidth)}}),t.controllers.horizontalBar=t.controllers.bar.extend({getValueScaleId:function(){return this.getMeta().xAxisID},getIndexScaleId:function(){return this.getMeta().yAxisID}})}},{25:25,40:40,45:45}],16:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("bubble",{hover:{mode:"single"},scales:{xAxes:[{type:"linear",position:"bottom",id:"x-axis-0"}],yAxes:[{type:"linear",position:"left",id:"y-axis-0"}]},tooltips:{callbacks:{title:function(){return""},label:function(t,e){var n=e.datasets[t.datasetIndex].label||"",i=e.datasets[t.datasetIndex].data[t.index];return n+": ("+t.xLabel+", "+t.yLabel+", "+i.r+")"}}}}),e.exports=function(t){t.controllers.bubble=t.DatasetController.extend({dataElementType:a.Point,update:function(t){var e=this,n=e.getMeta().data;r.each(n,function(n,i){e.updateElement(n,i,t)})},updateElement:function(t,e,n){var i=this,a=i.getMeta(),r=t.custom||{},o=i.getScaleForId(a.xAxisID),s=i.getScaleForId(a.yAxisID),l=i._resolveElementOptions(t,e),u=i.getDataset().data[e],d=i.index,c=n?o.getPixelForDecimal(.5):o.getPixelForValue("object"==typeof u?u:NaN,e,d),h=n?s.getBasePixel():s.getPixelForValue(u,e,d);t._xScale=o,t._yScale=s,t._options=l,t._datasetIndex=d,t._index=e,t._model={backgroundColor:l.backgroundColor,borderColor:l.borderColor,borderWidth:l.borderWidth,hitRadius:l.hitRadius,pointStyle:l.pointStyle,radius:n?0:l.radius,skip:r.skip||isNaN(c)||isNaN(h),x:c,y:h},t.pivot()},setHoverStyle:function(t){var e=t._model,n=t._options;e.backgroundColor=r.valueOrDefault(n.hoverBackgroundColor,r.getHoverColor(n.backgroundColor)),e.borderColor=r.valueOrDefault(n.hoverBorderColor,r.getHoverColor(n.borderColor)),e.borderWidth=r.valueOrDefault(n.hoverBorderWidth,n.borderWidth),e.radius=n.radius+n.hoverRadius},removeHoverStyle:function(t){var e=t._model,n=t._options;e.backgroundColor=n.backgroundColor,e.borderColor=n.borderColor,e.borderWidth=n.borderWidth,e.radius=n.radius},_resolveElementOptions:function(t,e){var n,i,a,o=this,s=o.chart,l=s.data.datasets[o.index],u=t.custom||{},d=s.options.elements.point,c=r.options.resolve,h=l.data[e],f={},g={chart:s,dataIndex:e,dataset:l,datasetIndex:o.index},m=["backgroundColor","borderColor","borderWidth","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth","hoverRadius","hitRadius","pointStyle"];for(n=0,i=m.length;n<i;++n)f[a=m[n]]=c([u[a],l[a],d[a]],g,e);return f.radius=c([u.radius,h?h.r:void 0,l.radius,d.radius],g,e),f}})}},{25:25,40:40,45:45}],17:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("doughnut",{animation:{animateRotate:!0,animateScale:!1},hover:{mode:"single"},legendCallback:function(t){var e=[];e.push('<ul class="'+t.id+'-legend">');var n=t.data,i=n.datasets,a=n.labels;if(i.length)for(var r=0;r<i[0].data.length;++r)e.push('<li><span style="background-color:'+i[0].backgroundColor[r]+'"></span>'),a[r]&&e.push(a[r]),e.push("</li>");return e.push("</ul>"),e.join("")},legend:{labels:{generateLabels:function(t){var e=t.data;return e.labels.length&&e.datasets.length?e.labels.map(function(n,i){var a=t.getDatasetMeta(0),o=e.datasets[0],s=a.data[i],l=s&&s.custom||{},u=r.valueAtIndexOrDefault,d=t.options.elements.arc;return{text:n,fillStyle:l.backgroundColor?l.backgroundColor:u(o.backgroundColor,i,d.backgroundColor),strokeStyle:l.borderColor?l.borderColor:u(o.borderColor,i,d.borderColor),lineWidth:l.borderWidth?l.borderWidth:u(o.borderWidth,i,d.borderWidth),hidden:isNaN(o.data[i])||a.data[i].hidden,index:i}}):[]}},onClick:function(t,e){var n,i,a,r=e.index,o=this.chart;for(n=0,i=(o.data.datasets||[]).length;n<i;++n)(a=o.getDatasetMeta(n)).data[r]&&(a.data[r].hidden=!a.data[r].hidden);o.update()}},cutoutPercentage:50,rotation:-.5*Math.PI,circumference:2*Math.PI,tooltips:{callbacks:{title:function(){return""},label:function(t,e){var n=e.labels[t.index],i=": "+e.datasets[t.datasetIndex].data[t.index];return r.isArray(n)?(n=n.slice())[0]+=i:n+=i,n}}}}),i._set("pie",r.clone(i.doughnut)),i._set("pie",{cutoutPercentage:0}),e.exports=function(t){t.controllers.doughnut=t.controllers.pie=t.DatasetController.extend({dataElementType:a.Arc,linkScales:r.noop,getRingIndex:function(t){for(var e=0,n=0;n<t;++n)this.chart.isDatasetVisible(n)&&++e;return e},update:function(t){var e=this,n=e.chart,i=n.chartArea,a=n.options,o=a.elements.arc,s=i.right-i.left-o.borderWidth,l=i.bottom-i.top-o.borderWidth,u=Math.min(s,l),d={x:0,y:0},c=e.getMeta(),h=a.cutoutPercentage,f=a.circumference;if(f<2*Math.PI){var g=a.rotation%(2*Math.PI),m=(g+=2*Math.PI*(g>=Math.PI?-1:g<-Math.PI?1:0))+f,p={x:Math.cos(g),y:Math.sin(g)},v={x:Math.cos(m),y:Math.sin(m)},y=g<=0&&m>=0||g<=2*Math.PI&&2*Math.PI<=m,b=g<=.5*Math.PI&&.5*Math.PI<=m||g<=2.5*Math.PI&&2.5*Math.PI<=m,x=g<=-Math.PI&&-Math.PI<=m||g<=Math.PI&&Math.PI<=m,_=g<=.5*-Math.PI&&.5*-Math.PI<=m||g<=1.5*Math.PI&&1.5*Math.PI<=m,k=h/100,w={x:x?-1:Math.min(p.x*(p.x<0?1:k),v.x*(v.x<0?1:k)),y:_?-1:Math.min(p.y*(p.y<0?1:k),v.y*(v.y<0?1:k))},M={x:y?1:Math.max(p.x*(p.x>0?1:k),v.x*(v.x>0?1:k)),y:b?1:Math.max(p.y*(p.y>0?1:k),v.y*(v.y>0?1:k))},S={width:.5*(M.x-w.x),height:.5*(M.y-w.y)};u=Math.min(s/S.width,l/S.height),d={x:-.5*(M.x+w.x),y:-.5*(M.y+w.y)}}n.borderWidth=e.getMaxBorderWidth(c.data),n.outerRadius=Math.max((u-n.borderWidth)/2,0),n.innerRadius=Math.max(h?n.outerRadius/100*h:0,0),n.radiusLength=(n.outerRadius-n.innerRadius)/n.getVisibleDatasetCount(),n.offsetX=d.x*n.outerRadius,n.offsetY=d.y*n.outerRadius,c.total=e.calculateTotal(),e.outerRadius=n.outerRadius-n.radiusLength*e.getRingIndex(e.index),e.innerRadius=Math.max(e.outerRadius-n.radiusLength,0),r.each(c.data,function(n,i){e.updateElement(n,i,t)})},updateElement:function(t,e,n){var i=this,a=i.chart,o=a.chartArea,s=a.options,l=s.animation,u=(o.left+o.right)/2,d=(o.top+o.bottom)/2,c=s.rotation,h=s.rotation,f=i.getDataset(),g=n&&l.animateRotate?0:t.hidden?0:i.calculateCircumference(f.data[e])*(s.circumference/(2*Math.PI)),m=n&&l.animateScale?0:i.innerRadius,p=n&&l.animateScale?0:i.outerRadius,v=r.valueAtIndexOrDefault;r.extend(t,{_datasetIndex:i.index,_index:e,_model:{x:u+a.offsetX,y:d+a.offsetY,startAngle:c,endAngle:h,circumference:g,outerRadius:p,innerRadius:m,label:v(f.label,e,a.data.labels[e])}});var y=t._model;this.removeHoverStyle(t),n&&l.animateRotate||(y.startAngle=0===e?s.rotation:i.getMeta().data[e-1]._model.endAngle,y.endAngle=y.startAngle+y.circumference),t.pivot()},removeHoverStyle:function(e){t.DatasetController.prototype.removeHoverStyle.call(this,e,this.chart.options.elements.arc)},calculateTotal:function(){var t,e=this.getDataset(),n=this.getMeta(),i=0;return r.each(n.data,function(n,a){t=e.data[a],isNaN(t)||n.hidden||(i+=Math.abs(t))}),i},calculateCircumference:function(t){var e=this.getMeta().total;return e>0&&!isNaN(t)?2*Math.PI*(t/e):0},getMaxBorderWidth:function(t){for(var e,n,i=0,a=this.index,r=t.length,o=0;o<r;o++)e=t[o]._model?t[o]._model.borderWidth:0,i=(n=t[o]._chart?t[o]._chart.config.data.datasets[a].hoverBorderWidth:0)>(i=e>i?e:i)?n:i;return i}})}},{25:25,40:40,45:45}],18:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("line",{showLines:!0,spanGaps:!1,hover:{mode:"label"},scales:{xAxes:[{type:"category",id:"x-axis-0"}],yAxes:[{type:"linear",id:"y-axis-0"}]}}),e.exports=function(t){function e(t,e){return r.valueOrDefault(t.showLine,e.showLines)}t.controllers.line=t.DatasetController.extend({datasetElementType:a.Line,dataElementType:a.Point,update:function(t){var n,i,a,o=this,s=o.getMeta(),l=s.dataset,u=s.data||[],d=o.chart.options,c=d.elements.line,h=o.getScaleForId(s.yAxisID),f=o.getDataset(),g=e(f,d);for(g&&(a=l.custom||{},void 0!==f.tension&&void 0===f.lineTension&&(f.lineTension=f.tension),l._scale=h,l._datasetIndex=o.index,l._children=u,l._model={spanGaps:f.spanGaps?f.spanGaps:d.spanGaps,tension:a.tension?a.tension:r.valueOrDefault(f.lineTension,c.tension),backgroundColor:a.backgroundColor?a.backgroundColor:f.backgroundColor||c.backgroundColor,borderWidth:a.borderWidth?a.borderWidth:f.borderWidth||c.borderWidth,borderColor:a.borderColor?a.borderColor:f.borderColor||c.borderColor,borderCapStyle:a.borderCapStyle?a.borderCapStyle:f.borderCapStyle||c.borderCapStyle,borderDash:a.borderDash?a.borderDash:f.borderDash||c.borderDash,borderDashOffset:a.borderDashOffset?a.borderDashOffset:f.borderDashOffset||c.borderDashOffset,borderJoinStyle:a.borderJoinStyle?a.borderJoinStyle:f.borderJoinStyle||c.borderJoinStyle,fill:a.fill?a.fill:void 0!==f.fill?f.fill:c.fill,steppedLine:a.steppedLine?a.steppedLine:r.valueOrDefault(f.steppedLine,c.stepped),cubicInterpolationMode:a.cubicInterpolationMode?a.cubicInterpolationMode:r.valueOrDefault(f.cubicInterpolationMode,c.cubicInterpolationMode)},l.pivot()),n=0,i=u.length;n<i;++n)o.updateElement(u[n],n,t);for(g&&0!==l._model.tension&&o.updateBezierControlPoints(),n=0,i=u.length;n<i;++n)u[n].pivot()},getPointBackgroundColor:function(t,e){var n=this.chart.options.elements.point.backgroundColor,i=this.getDataset(),a=t.custom||{};return a.backgroundColor?n=a.backgroundColor:i.pointBackgroundColor?n=r.valueAtIndexOrDefault(i.pointBackgroundColor,e,n):i.backgroundColor&&(n=i.backgroundColor),n},getPointBorderColor:function(t,e){var n=this.chart.options.elements.point.borderColor,i=this.getDataset(),a=t.custom||{};return a.borderColor?n=a.borderColor:i.pointBorderColor?n=r.valueAtIndexOrDefault(i.pointBorderColor,e,n):i.borderColor&&(n=i.borderColor),n},getPointBorderWidth:function(t,e){var n=this.chart.options.elements.point.borderWidth,i=this.getDataset(),a=t.custom||{};return isNaN(a.borderWidth)?!isNaN(i.pointBorderWidth)||r.isArray(i.pointBorderWidth)?n=r.valueAtIndexOrDefault(i.pointBorderWidth,e,n):isNaN(i.borderWidth)||(n=i.borderWidth):n=a.borderWidth,n},updateElement:function(t,e,n){var i,a,o=this,s=o.getMeta(),l=t.custom||{},u=o.getDataset(),d=o.index,c=u.data[e],h=o.getScaleForId(s.yAxisID),f=o.getScaleForId(s.xAxisID),g=o.chart.options.elements.point;void 0!==u.radius&&void 0===u.pointRadius&&(u.pointRadius=u.radius),void 0!==u.hitRadius&&void 0===u.pointHitRadius&&(u.pointHitRadius=u.hitRadius),i=f.getPixelForValue("object"==typeof c?c:NaN,e,d),a=n?h.getBasePixel():o.calculatePointY(c,e,d),t._xScale=f,t._yScale=h,t._datasetIndex=d,t._index=e,t._model={x:i,y:a,skip:l.skip||isNaN(i)||isNaN(a),radius:l.radius||r.valueAtIndexOrDefault(u.pointRadius,e,g.radius),pointStyle:l.pointStyle||r.valueAtIndexOrDefault(u.pointStyle,e,g.pointStyle),backgroundColor:o.getPointBackgroundColor(t,e),borderColor:o.getPointBorderColor(t,e),borderWidth:o.getPointBorderWidth(t,e),tension:s.dataset._model?s.dataset._model.tension:0,steppedLine:!!s.dataset._model&&s.dataset._model.steppedLine,hitRadius:l.hitRadius||r.valueAtIndexOrDefault(u.pointHitRadius,e,g.hitRadius)}},calculatePointY:function(t,e,n){var i,a,r,o=this,s=o.chart,l=o.getMeta(),u=o.getScaleForId(l.yAxisID),d=0,c=0;if(u.options.stacked){for(i=0;i<n;i++)if(a=s.data.datasets[i],"line"===(r=s.getDatasetMeta(i)).type&&r.yAxisID===u.id&&s.isDatasetVisible(i)){var h=Number(u.getRightValue(a.data[e]));h<0?c+=h||0:d+=h||0}var f=Number(u.getRightValue(t));return f<0?u.getPixelForValue(c+f):u.getPixelForValue(d+f)}return u.getPixelForValue(t)},updateBezierControlPoints:function(){function t(t,e,n){return Math.max(Math.min(t,n),e)}var e,n,i,a,o=this,s=o.getMeta(),l=o.chart.chartArea,u=s.data||[];if(s.dataset._model.spanGaps&&(u=u.filter(function(t){return!t._model.skip})),"monotone"===s.dataset._model.cubicInterpolationMode)r.splineCurveMonotone(u);else for(e=0,n=u.length;e<n;++e)i=u[e]._model,a=r.splineCurve(r.previousItem(u,e)._model,i,r.nextItem(u,e)._model,s.dataset._model.tension),i.controlPointPreviousX=a.previous.x,i.controlPointPreviousY=a.previous.y,i.controlPointNextX=a.next.x,i.controlPointNextY=a.next.y;if(o.chart.options.elements.line.capBezierPoints)for(e=0,n=u.length;e<n;++e)(i=u[e]._model).controlPointPreviousX=t(i.controlPointPreviousX,l.left,l.right),i.controlPointPreviousY=t(i.controlPointPreviousY,l.top,l.bottom),i.controlPointNextX=t(i.controlPointNextX,l.left,l.right),i.controlPointNextY=t(i.controlPointNextY,l.top,l.bottom)},draw:function(){var t=this,n=t.chart,i=t.getMeta(),a=i.data||[],o=n.chartArea,s=a.length,l=0;for(r.canvas.clipArea(n.ctx,o),e(t.getDataset(),n.options)&&i.dataset.draw(),r.canvas.unclipArea(n.ctx);l<s;++l)a[l].draw(o)},setHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t._index,i=t.custom||{},a=t._model;a.radius=i.hoverRadius||r.valueAtIndexOrDefault(e.pointHoverRadius,n,this.chart.options.elements.point.hoverRadius),a.backgroundColor=i.hoverBackgroundColor||r.valueAtIndexOrDefault(e.pointHoverBackgroundColor,n,r.getHoverColor(a.backgroundColor)),a.borderColor=i.hoverBorderColor||r.valueAtIndexOrDefault(e.pointHoverBorderColor,n,r.getHoverColor(a.borderColor)),a.borderWidth=i.hoverBorderWidth||r.valueAtIndexOrDefault(e.pointHoverBorderWidth,n,a.borderWidth)},removeHoverStyle:function(t){var e=this,n=e.chart.data.datasets[t._datasetIndex],i=t._index,a=t.custom||{},o=t._model;void 0!==n.radius&&void 0===n.pointRadius&&(n.pointRadius=n.radius),o.radius=a.radius||r.valueAtIndexOrDefault(n.pointRadius,i,e.chart.options.elements.point.radius),o.backgroundColor=e.getPointBackgroundColor(t,i),o.borderColor=e.getPointBorderColor(t,i),o.borderWidth=e.getPointBorderWidth(t,i)}})}},{25:25,40:40,45:45}],19:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("polarArea",{scale:{type:"radialLinear",angleLines:{display:!1},gridLines:{circular:!0},pointLabels:{display:!1},ticks:{beginAtZero:!0}},animation:{animateRotate:!0,animateScale:!0},startAngle:-.5*Math.PI,legendCallback:function(t){var e=[];e.push('<ul class="'+t.id+'-legend">');var n=t.data,i=n.datasets,a=n.labels;if(i.length)for(var r=0;r<i[0].data.length;++r)e.push('<li><span style="background-color:'+i[0].backgroundColor[r]+'"></span>'),a[r]&&e.push(a[r]),e.push("</li>");return e.push("</ul>"),e.join("")},legend:{labels:{generateLabels:function(t){var e=t.data;return e.labels.length&&e.datasets.length?e.labels.map(function(n,i){var a=t.getDatasetMeta(0),o=e.datasets[0],s=a.data[i].custom||{},l=r.valueAtIndexOrDefault,u=t.options.elements.arc;return{text:n,fillStyle:s.backgroundColor?s.backgroundColor:l(o.backgroundColor,i,u.backgroundColor),strokeStyle:s.borderColor?s.borderColor:l(o.borderColor,i,u.borderColor),lineWidth:s.borderWidth?s.borderWidth:l(o.borderWidth,i,u.borderWidth),hidden:isNaN(o.data[i])||a.data[i].hidden,index:i}}):[]}},onClick:function(t,e){var n,i,a,r=e.index,o=this.chart;for(n=0,i=(o.data.datasets||[]).length;n<i;++n)(a=o.getDatasetMeta(n)).data[r].hidden=!a.data[r].hidden;o.update()}},tooltips:{callbacks:{title:function(){return""},label:function(t,e){return e.labels[t.index]+": "+t.yLabel}}}}),e.exports=function(t){t.controllers.polarArea=t.DatasetController.extend({dataElementType:a.Arc,linkScales:r.noop,update:function(t){var e=this,n=e.chart,i=n.chartArea,a=e.getMeta(),o=n.options,s=o.elements.arc,l=Math.min(i.right-i.left,i.bottom-i.top);n.outerRadius=Math.max((l-s.borderWidth/2)/2,0),n.innerRadius=Math.max(o.cutoutPercentage?n.outerRadius/100*o.cutoutPercentage:1,0),n.radiusLength=(n.outerRadius-n.innerRadius)/n.getVisibleDatasetCount(),e.outerRadius=n.outerRadius-n.radiusLength*e.index,e.innerRadius=e.outerRadius-n.radiusLength,a.count=e.countVisibleElements(),r.each(a.data,function(n,i){e.updateElement(n,i,t)})},updateElement:function(t,e,n){for(var i=this,a=i.chart,o=i.getDataset(),s=a.options,l=s.animation,u=a.scale,d=a.data.labels,c=i.calculateCircumference(o.data[e]),h=u.xCenter,f=u.yCenter,g=0,m=i.getMeta(),p=0;p<e;++p)isNaN(o.data[p])||m.data[p].hidden||++g;var v=s.startAngle,y=t.hidden?0:u.getDistanceFromCenterForValue(o.data[e]),b=v+c*g,x=b+(t.hidden?0:c),_=l.animateScale?0:u.getDistanceFromCenterForValue(o.data[e]);r.extend(t,{_datasetIndex:i.index,_index:e,_scale:u,_model:{x:h,y:f,innerRadius:0,outerRadius:n?_:y,startAngle:n&&l.animateRotate?v:b,endAngle:n&&l.animateRotate?v:x,label:r.valueAtIndexOrDefault(d,e,d[e])}}),i.removeHoverStyle(t),t.pivot()},removeHoverStyle:function(e){t.DatasetController.prototype.removeHoverStyle.call(this,e,this.chart.options.elements.arc)},countVisibleElements:function(){var t=this.getDataset(),e=this.getMeta(),n=0;return r.each(e.data,function(e,i){isNaN(t.data[i])||e.hidden||n++}),n},calculateCircumference:function(t){var e=this.getMeta().count;return e>0&&!isNaN(t)?2*Math.PI/e:0}})}},{25:25,40:40,45:45}],20:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("radar",{scale:{type:"radialLinear"},elements:{line:{tension:0}}}),e.exports=function(t){t.controllers.radar=t.DatasetController.extend({datasetElementType:a.Line,dataElementType:a.Point,linkScales:r.noop,update:function(t){var e=this,n=e.getMeta(),i=n.dataset,a=n.data,o=i.custom||{},s=e.getDataset(),l=e.chart.options.elements.line,u=e.chart.scale;void 0!==s.tension&&void 0===s.lineTension&&(s.lineTension=s.tension),r.extend(n.dataset,{_datasetIndex:e.index,_scale:u,_children:a,_loop:!0,_model:{tension:o.tension?o.tension:r.valueOrDefault(s.lineTension,l.tension),backgroundColor:o.backgroundColor?o.backgroundColor:s.backgroundColor||l.backgroundColor,borderWidth:o.borderWidth?o.borderWidth:s.borderWidth||l.borderWidth,borderColor:o.borderColor?o.borderColor:s.borderColor||l.borderColor,fill:o.fill?o.fill:void 0!==s.fill?s.fill:l.fill,borderCapStyle:o.borderCapStyle?o.borderCapStyle:s.borderCapStyle||l.borderCapStyle,borderDash:o.borderDash?o.borderDash:s.borderDash||l.borderDash,borderDashOffset:o.borderDashOffset?o.borderDashOffset:s.borderDashOffset||l.borderDashOffset,borderJoinStyle:o.borderJoinStyle?o.borderJoinStyle:s.borderJoinStyle||l.borderJoinStyle}}),n.dataset.pivot(),r.each(a,function(n,i){e.updateElement(n,i,t)},e),e.updateBezierControlPoints()},updateElement:function(t,e,n){var i=this,a=t.custom||{},o=i.getDataset(),s=i.chart.scale,l=i.chart.options.elements.point,u=s.getPointPositionForValue(e,o.data[e]);void 0!==o.radius&&void 0===o.pointRadius&&(o.pointRadius=o.radius),void 0!==o.hitRadius&&void 0===o.pointHitRadius&&(o.pointHitRadius=o.hitRadius),r.extend(t,{_datasetIndex:i.index,_index:e,_scale:s,_model:{x:n?s.xCenter:u.x,y:n?s.yCenter:u.y,tension:a.tension?a.tension:r.valueOrDefault(o.lineTension,i.chart.options.elements.line.tension),radius:a.radius?a.radius:r.valueAtIndexOrDefault(o.pointRadius,e,l.radius),backgroundColor:a.backgroundColor?a.backgroundColor:r.valueAtIndexOrDefault(o.pointBackgroundColor,e,l.backgroundColor),borderColor:a.borderColor?a.borderColor:r.valueAtIndexOrDefault(o.pointBorderColor,e,l.borderColor),borderWidth:a.borderWidth?a.borderWidth:r.valueAtIndexOrDefault(o.pointBorderWidth,e,l.borderWidth),pointStyle:a.pointStyle?a.pointStyle:r.valueAtIndexOrDefault(o.pointStyle,e,l.pointStyle),hitRadius:a.hitRadius?a.hitRadius:r.valueAtIndexOrDefault(o.pointHitRadius,e,l.hitRadius)}}),t._model.skip=a.skip?a.skip:isNaN(t._model.x)||isNaN(t._model.y)},updateBezierControlPoints:function(){var t=this.chart.chartArea,e=this.getMeta();r.each(e.data,function(n,i){var a=n._model,o=r.splineCurve(r.previousItem(e.data,i,!0)._model,a,r.nextItem(e.data,i,!0)._model,a.tension);a.controlPointPreviousX=Math.max(Math.min(o.previous.x,t.right),t.left),a.controlPointPreviousY=Math.max(Math.min(o.previous.y,t.bottom),t.top),a.controlPointNextX=Math.max(Math.min(o.next.x,t.right),t.left),a.controlPointNextY=Math.max(Math.min(o.next.y,t.bottom),t.top),n.pivot()})},setHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t.custom||{},i=t._index,a=t._model;a.radius=n.hoverRadius?n.hoverRadius:r.valueAtIndexOrDefault(e.pointHoverRadius,i,this.chart.options.elements.point.hoverRadius),a.backgroundColor=n.hoverBackgroundColor?n.hoverBackgroundColor:r.valueAtIndexOrDefault(e.pointHoverBackgroundColor,i,r.getHoverColor(a.backgroundColor)),a.borderColor=n.hoverBorderColor?n.hoverBorderColor:r.valueAtIndexOrDefault(e.pointHoverBorderColor,i,r.getHoverColor(a.borderColor)),a.borderWidth=n.hoverBorderWidth?n.hoverBorderWidth:r.valueAtIndexOrDefault(e.pointHoverBorderWidth,i,a.borderWidth)},removeHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t.custom||{},i=t._index,a=t._model,o=this.chart.options.elements.point;a.radius=n.radius?n.radius:r.valueAtIndexOrDefault(e.pointRadius,i,o.radius),a.backgroundColor=n.backgroundColor?n.backgroundColor:r.valueAtIndexOrDefault(e.pointBackgroundColor,i,o.backgroundColor),a.borderColor=n.borderColor?n.borderColor:r.valueAtIndexOrDefault(e.pointBorderColor,i,o.borderColor),a.borderWidth=n.borderWidth?n.borderWidth:r.valueAtIndexOrDefault(e.pointBorderWidth,i,o.borderWidth)}})}},{25:25,40:40,45:45}],21:[function(t,e,n){"use strict";t(25)._set("scatter",{hover:{mode:"single"},scales:{xAxes:[{id:"x-axis-1",type:"linear",position:"bottom"}],yAxes:[{id:"y-axis-1",type:"linear",position:"left"}]},showLines:!1,tooltips:{callbacks:{title:function(){return""},label:function(t){return"("+t.xLabel+", "+t.yLabel+")"}}}}),e.exports=function(t){t.controllers.scatter=t.controllers.line}},{25:25}],22:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45);i._set("global",{animation:{duration:1e3,easing:"easeOutQuart",onProgress:r.noop,onComplete:r.noop}}),e.exports=function(t){t.Animation=a.extend({chart:null,currentStep:0,numSteps:60,easing:"",render:null,onAnimationProgress:null,onAnimationComplete:null}),t.animationService={frameDuration:17,animations:[],dropFrames:0,request:null,addAnimation:function(t,e,n,i){var a,r,o=this.animations;for(e.chart=t,i||(t.animating=!0),a=0,r=o.length;a<r;++a)if(o[a].chart===t)return void(o[a]=e);o.push(e),1===o.length&&this.requestAnimationFrame()},cancelAnimation:function(t){var e=r.findIndex(this.animations,function(e){return e.chart===t});-1!==e&&(this.animations.splice(e,1),t.animating=!1)},requestAnimationFrame:function(){var t=this;null===t.request&&(t.request=r.requestAnimFrame.call(window,function(){t.request=null,t.startDigest()}))},startDigest:function(){var t=this,e=Date.now(),n=0;t.dropFrames>1&&(n=Math.floor(t.dropFrames),t.dropFrames=t.dropFrames%1),t.advance(1+n);var i=Date.now();t.dropFrames+=(i-e)/t.frameDuration,t.animations.length>0&&t.requestAnimationFrame()},advance:function(t){for(var e,n,i=this.animations,a=0;a<i.length;)n=(e=i[a]).chart,e.currentStep=(e.currentStep||0)+t,e.currentStep=Math.min(e.currentStep,e.numSteps),r.callback(e.render,[n,e],n),r.callback(e.onAnimationProgress,[e],n),e.currentStep>=e.numSteps?(r.callback(e.onAnimationComplete,[e],n),n.animating=!1,i.splice(a,1)):++a}},Object.defineProperty(t.Animation.prototype,"animationObject",{get:function(){return this}}),Object.defineProperty(t.Animation.prototype,"chartInstance",{get:function(){return this.chart},set:function(t){this.chart=t}})}},{25:25,26:26,45:45}],23:[function(t,e,n){"use strict";var i=t(25),a=t(45),r=t(28),o=t(48);e.exports=function(t){function e(t){var e=(t=t||{}).data=t.data||{};return e.datasets=e.datasets||[],e.labels=e.labels||[],t.options=a.configMerge(i.global,i[t.type],t.options||{}),t}function n(t){var e=t.options;e.scale?t.scale.options=e.scale:e.scales&&e.scales.xAxes.concat(e.scales.yAxes).forEach(function(e){t.scales[e.id].options=e}),t.tooltip._options=e.tooltips}function s(t){return"top"===t||"bottom"===t}var l=t.plugins;t.types={},t.instances={},t.controllers={},a.extend(t.prototype,{construct:function(n,i){var r=this;i=e(i);var s=o.acquireContext(n,i),l=s&&s.canvas,u=l&&l.height,d=l&&l.width;r.id=a.uid(),r.ctx=s,r.canvas=l,r.config=i,r.width=d,r.height=u,r.aspectRatio=u?d/u:null,r.options=i.options,r._bufferedRender=!1,r.chart=r,r.controller=r,t.instances[r.id]=r,Object.defineProperty(r,"data",{get:function(){return r.config.data},set:function(t){r.config.data=t}}),s&&l?(r.initialize(),r.update()):console.error("Failed to create chart: can't acquire context from the given item")},initialize:function(){var t=this;return l.notify(t,"beforeInit"),a.retinaScale(t,t.options.devicePixelRatio),t.bindEvents(),t.options.responsive&&t.resize(!0),t.ensureScalesHaveIDs(),t.buildScales(),t.initToolTip(),l.notify(t,"afterInit"),t},clear:function(){return a.canvas.clear(this),this},stop:function(){return t.animationService.cancelAnimation(this),this},resize:function(t){var e=this,n=e.options,i=e.canvas,r=n.maintainAspectRatio&&e.aspectRatio||null,o=Math.max(0,Math.floor(a.getMaximumWidth(i))),s=Math.max(0,Math.floor(r?o/r:a.getMaximumHeight(i)));if((e.width!==o||e.height!==s)&&(i.width=e.width=o,i.height=e.height=s,i.style.width=o+"px",i.style.height=s+"px",a.retinaScale(e,n.devicePixelRatio),!t)){var u={width:o,height:s};l.notify(e,"resize",[u]),e.options.onResize&&e.options.onResize(e,u),e.stop(),e.update(e.options.responsiveAnimationDuration)}},ensureScalesHaveIDs:function(){var t=this.options,e=t.scales||{},n=t.scale;a.each(e.xAxes,function(t,e){t.id=t.id||"x-axis-"+e}),a.each(e.yAxes,function(t,e){t.id=t.id||"y-axis-"+e}),n&&(n.id=n.id||"scale")},buildScales:function(){var e=this,n=e.options,i=e.scales={},r=[];n.scales&&(r=r.concat((n.scales.xAxes||[]).map(function(t){return{options:t,dtype:"category",dposition:"bottom"}}),(n.scales.yAxes||[]).map(function(t){return{options:t,dtype:"linear",dposition:"left"}}))),n.scale&&r.push({options:n.scale,dtype:"radialLinear",isDefault:!0,dposition:"chartArea"}),a.each(r,function(n){var r=n.options,o=a.valueOrDefault(r.type,n.dtype),l=t.scaleService.getScaleConstructor(o);if(l){s(r.position)!==s(n.dposition)&&(r.position=n.dposition);var u=new l({id:r.id,options:r,ctx:e.ctx,chart:e});i[u.id]=u,u.mergeTicksOptions(),n.isDefault&&(e.scale=u)}}),t.scaleService.addScalesToLayout(this)},buildOrUpdateControllers:function(){var e=this,n=[],i=[];return a.each(e.data.datasets,function(a,r){var o=e.getDatasetMeta(r),s=a.type||e.config.type;if(o.type&&o.type!==s&&(e.destroyDatasetMeta(r),o=e.getDatasetMeta(r)),o.type=s,n.push(o.type),o.controller)o.controller.updateIndex(r);else{var l=t.controllers[o.type];if(void 0===l)throw new Error('"'+o.type+'" is not a chart type.');o.controller=new l(e,r),i.push(o.controller)}},e),i},resetElements:function(){var t=this;a.each(t.data.datasets,function(e,n){t.getDatasetMeta(n).controller.reset()},t)},reset:function(){this.resetElements(),this.tooltip.initialize()},update:function(t){var e=this;if(t&&"object"==typeof t||(t={duration:t,lazy:arguments[1]}),n(e),!1!==l.notify(e,"beforeUpdate")){e.tooltip._data=e.data;var i=e.buildOrUpdateControllers();a.each(e.data.datasets,function(t,n){e.getDatasetMeta(n).controller.buildOrUpdateElements()},e),e.updateLayout(),a.each(i,function(t){t.reset()}),e.updateDatasets(),e.tooltip.initialize(),e.lastActive=[],l.notify(e,"afterUpdate"),e._bufferedRender?e._bufferedRequest={duration:t.duration,easing:t.easing,lazy:t.lazy}:e.render(t)}},updateLayout:function(){var e=this;!1!==l.notify(e,"beforeLayout")&&(t.layoutService.update(this,this.width,this.height),l.notify(e,"afterScaleUpdate"),l.notify(e,"afterLayout"))},updateDatasets:function(){var t=this;if(!1!==l.notify(t,"beforeDatasetsUpdate")){for(var e=0,n=t.data.datasets.length;e<n;++e)t.updateDataset(e);l.notify(t,"afterDatasetsUpdate")}},updateDataset:function(t){var e=this,n=e.getDatasetMeta(t),i={meta:n,index:t};!1!==l.notify(e,"beforeDatasetUpdate",[i])&&(n.controller.update(),l.notify(e,"afterDatasetUpdate",[i]))},render:function(e){var n=this;e&&"object"==typeof e||(e={duration:e,lazy:arguments[1]});var i=e.duration,r=e.lazy;if(!1!==l.notify(n,"beforeRender")){var o=n.options.animation,s=function(t){l.notify(n,"afterRender"),a.callback(o&&o.onComplete,[t],n)};if(o&&(void 0!==i&&0!==i||void 0===i&&0!==o.duration)){var u=new t.Animation({numSteps:(i||o.duration)/16.66,easing:e.easing||o.easing,render:function(t,e){var n=a.easing.effects[e.easing],i=e.currentStep,r=i/e.numSteps;t.draw(n(r),r,i)},onAnimationProgress:o.onProgress,onAnimationComplete:s});t.animationService.addAnimation(n,u,i,r)}else n.draw(),s(new t.Animation({numSteps:0,chart:n}));return n}},draw:function(t){var e=this;e.clear(),a.isNullOrUndef(t)&&(t=1),e.transition(t),!1!==l.notify(e,"beforeDraw",[t])&&(a.each(e.boxes,function(t){t.draw(e.chartArea)},e),e.scale&&e.scale.draw(),e.drawDatasets(t),e._drawTooltip(t),l.notify(e,"afterDraw",[t]))},transition:function(t){for(var e=this,n=0,i=(e.data.datasets||[]).length;n<i;++n)e.isDatasetVisible(n)&&e.getDatasetMeta(n).controller.transition(t);e.tooltip.transition(t)},drawDatasets:function(t){var e=this;if(!1!==l.notify(e,"beforeDatasetsDraw",[t])){for(var n=(e.data.datasets||[]).length-1;n>=0;--n)e.isDatasetVisible(n)&&e.drawDataset(n,t);l.notify(e,"afterDatasetsDraw",[t])}},drawDataset:function(t,e){var n=this,i=n.getDatasetMeta(t),a={meta:i,index:t,easingValue:e};!1!==l.notify(n,"beforeDatasetDraw",[a])&&(i.controller.draw(e),l.notify(n,"afterDatasetDraw",[a]))},_drawTooltip:function(t){var e=this,n=e.tooltip,i={tooltip:n,easingValue:t};!1!==l.notify(e,"beforeTooltipDraw",[i])&&(n.draw(),l.notify(e,"afterTooltipDraw",[i]))},getElementAtEvent:function(t){return r.modes.single(this,t)},getElementsAtEvent:function(t){return r.modes.label(this,t,{intersect:!0})},getElementsAtXAxis:function(t){return r.modes["x-axis"](this,t,{intersect:!0})},getElementsAtEventForMode:function(t,e,n){var i=r.modes[e];return"function"==typeof i?i(this,t,n):[]},getDatasetAtEvent:function(t){return r.modes.dataset(this,t,{intersect:!0})},getDatasetMeta:function(t){var e=this,n=e.data.datasets[t];n._meta||(n._meta={});var i=n._meta[e.id];return i||(i=n._meta[e.id]={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null}),i},getVisibleDatasetCount:function(){for(var t=0,e=0,n=this.data.datasets.length;e<n;++e)this.isDatasetVisible(e)&&t++;return t},isDatasetVisible:function(t){var e=this.getDatasetMeta(t);return"boolean"==typeof e.hidden?!e.hidden:!this.data.datasets[t].hidden},generateLegend:function(){return this.options.legendCallback(this)},destroyDatasetMeta:function(t){var e=this.id,n=this.data.datasets[t],i=n._meta&&n._meta[e];i&&(i.controller.destroy(),delete n._meta[e])},destroy:function(){var e,n,i=this,r=i.canvas;for(i.stop(),e=0,n=i.data.datasets.length;e<n;++e)i.destroyDatasetMeta(e);r&&(i.unbindEvents(),a.canvas.clear(i),o.releaseContext(i.ctx),i.canvas=null,i.ctx=null),l.notify(i,"destroy"),delete t.instances[i.id]},toBase64Image:function(){return this.canvas.toDataURL.apply(this.canvas,arguments)},initToolTip:function(){var e=this;e.tooltip=new t.Tooltip({_chart:e,_chartInstance:e,_data:e.data,_options:e.options.tooltips},e)},bindEvents:function(){var t=this,e=t._listeners={},n=function(){t.eventHandler.apply(t,arguments)};a.each(t.options.events,function(i){o.addEventListener(t,i,n),e[i]=n}),t.options.responsive&&(n=function(){t.resize()},o.addEventListener(t,"resize",n),e.resize=n)},unbindEvents:function(){var t=this,e=t._listeners;e&&(delete t._listeners,a.each(e,function(e,n){o.removeEventListener(t,n,e)}))},updateHoverStyle:function(t,e,n){var i,a,r,o=n?"setHoverStyle":"removeHoverStyle";for(a=0,r=t.length;a<r;++a)(i=t[a])&&this.getDatasetMeta(i._datasetIndex).controller[o](i)},eventHandler:function(t){var e=this,n=e.tooltip;if(!1!==l.notify(e,"beforeEvent",[t])){e._bufferedRender=!0,e._bufferedRequest=null;var i=e.handleEvent(t);i|=n&&n.handleEvent(t),l.notify(e,"afterEvent",[t]);var a=e._bufferedRequest;return a?e.render(a):i&&!e.animating&&(e.stop(),e.render(e.options.hover.animationDuration,!0)),e._bufferedRender=!1,e._bufferedRequest=null,e}},handleEvent:function(t){var e=this,n=e.options||{},i=n.hover,r=!1;return e.lastActive=e.lastActive||[],"mouseout"===t.type?e.active=[]:e.active=e.getElementsAtEventForMode(t,i.mode,i),a.callback(n.onHover||n.hover.onHover,[t.native,e.active],e),"mouseup"!==t.type&&"click"!==t.type||n.onClick&&n.onClick.call(e,t.native,e.active),e.lastActive.length&&e.updateHoverStyle(e.lastActive,i.mode,!1),e.active.length&&i.mode&&e.updateHoverStyle(e.active,i.mode,!0),r=!a.arrayEquals(e.active,e.lastActive),e.lastActive=e.active,r}}),t.Controller=t}},{25:25,28:28,45:45,48:48}],24:[function(t,e,n){"use strict";var i=t(45);e.exports=function(t){function e(t,e){t._chartjs?t._chartjs.listeners.push(e):(Object.defineProperty(t,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[e]}}),a.forEach(function(e){var n="onData"+e.charAt(0).toUpperCase()+e.slice(1),a=t[e];Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value:function(){var e=Array.prototype.slice.call(arguments),r=a.apply(this,e);return i.each(t._chartjs.listeners,function(t){"function"==typeof t[n]&&t[n].apply(t,e)}),r}})}))}function n(t,e){var n=t._chartjs;if(n){var i=n.listeners,r=i.indexOf(e);-1!==r&&i.splice(r,1),i.length>0||(a.forEach(function(e){delete t[e]}),delete t._chartjs)}}var a=["push","pop","shift","splice","unshift"];t.DatasetController=function(t,e){this.initialize(t,e)},i.extend(t.DatasetController.prototype,{datasetElementType:null,dataElementType:null,initialize:function(t,e){var n=this;n.chart=t,n.index=e,n.linkScales(),n.addElements()},updateIndex:function(t){this.index=t},linkScales:function(){var t=this,e=t.getMeta(),n=t.getDataset();null===e.xAxisID&&(e.xAxisID=n.xAxisID||t.chart.options.scales.xAxes[0].id),null===e.yAxisID&&(e.yAxisID=n.yAxisID||t.chart.options.scales.yAxes[0].id)},getDataset:function(){return this.chart.data.datasets[this.index]},getMeta:function(){return this.chart.getDatasetMeta(this.index)},getScaleForId:function(t){return this.chart.scales[t]},reset:function(){this.update(!0)},destroy:function(){this._data&&n(this._data,this)},createMetaDataset:function(){var t=this,e=t.datasetElementType;return e&&new e({_chart:t.chart,_datasetIndex:t.index})},createMetaData:function(t){var e=this,n=e.dataElementType;return n&&new n({_chart:e.chart,_datasetIndex:e.index,_index:t})},addElements:function(){var t,e,n=this,i=n.getMeta(),a=n.getDataset().data||[],r=i.data;for(t=0,e=a.length;t<e;++t)r[t]=r[t]||n.createMetaData(t);i.dataset=i.dataset||n.createMetaDataset()},addElementAndReset:function(t){var e=this.createMetaData(t);this.getMeta().data.splice(t,0,e),this.updateElement(e,t,!0)},buildOrUpdateElements:function(){var t=this,i=t.getDataset(),a=i.data||(i.data=[]);t._data!==a&&(t._data&&n(t._data,t),e(a,t),t._data=a),t.resyncElements()},update:i.noop,transition:function(t){for(var e=this.getMeta(),n=e.data||[],i=n.length,a=0;a<i;++a)n[a].transition(t);e.dataset&&e.dataset.transition(t)},draw:function(){var t=this.getMeta(),e=t.data||[],n=e.length,i=0;for(t.dataset&&t.dataset.draw();i<n;++i)e[i].draw()},removeHoverStyle:function(t,e){var n=this.chart.data.datasets[t._datasetIndex],a=t._index,r=t.custom||{},o=i.valueAtIndexOrDefault,s=t._model;s.backgroundColor=r.backgroundColor?r.backgroundColor:o(n.backgroundColor,a,e.backgroundColor),s.borderColor=r.borderColor?r.borderColor:o(n.borderColor,a,e.borderColor),s.borderWidth=r.borderWidth?r.borderWidth:o(n.borderWidth,a,e.borderWidth)},setHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t._index,a=t.custom||{},r=i.valueAtIndexOrDefault,o=i.getHoverColor,s=t._model;s.backgroundColor=a.hoverBackgroundColor?a.hoverBackgroundColor:r(e.hoverBackgroundColor,n,o(s.backgroundColor)),s.borderColor=a.hoverBorderColor?a.hoverBorderColor:r(e.hoverBorderColor,n,o(s.borderColor)),s.borderWidth=a.hoverBorderWidth?a.hoverBorderWidth:r(e.hoverBorderWidth,n,s.borderWidth)},resyncElements:function(){var t=this,e=t.getMeta(),n=t.getDataset().data,i=e.data.length,a=n.length;a<i?e.data.splice(a,i-a):a>i&&t.insertElements(i,a-i)},insertElements:function(t,e){for(var n=0;n<e;++n)this.addElementAndReset(t+n)},onDataPush:function(){this.insertElements(this.getDataset().data.length-1,arguments.length)},onDataPop:function(){this.getMeta().data.pop()},onDataShift:function(){this.getMeta().data.shift()},onDataSplice:function(t,e){this.getMeta().data.splice(t,e),this.insertElements(t,arguments.length-2)},onDataUnshift:function(){this.insertElements(0,arguments.length)}}),t.DatasetController.extend=i.inherits}},{45:45}],25:[function(t,e,n){"use strict";var i=t(45);e.exports={_set:function(t,e){return i.merge(this[t]||(this[t]={}),e)}}},{45:45}],26:[function(t,e,n){"use strict";function i(t,e,n,i){var r,o,s,l,u,d,c,h,f,g=Object.keys(n);for(r=0,o=g.length;r<o;++r)if(s=g[r],d=n[s],e.hasOwnProperty(s)||(e[s]=d),(l=e[s])!==d&&"_"!==s[0]){if(t.hasOwnProperty(s)||(t[s]=l),u=t[s],(c=typeof d)===typeof u)if("string"===c){if((h=a(u)).valid&&(f=a(d)).valid){e[s]=f.mix(h,i).rgbString();continue}}else if("number"===c&&isFinite(u)&&isFinite(d)){e[s]=u+(d-u)*i;continue}e[s]=d}}var a=t(2),r=t(45),o=function(t){r.extend(this,t),this.initialize.apply(this,arguments)};r.extend(o.prototype,{initialize:function(){this.hidden=!1},pivot:function(){var t=this;return t._view||(t._view=r.clone(t._model)),t._start={},t},transition:function(t){var e=this,n=e._model,a=e._start,r=e._view;return n&&1!==t?(r||(r=e._view={}),a||(a=e._start={}),i(a,r,n,t),e):(e._view=n,e._start=null,e)},tooltipPosition:function(){return{x:this._model.x,y:this._model.y}},hasValue:function(){return r.isNumber(this._model.x)&&r.isNumber(this._model.y)}}),o.extend=r.inherits,e.exports=o},{2:2,45:45}],27:[function(t,e,n){"use strict";var i=t(2),a=t(25),r=t(45);e.exports=function(t){function e(t,e,n){var i;return"string"==typeof t?(i=parseInt(t,10),-1!==t.indexOf("%")&&(i=i/100*e.parentNode[n])):i=t,i}function n(t){return void 0!==t&&null!==t&&"none"!==t}function o(t,i,a){var r=document.defaultView,o=t.parentNode,s=r.getComputedStyle(t)[i],l=r.getComputedStyle(o)[i],u=n(s),d=n(l),c=Number.POSITIVE_INFINITY;return u||d?Math.min(u?e(s,t,a):c,d?e(l,o,a):c):"none"}r.configMerge=function(){return r.merge(r.clone(arguments[0]),[].slice.call(arguments,1),{merger:function(e,n,i,a){var o=n[e]||{},s=i[e];"scales"===e?n[e]=r.scaleMerge(o,s):"scale"===e?n[e]=r.merge(o,[t.scaleService.getScaleDefaults(s.type),s]):r._merger(e,n,i,a)}})},r.scaleMerge=function(){return r.merge(r.clone(arguments[0]),[].slice.call(arguments,1),{merger:function(e,n,i,a){if("xAxes"===e||"yAxes"===e){var o,s,l,u=i[e].length;for(n[e]||(n[e]=[]),o=0;o<u;++o)l=i[e][o],s=r.valueOrDefault(l.type,"xAxes"===e?"category":"linear"),o>=n[e].length&&n[e].push({}),!n[e][o].type||l.type&&l.type!==n[e][o].type?r.merge(n[e][o],[t.scaleService.getScaleDefaults(s),l]):r.merge(n[e][o],l)}else r._merger(e,n,i,a)}})},r.where=function(t,e){if(r.isArray(t)&&Array.prototype.filter)return t.filter(e);var n=[];return r.each(t,function(t){e(t)&&n.push(t)}),n},r.findIndex=Array.prototype.findIndex?function(t,e,n){return t.findIndex(e,n)}:function(t,e,n){n=void 0===n?t:n;for(var i=0,a=t.length;i<a;++i)if(e.call(n,t[i],i,t))return i;return-1},r.findNextWhere=function(t,e,n){r.isNullOrUndef(n)&&(n=-1);for(var i=n+1;i<t.length;i++){var a=t[i];if(e(a))return a}},r.findPreviousWhere=function(t,e,n){r.isNullOrUndef(n)&&(n=t.length);for(var i=n-1;i>=0;i--){var a=t[i];if(e(a))return a}},r.isNumber=function(t){return!isNaN(parseFloat(t))&&isFinite(t)},r.almostEquals=function(t,e,n){return Math.abs(t-e)<n},r.almostWhole=function(t,e){var n=Math.round(t);return n-e<t&&n+e>t},r.max=function(t){return t.reduce(function(t,e){return isNaN(e)?t:Math.max(t,e)},Number.NEGATIVE_INFINITY)},r.min=function(t){return t.reduce(function(t,e){return isNaN(e)?t:Math.min(t,e)},Number.POSITIVE_INFINITY)},r.sign=Math.sign?function(t){return Math.sign(t)}:function(t){return 0==(t=+t)||isNaN(t)?t:t>0?1:-1},r.log10=Math.log10?function(t){return Math.log10(t)}:function(t){return Math.log(t)/Math.LN10},r.toRadians=function(t){return t*(Math.PI/180)},r.toDegrees=function(t){return t*(180/Math.PI)},r.getAngleFromPoint=function(t,e){var n=e.x-t.x,i=e.y-t.y,a=Math.sqrt(n*n+i*i),r=Math.atan2(i,n);return r<-.5*Math.PI&&(r+=2*Math.PI),{angle:r,distance:a}},r.distanceBetweenPoints=function(t,e){return Math.sqrt(Math.pow(e.x-t.x,2)+Math.pow(e.y-t.y,2))},r.aliasPixel=function(t){return t%2==0?0:.5},r.splineCurve=function(t,e,n,i){var a=t.skip?e:t,r=e,o=n.skip?e:n,s=Math.sqrt(Math.pow(r.x-a.x,2)+Math.pow(r.y-a.y,2)),l=Math.sqrt(Math.pow(o.x-r.x,2)+Math.pow(o.y-r.y,2)),u=s/(s+l),d=l/(s+l),c=i*(u=isNaN(u)?0:u),h=i*(d=isNaN(d)?0:d);return{previous:{x:r.x-c*(o.x-a.x),y:r.y-c*(o.y-a.y)},next:{x:r.x+h*(o.x-a.x),y:r.y+h*(o.y-a.y)}}},r.EPSILON=Number.EPSILON||1e-14,r.splineCurveMonotone=function(t){var e,n,i,a,o=(t||[]).map(function(t){return{model:t._model,deltaK:0,mK:0}}),s=o.length;for(e=0;e<s;++e)if(!(i=o[e]).model.skip){if(n=e>0?o[e-1]:null,(a=e<s-1?o[e+1]:null)&&!a.model.skip){var l=a.model.x-i.model.x;i.deltaK=0!==l?(a.model.y-i.model.y)/l:0}!n||n.model.skip?i.mK=i.deltaK:!a||a.model.skip?i.mK=n.deltaK:this.sign(n.deltaK)!==this.sign(i.deltaK)?i.mK=0:i.mK=(n.deltaK+i.deltaK)/2}var u,d,c,h;for(e=0;e<s-1;++e)i=o[e],a=o[e+1],i.model.skip||a.model.skip||(r.almostEquals(i.deltaK,0,this.EPSILON)?i.mK=a.mK=0:(u=i.mK/i.deltaK,d=a.mK/i.deltaK,(h=Math.pow(u,2)+Math.pow(d,2))<=9||(c=3/Math.sqrt(h),i.mK=u*c*i.deltaK,a.mK=d*c*i.deltaK)));var f;for(e=0;e<s;++e)(i=o[e]).model.skip||(n=e>0?o[e-1]:null,a=e<s-1?o[e+1]:null,n&&!n.model.skip&&(f=(i.model.x-n.model.x)/3,i.model.controlPointPreviousX=i.model.x-f,i.model.controlPointPreviousY=i.model.y-f*i.mK),a&&!a.model.skip&&(f=(a.model.x-i.model.x)/3,i.model.controlPointNextX=i.model.x+f,i.model.controlPointNextY=i.model.y+f*i.mK))},r.nextItem=function(t,e,n){return n?e>=t.length-1?t[0]:t[e+1]:e>=t.length-1?t[t.length-1]:t[e+1]},r.previousItem=function(t,e,n){return n?e<=0?t[t.length-1]:t[e-1]:e<=0?t[0]:t[e-1]},r.niceNum=function(t,e){var n=Math.floor(r.log10(t)),i=t/Math.pow(10,n);return(e?i<1.5?1:i<3?2:i<7?5:10:i<=1?1:i<=2?2:i<=5?5:10)*Math.pow(10,n)},r.requestAnimFrame="undefined"==typeof window?function(t){t()}:window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(t){return window.setTimeout(t,1e3/60)},r.getRelativePosition=function(t,e){var n,i,a=t.originalEvent||t,o=t.currentTarget||t.srcElement,s=o.getBoundingClientRect(),l=a.touches;l&&l.length>0?(n=l[0].clientX,i=l[0].clientY):(n=a.clientX,i=a.clientY);var u=parseFloat(r.getStyle(o,"padding-left")),d=parseFloat(r.getStyle(o,"padding-top")),c=parseFloat(r.getStyle(o,"padding-right")),h=parseFloat(r.getStyle(o,"padding-bottom")),f=s.right-s.left-u-c,g=s.bottom-s.top-d-h;return n=Math.round((n-s.left-u)/f*o.width/e.currentDevicePixelRatio),i=Math.round((i-s.top-d)/g*o.height/e.currentDevicePixelRatio),{x:n,y:i}},r.getConstraintWidth=function(t){return o(t,"max-width","clientWidth")},r.getConstraintHeight=function(t){return o(t,"max-height","clientHeight")},r.getMaximumWidth=function(t){var e=t.parentNode;if(!e)return t.clientWidth;var n=parseInt(r.getStyle(e,"padding-left"),10),i=parseInt(r.getStyle(e,"padding-right"),10),a=e.clientWidth-n-i,o=r.getConstraintWidth(t);return isNaN(o)?a:Math.min(a,o)},r.getMaximumHeight=function(t){var e=t.parentNode;if(!e)return t.clientHeight;var n=parseInt(r.getStyle(e,"padding-top"),10),i=parseInt(r.getStyle(e,"padding-bottom"),10),a=e.clientHeight-n-i,o=r.getConstraintHeight(t);return isNaN(o)?a:Math.min(a,o)},r.getStyle=function(t,e){return t.currentStyle?t.currentStyle[e]:document.defaultView.getComputedStyle(t,null).getPropertyValue(e)},r.retinaScale=function(t,e){var n=t.currentDevicePixelRatio=e||window.devicePixelRatio||1;if(1!==n){var i=t.canvas,a=t.height,r=t.width;i.height=a*n,i.width=r*n,t.ctx.scale(n,n),i.style.height=a+"px",i.style.width=r+"px"}},r.fontString=function(t,e,n){return e+" "+t+"px "+n},r.longestText=function(t,e,n,i){var a=(i=i||{}).data=i.data||{},o=i.garbageCollect=i.garbageCollect||[];i.font!==e&&(a=i.data={},o=i.garbageCollect=[],i.font=e),t.font=e;var s=0;r.each(n,function(e){void 0!==e&&null!==e&&!0!==r.isArray(e)?s=r.measureText(t,a,o,s,e):r.isArray(e)&&r.each(e,function(e){void 0===e||null===e||r.isArray(e)||(s=r.measureText(t,a,o,s,e))})});var l=o.length/2;if(l>n.length){for(var u=0;u<l;u++)delete a[o[u]];o.splice(0,l)}return s},r.measureText=function(t,e,n,i,a){var r=e[a];return r||(r=e[a]=t.measureText(a).width,n.push(a)),r>i&&(i=r),i},r.numberOfLabelLines=function(t){var e=1;return r.each(t,function(t){r.isArray(t)&&t.length>e&&(e=t.length)}),e},r.color=i?function(t){return t instanceof CanvasGradient&&(t=a.global.defaultColor),i(t)}:function(t){return console.error("Color.js not found!"),t},r.getHoverColor=function(t){return t instanceof CanvasPattern?t:r.color(t).saturate(.5).darken(.1).rgbString()}}},{2:2,25:25,45:45}],28:[function(t,e,n){"use strict";function i(t,e){return t.native?{x:t.x,y:t.y}:u.getRelativePosition(t,e)}function a(t,e){var n,i,a,r,o;for(i=0,r=t.data.datasets.length;i<r;++i)if(t.isDatasetVisible(i))for(a=0,o=(n=t.getDatasetMeta(i)).data.length;a<o;++a){var s=n.data[a];s._view.skip||e(s)}}function r(t,e){var n=[];return a(t,function(t){t.inRange(e.x,e.y)&&n.push(t)}),n}function o(t,e,n,i){var r=Number.POSITIVE_INFINITY,o=[];return a(t,function(t){if(!n||t.inRange(e.x,e.y)){var a=t.getCenterPoint(),s=i(e,a);s<r?(o=[t],r=s):s===r&&o.push(t)}}),o}function s(t){var e=-1!==t.indexOf("x"),n=-1!==t.indexOf("y");return function(t,i){var a=e?Math.abs(t.x-i.x):0,r=n?Math.abs(t.y-i.y):0;return Math.sqrt(Math.pow(a,2)+Math.pow(r,2))}}function l(t,e,n){var a=i(e,t);n.axis=n.axis||"x";var l=s(n.axis),u=n.intersect?r(t,a):o(t,a,!1,l),d=[];return u.length?(t.data.datasets.forEach(function(e,n){if(t.isDatasetVisible(n)){var i=t.getDatasetMeta(n).data[u[0]._index];i&&!i._view.skip&&d.push(i)}}),d):[]}var u=t(45);e.exports={modes:{single:function(t,e){var n=i(e,t),r=[];return a(t,function(t){if(t.inRange(n.x,n.y))return r.push(t),r}),r.slice(0,1)},label:l,index:l,dataset:function(t,e,n){var a=i(e,t);n.axis=n.axis||"xy";var l=s(n.axis),u=n.intersect?r(t,a):o(t,a,!1,l);return u.length>0&&(u=t.getDatasetMeta(u[0]._datasetIndex).data),u},"x-axis":function(t,e){return l(t,e,{intersect:!1})},point:function(t,e){return r(t,i(e,t))},nearest:function(t,e,n){var a=i(e,t);n.axis=n.axis||"xy";var r=s(n.axis),l=o(t,a,n.intersect,r);return l.length>1&&l.sort(function(t,e){var n=t.getArea()-e.getArea();return 0===n&&(n=t._datasetIndex-e._datasetIndex),n}),l.slice(0,1)},x:function(t,e,n){var r=i(e,t),o=[],s=!1;return a(t,function(t){t.inXRange(r.x)&&o.push(t),t.inRange(r.x,r.y)&&(s=!0)}),n.intersect&&!s&&(o=[]),o},y:function(t,e,n){var r=i(e,t),o=[],s=!1;return a(t,function(t){t.inYRange(r.y)&&o.push(t),t.inRange(r.x,r.y)&&(s=!0)}),n.intersect&&!s&&(o=[]),o}}}},{45:45}],29:[function(t,e,n){"use strict";t(25)._set("global",{responsive:!0,responsiveAnimationDuration:0,maintainAspectRatio:!0,events:["mousemove","mouseout","click","touchstart","touchmove"],hover:{onHover:null,mode:"nearest",intersect:!0,animationDuration:400},onClick:null,defaultColor:"rgba(0,0,0,0.1)",defaultFontColor:"#666",defaultFontFamily:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",defaultFontSize:12,defaultFontStyle:"normal",showLines:!0,elements:{},layout:{padding:{top:0,right:0,bottom:0,left:0}}}),e.exports=function(){var t=function(t,e){return this.construct(t,e),this};return t.Chart=t,t}},{25:25}],30:[function(t,e,n){"use strict";var i=t(45);e.exports=function(t){function e(t,e){return i.where(t,function(t){return t.position===e})}function n(t,e){t.forEach(function(t,e){return t._tmpIndex_=e,t}),t.sort(function(t,n){var i=e?n:t,a=e?t:n;return i.weight===a.weight?i._tmpIndex_-a._tmpIndex_:i.weight-a.weight}),t.forEach(function(t){delete t._tmpIndex_})}t.layoutService={defaults:{},addBox:function(t,e){t.boxes||(t.boxes=[]),e.fullWidth=e.fullWidth||!1,e.position=e.position||"top",e.weight=e.weight||0,t.boxes.push(e)},removeBox:function(t,e){var n=t.boxes?t.boxes.indexOf(e):-1;-1!==n&&t.boxes.splice(n,1)},configure:function(t,e,n){for(var i,a=["fullWidth","position","weight"],r=a.length,o=0;o<r;++o)i=a[o],n.hasOwnProperty(i)&&(e[i]=n[i])},update:function(t,a,r){function o(t){var e=i.findNextWhere(D,function(e){return e.box===t});if(e)if(t.isHorizontal()){var n={left:Math.max(I,C),right:Math.max(O,P),top:0,bottom:0};t.update(t.fullWidth?b:M,x/2,n)}else t.update(e.minSize.width,S)}function s(t){t.isHorizontal()?(t.left=t.fullWidth?d:I,t.right=t.fullWidth?a-c:I+M,t.top=B,t.bottom=B+t.height,B=t.bottom):(t.left=z,t.right=z+t.width,t.top=F,t.bottom=F+S,z=t.right)}if(t){var l=t.options.layout||{},u=i.options.toPadding(l.padding),d=u.left,c=u.right,h=u.top,f=u.bottom,g=e(t.boxes,"left"),m=e(t.boxes,"right"),p=e(t.boxes,"top"),v=e(t.boxes,"bottom"),y=e(t.boxes,"chartArea");n(g,!0),n(m,!1),n(p,!0),n(v,!1);var b=a-d-c,x=r-h-f,_=x/2,k=(a-b/2)/(g.length+m.length),w=(r-_)/(p.length+v.length),M=b,S=x,D=[];i.each(g.concat(m,p,v),function(t){var e,n=t.isHorizontal();n?(e=t.update(t.fullWidth?b:M,w),S-=e.height):(e=t.update(k,_),M-=e.width),D.push({horizontal:n,minSize:e,box:t})});var C=0,P=0,T=0,A=0;i.each(p.concat(v),function(t){if(t.getPadding){var e=t.getPadding();C=Math.max(C,e.left),P=Math.max(P,e.right)}}),i.each(g.concat(m),function(t){if(t.getPadding){var e=t.getPadding();T=Math.max(T,e.top),A=Math.max(A,e.bottom)}});var I=d,O=c,F=h,R=f;i.each(g.concat(m),o),i.each(g,function(t){I+=t.width}),i.each(m,function(t){O+=t.width}),i.each(p.concat(v),o),i.each(p,function(t){F+=t.height}),i.each(v,function(t){R+=t.height}),i.each(g.concat(m),function(t){var e=i.findNextWhere(D,function(e){return e.box===t}),n={left:0,right:0,top:F,bottom:R};e&&t.update(e.minSize.width,S,n)}),I=d,O=c,F=h,R=f,i.each(g,function(t){I+=t.width}),i.each(m,function(t){O+=t.width}),i.each(p,function(t){F+=t.height}),i.each(v,function(t){R+=t.height});var L=Math.max(C-I,0);I+=L,O+=Math.max(P-O,0);var W=Math.max(T-F,0);F+=W,R+=Math.max(A-R,0);var Y=r-F-R,N=a-I-O;N===M&&Y===S||(i.each(g,function(t){t.height=Y}),i.each(m,function(t){t.height=Y}),i.each(p,function(t){t.fullWidth||(t.width=N)}),i.each(v,function(t){t.fullWidth||(t.width=N)}),S=Y,M=N);var z=d+L,B=h+W;i.each(g.concat(p),s),z+=M,B+=S,i.each(m,s),i.each(v,s),t.chartArea={left:I,top:F,right:I+M,bottom:F+S},i.each(y,function(e){e.left=t.chartArea.left,e.top=t.chartArea.top,e.right=t.chartArea.right,e.bottom=t.chartArea.bottom,e.update(M,S)})}}}}},{45:45}],31:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45);i._set("global",{plugins:{}}),e.exports=function(t){t.plugins={_plugins:[],_cacheId:0,register:function(t){var e=this._plugins;[].concat(t).forEach(function(t){-1===e.indexOf(t)&&e.push(t)}),this._cacheId++},unregister:function(t){var e=this._plugins;[].concat(t).forEach(function(t){var n=e.indexOf(t);-1!==n&&e.splice(n,1)}),this._cacheId++},clear:function(){this._plugins=[],this._cacheId++},count:function(){return this._plugins.length},getAll:function(){return this._plugins},notify:function(t,e,n){var i,a,r,o,s,l=this.descriptors(t),u=l.length;for(i=0;i<u;++i)if(a=l[i],r=a.plugin,"function"==typeof(s=r[e])&&((o=[t].concat(n||[])).push(a.options),!1===s.apply(r,o)))return!1;return!0},descriptors:function(t){var e=t._plugins||(t._plugins={});if(e.id===this._cacheId)return e.descriptors;var n=[],a=[],o=t&&t.config||{},s=o.options&&o.options.plugins||{};return this._plugins.concat(o.plugins||[]).forEach(function(t){if(-1===n.indexOf(t)){var e=t.id,o=s[e];!1!==o&&(!0===o&&(o=r.clone(i.global.plugins[e])),n.push(t),a.push({plugin:t,options:o||{}}))}}),e.descriptors=a,e.id=this._cacheId,a}},t.pluginService=t.plugins,t.PluginBase=a.extend({})}},{25:25,26:26,45:45}],32:[function(t,e,n){"use strict";function i(t){var e,n,i=[];for(e=0,n=t.length;e<n;++e)i.push(t[e].label);return i}function a(t,e,n){var i=t.getPixelForTick(e);return n&&(i-=0===e?(t.getPixelForTick(1)-i)/2:(i-t.getPixelForTick(e-1))/2),i}var r=t(25),o=t(26),s=t(45),l=t(34);r._set("scale",{display:!0,position:"left",offset:!1,gridLines:{display:!0,color:"rgba(0, 0, 0, 0.1)",lineWidth:1,drawBorder:!0,drawOnChartArea:!0,drawTicks:!0,tickMarkLength:10,zeroLineWidth:1,zeroLineColor:"rgba(0,0,0,0.25)",zeroLineBorderDash:[],zeroLineBorderDashOffset:0,offsetGridLines:!1,borderDash:[],borderDashOffset:0},scaleLabel:{display:!1,labelString:"",lineHeight:1.2,padding:{top:4,bottom:4}},ticks:{beginAtZero:!1,minRotation:0,maxRotation:50,mirror:!1,padding:0,reverse:!1,display:!0,autoSkip:!0,autoSkipPadding:0,labelOffset:0,callback:l.formatters.values,minor:{},major:{}}}),e.exports=function(t){function e(t,e,n){return s.isArray(e)?s.longestText(t,n,e):t.measureText(e).width}function n(t){var e=s.valueOrDefault,n=r.global,i=e(t.fontSize,n.defaultFontSize),a=e(t.fontStyle,n.defaultFontStyle),o=e(t.fontFamily,n.defaultFontFamily);return{size:i,style:a,family:o,font:s.fontString(i,a,o)}}function l(t){return s.options.toLineHeight(s.valueOrDefault(t.lineHeight,1.2),s.valueOrDefault(t.fontSize,r.global.defaultFontSize))}t.Scale=o.extend({getPadding:function(){var t=this;return{left:t.paddingLeft||0,top:t.paddingTop||0,right:t.paddingRight||0,bottom:t.paddingBottom||0}},getTicks:function(){return this._ticks},mergeTicksOptions:function(){var t=this.options.ticks;!1===t.minor&&(t.minor={display:!1}),!1===t.major&&(t.major={display:!1});for(var e in t)"major"!==e&&"minor"!==e&&(void 0===t.minor[e]&&(t.minor[e]=t[e]),void 0===t.major[e]&&(t.major[e]=t[e]))},beforeUpdate:function(){s.callback(this.options.beforeUpdate,[this])},update:function(t,e,n){var i,a,r,o,l,u,d=this;for(d.beforeUpdate(),d.maxWidth=t,d.maxHeight=e,d.margins=s.extend({left:0,right:0,top:0,bottom:0},n),d.longestTextCache=d.longestTextCache||{},d.beforeSetDimensions(),d.setDimensions(),d.afterSetDimensions(),d.beforeDataLimits(),d.determineDataLimits(),d.afterDataLimits(),d.beforeBuildTicks(),l=d.buildTicks()||[],d.afterBuildTicks(),d.beforeTickToLabelConversion(),r=d.convertTicksToLabels(l)||d.ticks,d.afterTickToLabelConversion(),d.ticks=r,i=0,a=r.length;i<a;++i)o=r[i],(u=l[i])?u.label=o:l.push(u={label:o,major:!1});return d._ticks=l,d.beforeCalculateTickRotation(),d.calculateTickRotation(),d.afterCalculateTickRotation(),d.beforeFit(),d.fit(),d.afterFit(),d.afterUpdate(),d.minSize},afterUpdate:function(){s.callback(this.options.afterUpdate,[this])},beforeSetDimensions:function(){s.callback(this.options.beforeSetDimensions,[this])},setDimensions:function(){var t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0},afterSetDimensions:function(){s.callback(this.options.afterSetDimensions,[this])},beforeDataLimits:function(){s.callback(this.options.beforeDataLimits,[this])},determineDataLimits:s.noop,afterDataLimits:function(){s.callback(this.options.afterDataLimits,[this])},beforeBuildTicks:function(){s.callback(this.options.beforeBuildTicks,[this])},buildTicks:s.noop,afterBuildTicks:function(){s.callback(this.options.afterBuildTicks,[this])},beforeTickToLabelConversion:function(){s.callback(this.options.beforeTickToLabelConversion,[this])},convertTicksToLabels:function(){var t=this,e=t.options.ticks;t.ticks=t.ticks.map(e.userCallback||e.callback,this)},afterTickToLabelConversion:function(){s.callback(this.options.afterTickToLabelConversion,[this])},beforeCalculateTickRotation:function(){s.callback(this.options.beforeCalculateTickRotation,[this])},calculateTickRotation:function(){var t=this,e=t.ctx,a=t.options.ticks,r=i(t._ticks),o=n(a);e.font=o.font;var l=a.minRotation||0;if(r.length&&t.options.display&&t.isHorizontal())for(var u,d=s.longestText(e,o.font,r,t.longestTextCache),c=d,h=t.getPixelForTick(1)-t.getPixelForTick(0)-6;c>h&&l<a.maxRotation;){var f=s.toRadians(l);if(u=Math.cos(f),Math.sin(f)*d>t.maxHeight){l--;break}l++,c=u*d}t.labelRotation=l},afterCalculateTickRotation:function(){s.callback(this.options.afterCalculateTickRotation,[this])},beforeFit:function(){s.callback(this.options.beforeFit,[this])},fit:function(){var t=this,a=t.minSize={width:0,height:0},r=i(t._ticks),o=t.options,u=o.ticks,d=o.scaleLabel,c=o.gridLines,h=o.display,f=t.isHorizontal(),g=n(u),m=o.gridLines.tickMarkLength;if(a.width=f?t.isFullWidth()?t.maxWidth-t.margins.left-t.margins.right:t.maxWidth:h&&c.drawTicks?m:0,a.height=f?h&&c.drawTicks?m:0:t.maxHeight,d.display&&h){var p=l(d)+s.options.toPadding(d.padding).height;f?a.height+=p:a.width+=p}if(u.display&&h){var v=s.longestText(t.ctx,g.font,r,t.longestTextCache),y=s.numberOfLabelLines(r),b=.5*g.size,x=t.options.ticks.padding;if(f){t.longestLabelWidth=v;var _=s.toRadians(t.labelRotation),k=Math.cos(_),w=Math.sin(_)*v+g.size*y+b*(y-1)+b;a.height=Math.min(t.maxHeight,a.height+w+x),t.ctx.font=g.font;var M=e(t.ctx,r[0],g.font),S=e(t.ctx,r[r.length-1],g.font);0!==t.labelRotation?(t.paddingLeft="bottom"===o.position?k*M+3:k*b+3,t.paddingRight="bottom"===o.position?k*b+3:k*S+3):(t.paddingLeft=M/2+3,t.paddingRight=S/2+3)}else u.mirror?v=0:v+=x+b,a.width=Math.min(t.maxWidth,a.width+v),t.paddingTop=g.size/2,t.paddingBottom=g.size/2}t.handleMargins(),t.width=a.width,t.height=a.height},handleMargins:function(){var t=this;t.margins&&(t.paddingLeft=Math.max(t.paddingLeft-t.margins.left,0),t.paddingTop=Math.max(t.paddingTop-t.margins.top,0),t.paddingRight=Math.max(t.paddingRight-t.margins.right,0),t.paddingBottom=Math.max(t.paddingBottom-t.margins.bottom,0))},afterFit:function(){s.callback(this.options.afterFit,[this])},isHorizontal:function(){return"top"===this.options.position||"bottom"===this.options.position},isFullWidth:function(){return this.options.fullWidth},getRightValue:function(t){if(s.isNullOrUndef(t))return NaN;if("number"==typeof t&&!isFinite(t))return NaN;if(t)if(this.isHorizontal()){if(void 0!==t.x)return this.getRightValue(t.x)}else if(void 0!==t.y)return this.getRightValue(t.y);return t},getLabelForIndex:s.noop,getPixelForValue:s.noop,getValueForPixel:s.noop,getPixelForTick:function(t){var e=this,n=e.options.offset;if(e.isHorizontal()){var i=(e.width-(e.paddingLeft+e.paddingRight))/Math.max(e._ticks.length-(n?0:1),1),a=i*t+e.paddingLeft;n&&(a+=i/2);var r=e.left+Math.round(a);return r+=e.isFullWidth()?e.margins.left:0}var o=e.height-(e.paddingTop+e.paddingBottom);return e.top+t*(o/(e._ticks.length-1))},getPixelForDecimal:function(t){var e=this;if(e.isHorizontal()){var n=(e.width-(e.paddingLeft+e.paddingRight))*t+e.paddingLeft,i=e.left+Math.round(n);return i+=e.isFullWidth()?e.margins.left:0}return e.top+t*e.height},getBasePixel:function(){return this.getPixelForValue(this.getBaseValue())},getBaseValue:function(){var t=this,e=t.min,n=t.max;return t.beginAtZero?0:e<0&&n<0?n:e>0&&n>0?e:0},_autoSkip:function(t){var e,n,i,a,r=this,o=r.isHorizontal(),l=r.options.ticks.minor,u=t.length,d=s.toRadians(r.labelRotation),c=Math.cos(d),h=r.longestLabelWidth*c,f=[];for(l.maxTicksLimit&&(a=l.maxTicksLimit),o&&(e=!1,(h+l.autoSkipPadding)*u>r.width-(r.paddingLeft+r.paddingRight)&&(e=1+Math.floor((h+l.autoSkipPadding)*u/(r.width-(r.paddingLeft+r.paddingRight)))),a&&u>a&&(e=Math.max(e,Math.floor(u/a)))),n=0;n<u;n++)i=t[n],(e>1&&n%e>0||n%e==0&&n+e>=u)&&n!==u-1&&delete i.label,f.push(i);return f},draw:function(t){var e=this,i=e.options;if(i.display){var o=e.ctx,u=r.global,d=i.ticks.minor,c=i.ticks.major||d,h=i.gridLines,f=i.scaleLabel,g=0!==e.labelRotation,m=e.isHorizontal(),p=d.autoSkip?e._autoSkip(e.getTicks()):e.getTicks(),v=s.valueOrDefault(d.fontColor,u.defaultFontColor),y=n(d),b=s.valueOrDefault(c.fontColor,u.defaultFontColor),x=n(c),_=h.drawTicks?h.tickMarkLength:0,k=s.valueOrDefault(f.fontColor,u.defaultFontColor),w=n(f),M=s.options.toPadding(f.padding),S=s.toRadians(e.labelRotation),D=[],C="right"===i.position?e.left:e.right-_,P="right"===i.position?e.left+_:e.right,T="bottom"===i.position?e.top:e.bottom-_,A="bottom"===i.position?e.top+_:e.bottom;if(s.each(p,function(n,r){if(!s.isNullOrUndef(n.label)){var o,l,c,f,v=n.label;r===e.zeroLineIndex&&i.offset===h.offsetGridLines?(o=h.zeroLineWidth,l=h.zeroLineColor,c=h.zeroLineBorderDash,f=h.zeroLineBorderDashOffset):(o=s.valueAtIndexOrDefault(h.lineWidth,r),l=s.valueAtIndexOrDefault(h.color,r),c=s.valueOrDefault(h.borderDash,u.borderDash),f=s.valueOrDefault(h.borderDashOffset,u.borderDashOffset));var y,b,x,k,w,M,I,O,F,R,L="middle",W="middle",Y=d.padding;if(m){var N=_+Y;"bottom"===i.position?(W=g?"middle":"top",L=g?"right":"center",R=e.top+N):(W=g?"middle":"bottom",L=g?"left":"center",R=e.bottom-N);var z=a(e,r,h.offsetGridLines&&p.length>1);z<e.left&&(l="rgba(0,0,0,0)"),z+=s.aliasPixel(o),F=e.getPixelForTick(r)+d.labelOffset,y=x=w=I=z,b=T,k=A,M=t.top,O=t.bottom}else{var B,V="left"===i.position;d.mirror?(L=V?"left":"right",B=Y):(L=V?"right":"left",B=_+Y),F=V?e.right-B:e.left+B;var H=a(e,r,h.offsetGridLines&&p.length>1);H<e.top&&(l="rgba(0,0,0,0)"),H+=s.aliasPixel(o),R=e.getPixelForTick(r)+d.labelOffset,y=C,x=P,w=t.left,I=t.right,b=k=M=O=H}D.push({tx1:y,ty1:b,tx2:x,ty2:k,x1:w,y1:M,x2:I,y2:O,labelX:F,labelY:R,glWidth:o,glColor:l,glBorderDash:c,glBorderDashOffset:f,rotation:-1*S,label:v,major:n.major,textBaseline:W,textAlign:L})}}),s.each(D,function(t){if(h.display&&(o.save(),o.lineWidth=t.glWidth,o.strokeStyle=t.glColor,o.setLineDash&&(o.setLineDash(t.glBorderDash),o.lineDashOffset=t.glBorderDashOffset),o.beginPath(),h.drawTicks&&(o.moveTo(t.tx1,t.ty1),o.lineTo(t.tx2,t.ty2)),h.drawOnChartArea&&(o.moveTo(t.x1,t.y1),o.lineTo(t.x2,t.y2)),o.stroke(),o.restore()),d.display){o.save(),o.translate(t.labelX,t.labelY),o.rotate(t.rotation),o.font=t.major?x.font:y.font,o.fillStyle=t.major?b:v,o.textBaseline=t.textBaseline,o.textAlign=t.textAlign;var e=t.label;if(s.isArray(e))for(var n=0,i=0;n<e.length;++n)o.fillText(""+e[n],0,i),i+=1.5*y.size;else o.fillText(e,0,0);o.restore()}}),f.display){var I,O,F=0,R=l(f)/2;if(m)I=e.left+(e.right-e.left)/2,O="bottom"===i.position?e.bottom-R-M.bottom:e.top+R+M.top;else{var L="left"===i.position;I=L?e.left+R+M.top:e.right-R-M.top,O=e.top+(e.bottom-e.top)/2,F=L?-.5*Math.PI:.5*Math.PI}o.save(),o.translate(I,O),o.rotate(F),o.textAlign="center",o.textBaseline="middle",o.fillStyle=k,o.font=w.font,o.fillText(f.labelString,0,0),o.restore()}if(h.drawBorder){o.lineWidth=s.valueAtIndexOrDefault(h.lineWidth,0),o.strokeStyle=s.valueAtIndexOrDefault(h.color,0);var W=e.left,Y=e.right,N=e.top,z=e.bottom,B=s.aliasPixel(o.lineWidth);m?(N=z="top"===i.position?e.bottom:e.top,N+=B,z+=B):(W=Y="left"===i.position?e.right:e.left,W+=B,Y+=B),o.beginPath(),o.moveTo(W,N),o.lineTo(Y,z),o.stroke()}}}})}},{25:25,26:26,34:34,45:45}],33:[function(t,e,n){"use strict";var i=t(25),a=t(45);e.exports=function(t){t.scaleService={constructors:{},defaults:{},registerScaleType:function(t,e,n){this.constructors[t]=e,this.defaults[t]=a.clone(n)},getScaleConstructor:function(t){return this.constructors.hasOwnProperty(t)?this.constructors[t]:void 0},getScaleDefaults:function(t){return this.defaults.hasOwnProperty(t)?a.merge({},[i.scale,this.defaults[t]]):{}},updateScaleDefaults:function(t,e){var n=this;n.defaults.hasOwnProperty(t)&&(n.defaults[t]=a.extend(n.defaults[t],e))},addScalesToLayout:function(e){a.each(e.scales,function(n){n.fullWidth=n.options.fullWidth,n.position=n.options.position,n.weight=n.options.weight,t.layoutService.addBox(e,n)})}}}},{25:25,45:45}],34:[function(t,e,n){"use strict";var i=t(45);e.exports={generators:{linear:function(t,e){var n,a=[];if(t.stepSize&&t.stepSize>0)n=t.stepSize;else{var r=i.niceNum(e.max-e.min,!1);n=i.niceNum(r/(t.maxTicks-1),!0)}var o=Math.floor(e.min/n)*n,s=Math.ceil(e.max/n)*n;t.min&&t.max&&t.stepSize&&i.almostWhole((t.max-t.min)/t.stepSize,n/1e3)&&(o=t.min,s=t.max);var l=(s-o)/n;l=i.almostEquals(l,Math.round(l),n/1e3)?Math.round(l):Math.ceil(l),a.push(void 0!==t.min?t.min:o);for(var u=1;u<l;++u)a.push(o+u*n);return a.push(void 0!==t.max?t.max:s),a},logarithmic:function(t,e){var n,a,r=[],o=i.valueOrDefault,s=o(t.min,Math.pow(10,Math.floor(i.log10(e.min)))),l=Math.floor(i.log10(e.max)),u=Math.ceil(e.max/Math.pow(10,l));0===s?(n=Math.floor(i.log10(e.minNotZero)),a=Math.floor(e.minNotZero/Math.pow(10,n)),r.push(s),s=a*Math.pow(10,n)):(n=Math.floor(i.log10(s)),a=Math.floor(s/Math.pow(10,n)));do{r.push(s),10===++a&&(a=1,++n),s=a*Math.pow(10,n)}while(n<l||n===l&&a<u);var d=o(t.max,s);return r.push(d),r}},formatters:{values:function(t){return i.isArray(t)?t:""+t},linear:function(t,e,n){var a=n.length>3?n[2]-n[1]:n[1]-n[0];Math.abs(a)>1&&t!==Math.floor(t)&&(a=t-Math.floor(t));var r=i.log10(Math.abs(a)),o="";if(0!==t){var s=-1*Math.floor(r);s=Math.max(Math.min(s,20),0),o=t.toFixed(s)}else o="0";return o},logarithmic:function(t,e,n){var a=t/Math.pow(10,Math.floor(i.log10(t)));return 0===t?"0":1===a||2===a||5===a||0===e||e===n.length-1?t.toExponential():""}}}},{45:45}],35:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45);i._set("global",{tooltips:{enabled:!0,custom:null,mode:"nearest",position:"average",intersect:!0,backgroundColor:"rgba(0,0,0,0.8)",titleFontStyle:"bold",titleSpacing:2,titleMarginBottom:6,titleFontColor:"#fff",titleAlign:"left",bodySpacing:2,bodyFontColor:"#fff",bodyAlign:"left",footerFontStyle:"bold",footerSpacing:2,footerMarginTop:6,footerFontColor:"#fff",footerAlign:"left",yPadding:6,xPadding:6,caretPadding:2,caretSize:5,cornerRadius:6,multiKeyBackground:"#fff",displayColors:!0,borderColor:"rgba(0,0,0,0)",borderWidth:0,callbacks:{beforeTitle:r.noop,title:function(t,e){var n="",i=e.labels,a=i?i.length:0;if(t.length>0){var r=t[0];r.xLabel?n=r.xLabel:a>0&&r.index<a&&(n=i[r.index])}return n},afterTitle:r.noop,beforeBody:r.noop,beforeLabel:r.noop,label:function(t,e){var n=e.datasets[t.datasetIndex].label||"";return n&&(n+=": "),n+=t.yLabel},labelColor:function(t,e){var n=e.getDatasetMeta(t.datasetIndex).data[t.index]._view;return{borderColor:n.borderColor,backgroundColor:n.backgroundColor}},labelTextColor:function(){return this._options.bodyFontColor},afterLabel:r.noop,afterBody:r.noop,beforeFooter:r.noop,footer:r.noop,afterFooter:r.noop}}}),e.exports=function(t){function e(t,e){var n=r.color(t);return n.alpha(e*n.alpha()).rgbaString()}function n(t,e){return e&&(r.isArray(e)?Array.prototype.push.apply(t,e):t.push(e)),t}function o(t){var e=t._xScale,n=t._yScale||t._scale,i=t._index,a=t._datasetIndex;return{xLabel:e?e.getLabelForIndex(i,a):"",yLabel:n?n.getLabelForIndex(i,a):"",index:i,datasetIndex:a,x:t._model.x,y:t._model.y}}function s(t){var e=i.global,n=r.valueOrDefault;return{xPadding:t.xPadding,yPadding:t.yPadding,xAlign:t.xAlign,yAlign:t.yAlign,bodyFontColor:t.bodyFontColor,_bodyFontFamily:n(t.bodyFontFamily,e.defaultFontFamily),_bodyFontStyle:n(t.bodyFontStyle,e.defaultFontStyle),_bodyAlign:t.bodyAlign,bodyFontSize:n(t.bodyFontSize,e.defaultFontSize),bodySpacing:t.bodySpacing,titleFontColor:t.titleFontColor,_titleFontFamily:n(t.titleFontFamily,e.defaultFontFamily),_titleFontStyle:n(t.titleFontStyle,e.defaultFontStyle),titleFontSize:n(t.titleFontSize,e.defaultFontSize),_titleAlign:t.titleAlign,titleSpacing:t.titleSpacing,titleMarginBottom:t.titleMarginBottom,footerFontColor:t.footerFontColor,_footerFontFamily:n(t.footerFontFamily,e.defaultFontFamily),_footerFontStyle:n(t.footerFontStyle,e.defaultFontStyle),footerFontSize:n(t.footerFontSize,e.defaultFontSize),_footerAlign:t.footerAlign,footerSpacing:t.footerSpacing,footerMarginTop:t.footerMarginTop,caretSize:t.caretSize,cornerRadius:t.cornerRadius,backgroundColor:t.backgroundColor,opacity:0,legendColorBackground:t.multiKeyBackground,displayColors:t.displayColors,borderColor:t.borderColor,borderWidth:t.borderWidth}}function l(t,e){var n=t._chart.ctx,i=2*e.yPadding,a=0,o=e.body,s=o.reduce(function(t,e){return t+e.before.length+e.lines.length+e.after.length},0);s+=e.beforeBody.length+e.afterBody.length;var l=e.title.length,u=e.footer.length,d=e.titleFontSize,c=e.bodyFontSize,h=e.footerFontSize;i+=l*d,i+=l?(l-1)*e.titleSpacing:0,i+=l?e.titleMarginBottom:0,i+=s*c,i+=s?(s-1)*e.bodySpacing:0,i+=u?e.footerMarginTop:0,i+=u*h,i+=u?(u-1)*e.footerSpacing:0;var f=0,g=function(t){a=Math.max(a,n.measureText(t).width+f)};return n.font=r.fontString(d,e._titleFontStyle,e._titleFontFamily),r.each(e.title,g),n.font=r.fontString(c,e._bodyFontStyle,e._bodyFontFamily),r.each(e.beforeBody.concat(e.afterBody),g),f=e.displayColors?c+2:0,r.each(o,function(t){r.each(t.before,g),r.each(t.lines,g),r.each(t.after,g)}),f=0,n.font=r.fontString(h,e._footerFontStyle,e._footerFontFamily),r.each(e.footer,g),a+=2*e.xPadding,{width:a,height:i}}function u(t,e){var n=t._model,i=t._chart,a=t._chart.chartArea,r="center",o="center";n.y<e.height?o="top":n.y>i.height-e.height&&(o="bottom");var s,l,u,d,c,h=(a.left+a.right)/2,f=(a.top+a.bottom)/2;"center"===o?(s=function(t){return t<=h},l=function(t){return t>h}):(s=function(t){return t<=e.width/2},l=function(t){return t>=i.width-e.width/2}),u=function(t){return t+e.width>i.width},d=function(t){return t-e.width<0},c=function(t){return t<=f?"top":"bottom"},s(n.x)?(r="left",u(n.x)&&(r="center",o=c(n.y))):l(n.x)&&(r="right",d(n.x)&&(r="center",o=c(n.y)));var g=t._options;return{xAlign:g.xAlign?g.xAlign:r,yAlign:g.yAlign?g.yAlign:o}}function d(t,e,n){var i=t.x,a=t.y,r=t.caretSize,o=t.caretPadding,s=t.cornerRadius,l=n.xAlign,u=n.yAlign,d=r+o,c=s+o;return"right"===l?i-=e.width:"center"===l&&(i-=e.width/2),"top"===u?a+=d:a-="bottom"===u?e.height+d:e.height/2,"center"===u?"left"===l?i+=d:"right"===l&&(i-=d):"left"===l?i-=c:"right"===l&&(i+=c),{x:i,y:a}}t.Tooltip=a.extend({initialize:function(){this._model=s(this._options),this._lastActive=[]},getTitle:function(){var t=this,e=t._options.callbacks,i=e.beforeTitle.apply(t,arguments),a=e.title.apply(t,arguments),r=e.afterTitle.apply(t,arguments),o=[];return o=n(o,i),o=n(o,a),o=n(o,r)},getBeforeBody:function(){var t=this._options.callbacks.beforeBody.apply(this,arguments);return r.isArray(t)?t:void 0!==t?[t]:[]},getBody:function(t,e){var i=this,a=i._options.callbacks,o=[];return r.each(t,function(t){var r={before:[],lines:[],after:[]};n(r.before,a.beforeLabel.call(i,t,e)),n(r.lines,a.label.call(i,t,e)),n(r.after,a.afterLabel.call(i,t,e)),o.push(r)}),o},getAfterBody:function(){var t=this._options.callbacks.afterBody.apply(this,arguments);return r.isArray(t)?t:void 0!==t?[t]:[]},getFooter:function(){var t=this,e=t._options.callbacks,i=e.beforeFooter.apply(t,arguments),a=e.footer.apply(t,arguments),r=e.afterFooter.apply(t,arguments),o=[];return o=n(o,i),o=n(o,a),o=n(o,r)},update:function(e){var n,i,a=this,c=a._options,h=a._model,f=a._model=s(c),g=a._active,m=a._data,p={xAlign:h.xAlign,yAlign:h.yAlign},v={x:h.x,y:h.y},y={width:h.width,height:h.height},b={x:h.caretX,y:h.caretY};if(g.length){f.opacity=1;var x=[],_=[];b=t.Tooltip.positioners[c.position].call(a,g,a._eventPosition);var k=[];for(n=0,i=g.length;n<i;++n)k.push(o(g[n]));c.filter&&(k=k.filter(function(t){return c.filter(t,m)})),c.itemSort&&(k=k.sort(function(t,e){return c.itemSort(t,e,m)})),r.each(k,function(t){x.push(c.callbacks.labelColor.call(a,t,a._chart)),_.push(c.callbacks.labelTextColor.call(a,t,a._chart))}),f.title=a.getTitle(k,m),f.beforeBody=a.getBeforeBody(k,m),f.body=a.getBody(k,m),f.afterBody=a.getAfterBody(k,m),f.footer=a.getFooter(k,m),f.x=Math.round(b.x),f.y=Math.round(b.y),f.caretPadding=c.caretPadding,f.labelColors=x,f.labelTextColors=_,f.dataPoints=k,v=d(f,y=l(this,f),p=u(this,y))}else f.opacity=0;return f.xAlign=p.xAlign,f.yAlign=p.yAlign,f.x=v.x,f.y=v.y,f.width=y.width,f.height=y.height,f.caretX=b.x,f.caretY=b.y,a._model=f,e&&c.custom&&c.custom.call(a,f),a},drawCaret:function(t,e){var n=this._chart.ctx,i=this._view,a=this.getCaretPosition(t,e,i);n.lineTo(a.x1,a.y1),n.lineTo(a.x2,a.y2),n.lineTo(a.x3,a.y3)},getCaretPosition:function(t,e,n){var i,a,r,o,s,l,u=n.caretSize,d=n.cornerRadius,c=n.xAlign,h=n.yAlign,f=t.x,g=t.y,m=e.width,p=e.height;if("center"===h)s=g+p/2,"left"===c?(a=(i=f)-u,r=i,o=s+u,l=s-u):(a=(i=f+m)+u,r=i,o=s-u,l=s+u);else if("left"===c?(i=(a=f+d+u)-u,r=a+u):"right"===c?(i=(a=f+m-d-u)-u,r=a+u):(i=(a=f+m/2)-u,r=a+u),"top"===h)s=(o=g)-u,l=o;else{s=(o=g+p)+u,l=o;var v=r;r=i,i=v}return{x1:i,x2:a,x3:r,y1:o,y2:s,y3:l}},drawTitle:function(t,n,i,a){var o=n.title;if(o.length){i.textAlign=n._titleAlign,i.textBaseline="top";var s=n.titleFontSize,l=n.titleSpacing;i.fillStyle=e(n.titleFontColor,a),i.font=r.fontString(s,n._titleFontStyle,n._titleFontFamily);var u,d;for(u=0,d=o.length;u<d;++u)i.fillText(o[u],t.x,t.y),t.y+=s+l,u+1===o.length&&(t.y+=n.titleMarginBottom-l)}},drawBody:function(t,n,i,a){var o=n.bodyFontSize,s=n.bodySpacing,l=n.body;i.textAlign=n._bodyAlign,i.textBaseline="top",i.font=r.fontString(o,n._bodyFontStyle,n._bodyFontFamily);var u=0,d=function(e){i.fillText(e,t.x+u,t.y),t.y+=o+s};i.fillStyle=e(n.bodyFontColor,a),r.each(n.beforeBody,d);var c=n.displayColors;u=c?o+2:0,r.each(l,function(s,l){var u=e(n.labelTextColors[l],a);i.fillStyle=u,r.each(s.before,d),r.each(s.lines,function(r){c&&(i.fillStyle=e(n.legendColorBackground,a),i.fillRect(t.x,t.y,o,o),i.lineWidth=1,i.strokeStyle=e(n.labelColors[l].borderColor,a),i.strokeRect(t.x,t.y,o,o),i.fillStyle=e(n.labelColors[l].backgroundColor,a),i.fillRect(t.x+1,t.y+1,o-2,o-2),i.fillStyle=u),d(r)}),r.each(s.after,d)}),u=0,r.each(n.afterBody,d),t.y-=s},drawFooter:function(t,n,i,a){var o=n.footer;o.length&&(t.y+=n.footerMarginTop,i.textAlign=n._footerAlign,i.textBaseline="top",i.fillStyle=e(n.footerFontColor,a),i.font=r.fontString(n.footerFontSize,n._footerFontStyle,n._footerFontFamily),r.each(o,function(e){i.fillText(e,t.x,t.y),t.y+=n.footerFontSize+n.footerSpacing}))},drawBackground:function(t,n,i,a,r){i.fillStyle=e(n.backgroundColor,r),i.strokeStyle=e(n.borderColor,r),i.lineWidth=n.borderWidth;var o=n.xAlign,s=n.yAlign,l=t.x,u=t.y,d=a.width,c=a.height,h=n.cornerRadius;i.beginPath(),i.moveTo(l+h,u),"top"===s&&this.drawCaret(t,a),i.lineTo(l+d-h,u),i.quadraticCurveTo(l+d,u,l+d,u+h),"center"===s&&"right"===o&&this.drawCaret(t,a),i.lineTo(l+d,u+c-h),i.quadraticCurveTo(l+d,u+c,l+d-h,u+c),"bottom"===s&&this.drawCaret(t,a),i.lineTo(l+h,u+c),i.quadraticCurveTo(l,u+c,l,u+c-h),"center"===s&&"left"===o&&this.drawCaret(t,a),i.lineTo(l,u+h),i.quadraticCurveTo(l,u,l+h,u),i.closePath(),i.fill(),n.borderWidth>0&&i.stroke()},draw:function(){var t=this._chart.ctx,e=this._view;if(0!==e.opacity){var n={width:e.width,height:e.height},i={x:e.x,y:e.y},a=Math.abs(e.opacity<.001)?0:e.opacity,r=e.title.length||e.beforeBody.length||e.body.length||e.afterBody.length||e.footer.length;this._options.enabled&&r&&(this.drawBackground(i,e,t,n,a),i.x+=e.xPadding,i.y+=e.yPadding,this.drawTitle(i,e,t,a),this.drawBody(i,e,t,a),this.drawFooter(i,e,t,a))}},handleEvent:function(t){var e=this,n=e._options,i=!1;if(e._lastActive=e._lastActive||[],"mouseout"===t.type?e._active=[]:e._active=e._chart.getElementsAtEventForMode(t,n.mode,n),!(i=!r.arrayEquals(e._active,e._lastActive)))return!1;if(e._lastActive=e._active,n.enabled||n.custom){e._eventPosition={x:t.x,y:t.y};var a=e._model;e.update(!0),e.pivot(),i|=a.x!==e._model.x||a.y!==e._model.y}return i}}),t.Tooltip.positioners={average:function(t){if(!t.length)return!1;var e,n,i=0,a=0,r=0;for(e=0,n=t.length;e<n;++e){var o=t[e];if(o&&o.hasValue()){var s=o.tooltipPosition();i+=s.x,a+=s.y,++r}}return{x:Math.round(i/r),y:Math.round(a/r)}},nearest:function(t,e){var n,i,a,o=e.x,s=e.y,l=Number.POSITIVE_INFINITY;for(n=0,i=t.length;n<i;++n){var u=t[n];if(u&&u.hasValue()){var d=u.getCenterPoint(),c=r.distanceBetweenPoints(e,d);c<l&&(l=c,a=u)}}if(a){var h=a.tooltipPosition();o=h.x,s=h.y}return{x:o,y:s}}}}},{25:25,26:26,45:45}],36:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45);i._set("global",{elements:{arc:{backgroundColor:i.global.defaultColor,borderColor:"#fff",borderWidth:2}}}),e.exports=a.extend({inLabelRange:function(t){var e=this._view;return!!e&&Math.pow(t-e.x,2)<Math.pow(e.radius+e.hoverRadius,2)},inRange:function(t,e){var n=this._view;if(n){for(var i=r.getAngleFromPoint(n,{x:t,y:e}),a=i.angle,o=i.distance,s=n.startAngle,l=n.endAngle;l<s;)l+=2*Math.PI;for(;a>l;)a-=2*Math.PI;for(;a<s;)a+=2*Math.PI;var u=a>=s&&a<=l,d=o>=n.innerRadius&&o<=n.outerRadius;return u&&d}return!1},getCenterPoint:function(){var t=this._view,e=(t.startAngle+t.endAngle)/2,n=(t.innerRadius+t.outerRadius)/2;return{x:t.x+Math.cos(e)*n,y:t.y+Math.sin(e)*n}},getArea:function(){var t=this._view;return Math.PI*((t.endAngle-t.startAngle)/(2*Math.PI))*(Math.pow(t.outerRadius,2)-Math.pow(t.innerRadius,2))},tooltipPosition:function(){var t=this._view,e=t.startAngle+(t.endAngle-t.startAngle)/2,n=(t.outerRadius-t.innerRadius)/2+t.innerRadius;return{x:t.x+Math.cos(e)*n,y:t.y+Math.sin(e)*n}},draw:function(){var t=this._chart.ctx,e=this._view,n=e.startAngle,i=e.endAngle;t.beginPath(),t.arc(e.x,e.y,e.outerRadius,n,i),t.arc(e.x,e.y,e.innerRadius,i,n,!0),t.closePath(),t.strokeStyle=e.borderColor,t.lineWidth=e.borderWidth,t.fillStyle=e.backgroundColor,t.fill(),t.lineJoin="bevel",e.borderWidth&&t.stroke()}})},{25:25,26:26,45:45}],37:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45),o=i.global;i._set("global",{elements:{line:{tension:.4,backgroundColor:o.defaultColor,borderWidth:3,borderColor:o.defaultColor,borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",capBezierPoints:!0,fill:!0}}}),e.exports=a.extend({draw:function(){var t,e,n,i,a=this,s=a._view,l=a._chart.ctx,u=s.spanGaps,d=a._children.slice(),c=o.elements.line,h=-1;for(a._loop&&d.length&&d.push(d[0]),l.save(),l.lineCap=s.borderCapStyle||c.borderCapStyle,l.setLineDash&&l.setLineDash(s.borderDash||c.borderDash),l.lineDashOffset=s.borderDashOffset||c.borderDashOffset,l.lineJoin=s.borderJoinStyle||c.borderJoinStyle,l.lineWidth=s.borderWidth||c.borderWidth,l.strokeStyle=s.borderColor||o.defaultColor,l.beginPath(),h=-1,t=0;t<d.length;++t)e=d[t],n=r.previousItem(d,t),i=e._view,0===t?i.skip||(l.moveTo(i.x,i.y),h=t):(n=-1===h?n:d[h],i.skip||(h!==t-1&&!u||-1===h?l.moveTo(i.x,i.y):r.canvas.lineTo(l,n._view,e._view),h=t));l.stroke(),l.restore()}})},{25:25,26:26,45:45}],38:[function(t,e,n){"use strict";function i(t){var e=this._view;return!!e&&Math.pow(t-e.x,2)<Math.pow(e.radius+e.hitRadius,2)}var a=t(25),r=t(26),o=t(45),s=a.global.defaultColor;a._set("global",{elements:{point:{radius:3,pointStyle:"circle",backgroundColor:s,borderColor:s,borderWidth:1,hitRadius:1,hoverRadius:4,hoverBorderWidth:1}}}),e.exports=r.extend({inRange:function(t,e){var n=this._view;return!!n&&Math.pow(t-n.x,2)+Math.pow(e-n.y,2)<Math.pow(n.hitRadius+n.radius,2)},inLabelRange:i,inXRange:i,inYRange:function(t){var e=this._view;return!!e&&Math.pow(t-e.y,2)<Math.pow(e.radius+e.hitRadius,2)},getCenterPoint:function(){var t=this._view;return{x:t.x,y:t.y}},getArea:function(){return Math.PI*Math.pow(this._view.radius,2)},tooltipPosition:function(){var t=this._view;return{x:t.x,y:t.y,padding:t.radius+t.borderWidth}},draw:function(t){var e=this._view,n=this._model,i=this._chart.ctx,r=e.pointStyle,l=e.radius,u=e.x,d=e.y,c=o.color,h=0;e.skip||(i.strokeStyle=e.borderColor||s,i.lineWidth=o.valueOrDefault(e.borderWidth,a.global.elements.point.borderWidth),i.fillStyle=e.backgroundColor||s,void 0!==t&&(n.x<t.left||1.01*t.right<n.x||n.y<t.top||1.01*t.bottom<n.y)&&(n.x<t.left?h=(u-n.x)/(t.left-n.x):1.01*t.right<n.x?h=(n.x-u)/(n.x-t.right):n.y<t.top?h=(d-n.y)/(t.top-n.y):1.01*t.bottom<n.y&&(h=(n.y-d)/(n.y-t.bottom)),h=Math.round(100*h)/100,i.strokeStyle=c(i.strokeStyle).alpha(h).rgbString(),i.fillStyle=c(i.fillStyle).alpha(h).rgbString()),o.canvas.drawPoint(i,r,l,u,d))}})},{25:25,26:26,45:45}],39:[function(t,e,n){"use strict";function i(t){return void 0!==t._view.width}function a(t){var e,n,a,r,o=t._view;if(i(t)){var s=o.width/2;e=o.x-s,n=o.x+s,a=Math.min(o.y,o.base),r=Math.max(o.y,o.base)}else{var l=o.height/2;e=Math.min(o.x,o.base),n=Math.max(o.x,o.base),a=o.y-l,r=o.y+l}return{left:e,top:a,right:n,bottom:r}}var r=t(25),o=t(26);r._set("global",{elements:{rectangle:{backgroundColor:r.global.defaultColor,borderColor:r.global.defaultColor,borderSkipped:"bottom",borderWidth:0}}}),e.exports=o.extend({draw:function(){function t(t){return v[(y+t)%4]}var e,n,i,a,r,o,s,l=this._chart.ctx,u=this._view,d=u.borderWidth;if(u.horizontal?(e=u.base,n=u.x,i=u.y-u.height/2,a=u.y+u.height/2,r=n>e?1:-1,o=1,s=u.borderSkipped||"left"):(e=u.x-u.width/2,n=u.x+u.width/2,i=u.y,r=1,o=(a=u.base)>i?1:-1,s=u.borderSkipped||"bottom"),d){var c=Math.min(Math.abs(e-n),Math.abs(i-a)),h=(d=d>c?c:d)/2,f=e+("left"!==s?h*r:0),g=n+("right"!==s?-h*r:0),m=i+("top"!==s?h*o:0),p=a+("bottom"!==s?-h*o:0);f!==g&&(i=m,a=p),m!==p&&(e=f,n=g)}l.beginPath(),l.fillStyle=u.backgroundColor,l.strokeStyle=u.borderColor,l.lineWidth=d;var v=[[e,a],[e,i],[n,i],[n,a]],y=["bottom","left","top","right"].indexOf(s,0);-1===y&&(y=0);var b=t(0);l.moveTo(b[0],b[1]);for(var x=1;x<4;x++)b=t(x),l.lineTo(b[0],b[1]);l.fill(),d&&l.stroke()},height:function(){var t=this._view;return t.base-t.y},inRange:function(t,e){var n=!1;if(this._view){var i=a(this);n=t>=i.left&&t<=i.right&&e>=i.top&&e<=i.bottom}return n},inLabelRange:function(t,e){var n=this;if(!n._view)return!1;var r=a(n);return i(n)?t>=r.left&&t<=r.right:e>=r.top&&e<=r.bottom},inXRange:function(t){var e=a(this);return t>=e.left&&t<=e.right},inYRange:function(t){var e=a(this);return t>=e.top&&t<=e.bottom},getCenterPoint:function(){var t,e,n=this._view;return i(this)?(t=n.x,e=(n.y+n.base)/2):(t=(n.x+n.base)/2,e=n.y),{x:t,y:e}},getArea:function(){var t=this._view;return t.width*Math.abs(t.y-t.base)},tooltipPosition:function(){var t=this._view;return{x:t.x,y:t.y}}})},{25:25,26:26}],40:[function(t,e,n){"use strict";e.exports={},e.exports.Arc=t(36),e.exports.Line=t(37),e.exports.Point=t(38),e.exports.Rectangle=t(39)},{36:36,37:37,38:38,39:39}],41:[function(t,e,n){"use strict";var i=t(42),n=e.exports={clear:function(t){t.ctx.clearRect(0,0,t.width,t.height)},roundedRect:function(t,e,n,i,a,r){if(r){var o=Math.min(r,i/2),s=Math.min(r,a/2);t.moveTo(e+o,n),t.lineTo(e+i-o,n),t.quadraticCurveTo(e+i,n,e+i,n+s),t.lineTo(e+i,n+a-s),t.quadraticCurveTo(e+i,n+a,e+i-o,n+a),t.lineTo(e+o,n+a),t.quadraticCurveTo(e,n+a,e,n+a-s),t.lineTo(e,n+s),t.quadraticCurveTo(e,n,e+o,n)}else t.rect(e,n,i,a)},drawPoint:function(t,e,n,i,a){var r,o,s,l,u,d;if(!e||"object"!=typeof e||"[object HTMLImageElement]"!==(r=e.toString())&&"[object HTMLCanvasElement]"!==r){if(!(isNaN(n)||n<=0)){switch(e){default:t.beginPath(),t.arc(i,a,n,0,2*Math.PI),t.closePath(),t.fill();break;case"triangle":t.beginPath(),u=(o=3*n/Math.sqrt(3))*Math.sqrt(3)/2,t.moveTo(i-o/2,a+u/3),t.lineTo(i+o/2,a+u/3),t.lineTo(i,a-2*u/3),t.closePath(),t.fill();break;case"rect":d=1/Math.SQRT2*n,t.beginPath(),t.fillRect(i-d,a-d,2*d,2*d),t.strokeRect(i-d,a-d,2*d,2*d);break;case"rectRounded":var c=n/Math.SQRT2,h=i-c,f=a-c,g=Math.SQRT2*n;t.beginPath(),this.roundedRect(t,h,f,g,g,n/2),t.closePath(),t.fill();break;case"rectRot":d=1/Math.SQRT2*n,t.beginPath(),t.moveTo(i-d,a),t.lineTo(i,a+d),t.lineTo(i+d,a),t.lineTo(i,a-d),t.closePath(),t.fill();break;case"cross":t.beginPath(),t.moveTo(i,a+n),t.lineTo(i,a-n),t.moveTo(i-n,a),t.lineTo(i+n,a),t.closePath();break;case"crossRot":t.beginPath(),s=Math.cos(Math.PI/4)*n,l=Math.sin(Math.PI/4)*n,t.moveTo(i-s,a-l),t.lineTo(i+s,a+l),t.moveTo(i-s,a+l),t.lineTo(i+s,a-l),t.closePath();break;case"star":t.beginPath(),t.moveTo(i,a+n),t.lineTo(i,a-n),t.moveTo(i-n,a),t.lineTo(i+n,a),s=Math.cos(Math.PI/4)*n,l=Math.sin(Math.PI/4)*n,t.moveTo(i-s,a-l),t.lineTo(i+s,a+l),t.moveTo(i-s,a+l),t.lineTo(i+s,a-l),t.closePath();break;case"line":t.beginPath(),t.moveTo(i-n,a),t.lineTo(i+n,a),t.closePath();break;case"dash":t.beginPath(),t.moveTo(i,a),t.lineTo(i+n,a),t.closePath()}t.stroke()}}else t.drawImage(e,i-e.width/2,a-e.height/2,e.width,e.height)},clipArea:function(t,e){t.save(),t.beginPath(),t.rect(e.left,e.top,e.right-e.left,e.bottom-e.top),t.clip()},unclipArea:function(t){t.restore()},lineTo:function(t,e,n,i){if(n.steppedLine)return"after"===n.steppedLine&&!i||"after"!==n.steppedLine&&i?t.lineTo(e.x,n.y):t.lineTo(n.x,e.y),void t.lineTo(n.x,n.y);n.tension?t.bezierCurveTo(i?e.controlPointPreviousX:e.controlPointNextX,i?e.controlPointPreviousY:e.controlPointNextY,i?n.controlPointNextX:n.controlPointPreviousX,i?n.controlPointNextY:n.controlPointPreviousY,n.x,n.y):t.lineTo(n.x,n.y)}};i.clear=n.clear,i.drawRoundedRectangle=function(t){t.beginPath(),n.roundedRect.apply(n,arguments),t.closePath()}},{42:42}],42:[function(t,e,n){"use strict";var i={noop:function(){},uid:function(){var t=0;return function(){return t++}}(),isNullOrUndef:function(t){return null===t||void 0===t},isArray:Array.isArray?Array.isArray:function(t){return"[object Array]"===Object.prototype.toString.call(t)},isObject:function(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)},valueOrDefault:function(t,e){return void 0===t?e:t},valueAtIndexOrDefault:function(t,e,n){return i.valueOrDefault(i.isArray(t)?t[e]:t,n)},callback:function(t,e,n){if(t&&"function"==typeof t.call)return t.apply(n,e)},each:function(t,e,n,a){var r,o,s;if(i.isArray(t))if(o=t.length,a)for(r=o-1;r>=0;r--)e.call(n,t[r],r);else for(r=0;r<o;r++)e.call(n,t[r],r);else if(i.isObject(t))for(o=(s=Object.keys(t)).length,r=0;r<o;r++)e.call(n,t[s[r]],s[r])},arrayEquals:function(t,e){var n,a,r,o;if(!t||!e||t.length!==e.length)return!1;for(n=0,a=t.length;n<a;++n)if(r=t[n],o=e[n],r instanceof Array&&o instanceof Array){if(!i.arrayEquals(r,o))return!1}else if(r!==o)return!1;return!0},clone:function(t){if(i.isArray(t))return t.map(i.clone);if(i.isObject(t)){for(var e={},n=Object.keys(t),a=n.length,r=0;r<a;++r)e[n[r]]=i.clone(t[n[r]]);return e}return t},_merger:function(t,e,n,a){var r=e[t],o=n[t];i.isObject(r)&&i.isObject(o)?i.merge(r,o,a):e[t]=i.clone(o)},_mergerIf:function(t,e,n){var a=e[t],r=n[t];i.isObject(a)&&i.isObject(r)?i.mergeIf(a,r):e.hasOwnProperty(t)||(e[t]=i.clone(r))},merge:function(t,e,n){var a,r,o,s,l,u=i.isArray(e)?e:[e],d=u.length;if(!i.isObject(t))return t;for(a=(n=n||{}).merger||i._merger,r=0;r<d;++r)if(e=u[r],i.isObject(e))for(l=0,s=(o=Object.keys(e)).length;l<s;++l)a(o[l],t,e,n);return t},mergeIf:function(t,e){return i.merge(t,e,{merger:i._mergerIf})},extend:function(t){for(var e=1,n=arguments.length;e<n;++e)i.each(arguments[e],function(e,n){t[n]=e});return t},inherits:function(t){var e=this,n=t&&t.hasOwnProperty("constructor")?t.constructor:function(){return e.apply(this,arguments)},a=function(){this.constructor=n};return a.prototype=e.prototype,n.prototype=new a,n.extend=i.inherits,t&&i.extend(n.prototype,t),n.__super__=e.prototype,n}};e.exports=i,i.callCallback=i.callback,i.indexOf=function(t,e,n){return Array.prototype.indexOf.call(t,e,n)},i.getValueOrDefault=i.valueOrDefault,i.getValueAtIndexOrDefault=i.valueAtIndexOrDefault},{}],43:[function(t,e,n){"use strict";var i=t(42),a={linear:function(t){return t},easeInQuad:function(t){return t*t},easeOutQuad:function(t){return-t*(t-2)},easeInOutQuad:function(t){return(t/=.5)<1?.5*t*t:-.5*(--t*(t-2)-1)},easeInCubic:function(t){return t*t*t},easeOutCubic:function(t){return(t-=1)*t*t+1},easeInOutCubic:function(t){return(t/=.5)<1?.5*t*t*t:.5*((t-=2)*t*t+2)},easeInQuart:function(t){return t*t*t*t},easeOutQuart:function(t){return-((t-=1)*t*t*t-1)},easeInOutQuart:function(t){return(t/=.5)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2)},easeInQuint:function(t){return t*t*t*t*t},easeOutQuint:function(t){return(t-=1)*t*t*t*t+1},easeInOutQuint:function(t){return(t/=.5)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2)},easeInSine:function(t){return 1-Math.cos(t*(Math.PI/2))},easeOutSine:function(t){return Math.sin(t*(Math.PI/2))},easeInOutSine:function(t){return-.5*(Math.cos(Math.PI*t)-1)},easeInExpo:function(t){return 0===t?0:Math.pow(2,10*(t-1))},easeOutExpo:function(t){return 1===t?1:1-Math.pow(2,-10*t)},easeInOutExpo:function(t){return 0===t?0:1===t?1:(t/=.5)<1?.5*Math.pow(2,10*(t-1)):.5*(2-Math.pow(2,-10*--t))},easeInCirc:function(t){return t>=1?t:-(Math.sqrt(1-t*t)-1)},easeOutCirc:function(t){return Math.sqrt(1-(t-=1)*t)},easeInOutCirc:function(t){return(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1)},easeInElastic:function(t){var e=1.70158,n=0,i=1;return 0===t?0:1===t?1:(n||(n=.3),i<1?(i=1,e=n/4):e=n/(2*Math.PI)*Math.asin(1/i),-i*Math.pow(2,10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/n))},easeOutElastic:function(t){var e=1.70158,n=0,i=1;return 0===t?0:1===t?1:(n||(n=.3),i<1?(i=1,e=n/4):e=n/(2*Math.PI)*Math.asin(1/i),i*Math.pow(2,-10*t)*Math.sin((t-e)*(2*Math.PI)/n)+1)},easeInOutElastic:function(t){var e=1.70158,n=0,i=1;return 0===t?0:2==(t/=.5)?1:(n||(n=.45),i<1?(i=1,e=n/4):e=n/(2*Math.PI)*Math.asin(1/i),t<1?i*Math.pow(2,10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/n)*-.5:i*Math.pow(2,-10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/n)*.5+1)},easeInBack:function(t){var e=1.70158;return t*t*((e+1)*t-e)},easeOutBack:function(t){var e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack:function(t){var e=1.70158;return(t/=.5)<1?t*t*((1+(e*=1.525))*t-e)*.5:.5*((t-=2)*t*((1+(e*=1.525))*t+e)+2)},easeInBounce:function(t){return 1-a.easeOutBounce(1-t)},easeOutBounce:function(t){return t<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375},easeInOutBounce:function(t){return t<.5?.5*a.easeInBounce(2*t):.5*a.easeOutBounce(2*t-1)+.5}};e.exports={effects:a},i.easingEffects=a},{42:42}],44:[function(t,e,n){"use strict";var i=t(42);e.exports={toLineHeight:function(t,e){var n=(""+t).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);if(!n||"normal"===n[1])return 1.2*e;switch(t=+n[2],n[3]){case"px":return t;case"%":t/=100}return e*t},toPadding:function(t){var e,n,a,r;return i.isObject(t)?(e=+t.top||0,n=+t.right||0,a=+t.bottom||0,r=+t.left||0):e=n=a=r=+t||0,{top:e,right:n,bottom:a,left:r,height:e+a,width:r+n}},resolve:function(t,e,n){var a,r,o;for(a=0,r=t.length;a<r;++a)if(void 0!==(o=t[a])&&(void 0!==e&&"function"==typeof o&&(o=o(e)),void 0!==n&&i.isArray(o)&&(o=o[n]),void 0!==o))return o}}},{42:42}],45:[function(t,e,n){"use strict";e.exports=t(42),e.exports.easing=t(43),e.exports.canvas=t(41),e.exports.options=t(44)},{41:41,42:42,43:43,44:44}],46:[function(t,e,n){e.exports={acquireContext:function(t){return t&&t.canvas&&(t=t.canvas),t&&t.getContext("2d")||null}}},{}],47:[function(t,e,n){"use strict";function i(t,e){var n=p.getStyle(t,e),i=n&&n.match(/^(\d+)(\.\d+)?px$/);return i?Number(i[1]):void 0}function a(t,e){var n=t.style,a=t.getAttribute("height"),r=t.getAttribute("width");if(t[v]={initial:{height:a,width:r,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||"block",null===r||""===r){var o=i(t,"width");void 0!==o&&(t.width=o)}if(null===a||""===a)if(""===t.style.height)t.height=t.width/(e.options.aspectRatio||2);else{var s=i(t,"height");void 0!==o&&(t.height=s)}return t}function r(t,e,n){t.addEventListener(e,n,w)}function o(t,e,n){t.removeEventListener(e,n,w)}function s(t,e,n,i,a){return{type:t,chart:e,native:a||null,x:void 0!==n?n:null,y:void 0!==i?i:null}}function l(t,e){var n=k[t.type]||t.type,i=p.getRelativePosition(t,e);return s(n,e,i.x,i.y,t)}function u(t,e){var n=!1,i=[];return function(){i=Array.prototype.slice.call(arguments),e=e||this,n||(n=!0,p.requestAnimFrame.call(window,function(){n=!1,t.apply(e,i)}))}}function d(t){var e=document.createElement("div"),n=y+"size-monitor",i="position:absolute;left:0;top:0;right:0;bottom:0;overflow:hidden;pointer-events:none;visibility:hidden;z-index:-1;";e.style.cssText=i,e.className=n,e.innerHTML='<div class="'+n+'-expand" style="'+i+'"><div style="position:absolute;width:1000000px;height:1000000px;left:0;top:0"></div></div><div class="'+n+'-shrink" style="'+i+'"><div style="position:absolute;width:200%;height:200%;left:0; top:0"></div></div>';var a=e.childNodes[0],o=e.childNodes[1];e._reset=function(){a.scrollLeft=1e6,a.scrollTop=1e6,o.scrollLeft=1e6,o.scrollTop=1e6};var s=function(){e._reset(),t()};return r(a,"scroll",s.bind(a,"expand")),r(o,"scroll",s.bind(o,"shrink")),e}function c(t,e){var n=t[v]||(t[v]={}),i=n.renderProxy=function(t){t.animationName===x&&e()};p.each(_,function(e){r(t,e,i)}),n.reflow=!!t.offsetParent,t.classList.add(b)}function h(t){var e=t[v]||{},n=e.renderProxy;n&&(p.each(_,function(e){o(t,e,n)}),delete e.renderProxy),t.classList.remove(b)}function f(t,e,n){var i=t[v]||(t[v]={}),a=i.resizer=d(u(function(){if(i.resizer)return e(s("resize",n))}));c(t,function(){if(i.resizer){var e=t.parentNode;e&&e!==a.parentNode&&e.insertBefore(a,e.firstChild),a._reset()}})}function g(t){var e=t[v]||{},n=e.resizer;delete e.resizer,h(t),n&&n.parentNode&&n.parentNode.removeChild(n)}function m(t,e){var n=t._style||document.createElement("style");t._style||(t._style=n,e="/* Chart.js */\n"+e,n.setAttribute("type","text/css"),document.getElementsByTagName("head")[0].appendChild(n)),n.appendChild(document.createTextNode(e))}var p=t(45),v="$chartjs",y="chartjs-",b=y+"render-monitor",x=y+"render-animation",_=["animationstart","webkitAnimationStart"],k={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},w=!!function(){var t=!1;try{var e=Object.defineProperty({},"passive",{get:function(){t=!0}});window.addEventListener("e",null,e)}catch(t){}return t}()&&{passive:!0};e.exports={_enabled:"undefined"!=typeof window&&"undefined"!=typeof document,initialize:function(){var t="from{opacity:0.99}to{opacity:1}";m(this,"@-webkit-keyframes "+x+"{"+t+"}@keyframes "+x+"{"+t+"}."+b+"{-webkit-animation:"+x+" 0.001s;animation:"+x+" 0.001s;}")},acquireContext:function(t,e){"string"==typeof t?t=document.getElementById(t):t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas);var n=t&&t.getContext&&t.getContext("2d");return n&&n.canvas===t?(a(t,e),n):null},releaseContext:function(t){var e=t.canvas;if(e[v]){var n=e[v].initial;["height","width"].forEach(function(t){var i=n[t];p.isNullOrUndef(i)?e.removeAttribute(t):e.setAttribute(t,i)}),p.each(n.style||{},function(t,n){e.style[n]=t}),e.width=e.width,delete e[v]}},addEventListener:function(t,e,n){var i=t.canvas;if("resize"!==e){var a=n[v]||(n[v]={});r(i,e,(a.proxies||(a.proxies={}))[t.id+"_"+e]=function(e){n(l(e,t))})}else f(i,n,t)},removeEventListener:function(t,e,n){var i=t.canvas;if("resize"!==e){var a=((n[v]||{}).proxies||{})[t.id+"_"+e];a&&o(i,e,a)}else g(i)}},p.addEvent=r,p.removeEvent=o},{45:45}],48:[function(t,e,n){"use strict";var i=t(45),a=t(46),r=t(47),o=r._enabled?r:a;e.exports=i.extend({initialize:function(){},acquireContext:function(){},releaseContext:function(){},addEventListener:function(){},removeEventListener:function(){}},o)},{45:45,46:46,47:47}],49:[function(t,e,n){"use strict";var i=t(25),a=t(40),r=t(45);i._set("global",{plugins:{filler:{propagate:!0}}}),e.exports=function(){function t(t,e,n){var i,a=t._model||{},r=a.fill;if(void 0===r&&(r=!!a.backgroundColor),!1===r||null===r)return!1;if(!0===r)return"origin";if(i=parseFloat(r,10),isFinite(i)&&Math.floor(i)===i)return"-"!==r[0]&&"+"!==r[0]||(i=e+i),!(i===e||i<0||i>=n)&&i;switch(r){case"bottom":return"start";case"top":return"end";case"zero":return"origin";case"origin":case"start":case"end":return r;default:return!1}}function e(t){var e,n=t.el._model||{},i=t.el._scale||{},a=t.fill,r=null;if(isFinite(a))return null;if("start"===a?r=void 0===n.scaleBottom?i.bottom:n.scaleBottom:"end"===a?r=void 0===n.scaleTop?i.top:n.scaleTop:void 0!==n.scaleZero?r=n.scaleZero:i.getBasePosition?r=i.getBasePosition():i.getBasePixel&&(r=i.getBasePixel()),void 0!==r&&null!==r){if(void 0!==r.x&&void 0!==r.y)return r;if("number"==typeof r&&isFinite(r))return e=i.isHorizontal(),{x:e?r:null,y:e?null:r}}return null}function n(t,e,n){var i,a=t[e].fill,r=[e];if(!n)return a;for(;!1!==a&&-1===r.indexOf(a);){if(!isFinite(a))return a;if(!(i=t[a]))return!1;if(i.visible)return a;r.push(a),a=i.fill}return!1}function o(t){var e=t.fill,n="dataset";return!1===e?null:(isFinite(e)||(n="boundary"),d[n](t))}function s(t){return t&&!t.skip}function l(t,e,n,i,a){var o;if(i&&a){for(t.moveTo(e[0].x,e[0].y),o=1;o<i;++o)r.canvas.lineTo(t,e[o-1],e[o]);for(t.lineTo(n[a-1].x,n[a-1].y),o=a-1;o>0;--o)r.canvas.lineTo(t,n[o],n[o-1],!0)}}function u(t,e,n,i,a,r){var o,u,d,c,h,f,g,m=e.length,p=i.spanGaps,v=[],y=[],b=0,x=0;for(t.beginPath(),o=0,u=m+!!r;o<u;++o)h=n(c=e[d=o%m]._view,d,i),f=s(c),g=s(h),f&&g?(b=v.push(c),x=y.push(h)):b&&x&&(p?(f&&v.push(c),g&&y.push(h)):(l(t,v,y,b,x),b=x=0,v=[],y=[]));l(t,v,y,b,x),t.closePath(),t.fillStyle=a,t.fill()}var d={dataset:function(t){var e=t.fill,n=t.chart,i=n.getDatasetMeta(e),a=i&&n.isDatasetVisible(e)&&i.dataset._children||[],r=a.length||0;return r?function(t,e){return e<r&&a[e]._view||null}:null},boundary:function(t){var e=t.boundary,n=e?e.x:null,i=e?e.y:null;return function(t){return{x:null===n?t.x:n,y:null===i?t.y:i}}}};return{id:"filler",afterDatasetsUpdate:function(i,r){var s,l,u,d,c=(i.data.datasets||[]).length,h=r.propagate,f=[];for(l=0;l<c;++l)d=null,(u=(s=i.getDatasetMeta(l)).dataset)&&u._model&&u instanceof a.Line&&(d={visible:i.isDatasetVisible(l),fill:t(u,l,c),chart:i,el:u}),s.$filler=d,f.push(d);for(l=0;l<c;++l)(d=f[l])&&(d.fill=n(f,l,h),d.boundary=e(d),d.mapper=o(d))},beforeDatasetDraw:function(t,e){var n=e.meta.$filler;if(n){var a=t.ctx,o=n.el,s=o._view,l=o._children||[],d=n.mapper,c=s.backgroundColor||i.global.defaultColor;d&&c&&l.length&&(r.canvas.clipArea(a,t.chartArea),u(a,l,d,s,c,o._loop),r.canvas.unclipArea(a))}}}}},{25:25,40:40,45:45}],50:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45);i._set("global",{legend:{display:!0,position:"top",fullWidth:!0,reverse:!1,weight:1e3,onClick:function(t,e){var n=e.datasetIndex,i=this.chart,a=i.getDatasetMeta(n);a.hidden=null===a.hidden?!i.data.datasets[n].hidden:null,i.update()},onHover:null,labels:{boxWidth:40,padding:10,generateLabels:function(t){var e=t.data;return r.isArray(e.datasets)?e.datasets.map(function(e,n){return{text:e.label,fillStyle:r.isArray(e.backgroundColor)?e.backgroundColor[0]:e.backgroundColor,hidden:!t.isDatasetVisible(n),lineCap:e.borderCapStyle,lineDash:e.borderDash,lineDashOffset:e.borderDashOffset,lineJoin:e.borderJoinStyle,lineWidth:e.borderWidth,strokeStyle:e.borderColor,pointStyle:e.pointStyle,datasetIndex:n}},this):[]}}},legendCallback:function(t){var e=[];e.push('<ul class="'+t.id+'-legend">');for(var n=0;n<t.data.datasets.length;n++)e.push('<li><span style="background-color:'+t.data.datasets[n].backgroundColor+'"></span>'),t.data.datasets[n].label&&e.push(t.data.datasets[n].label),e.push("</li>");return e.push("</ul>"),e.join("")}}),e.exports=function(t){function e(t,e){return t.usePointStyle?e*Math.SQRT2:t.boxWidth}function n(e,n){var i=new t.Legend({ctx:e.ctx,options:n,chart:e});o.configure(e,i,n),o.addBox(e,i),e.legend=i}var o=t.layoutService,s=r.noop;return t.Legend=a.extend({initialize:function(t){r.extend(this,t),this.legendHitBoxes=[],this.doughnutMode=!1},beforeUpdate:s,update:function(t,e,n){var i=this;return i.beforeUpdate(),i.maxWidth=t,i.maxHeight=e,i.margins=n,i.beforeSetDimensions(),i.setDimensions(),i.afterSetDimensions(),i.beforeBuildLabels(),i.buildLabels(),i.afterBuildLabels(),i.beforeFit(),i.fit(),i.afterFit(),i.afterUpdate(),i.minSize},afterUpdate:s,beforeSetDimensions:s,setDimensions:function(){var t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0,t.minSize={width:0,height:0}},afterSetDimensions:s,beforeBuildLabels:s,buildLabels:function(){var t=this,e=t.options.labels||{},n=r.callback(e.generateLabels,[t.chart],t)||[];e.filter&&(n=n.filter(function(n){return e.filter(n,t.chart.data)})),t.options.reverse&&n.reverse(),t.legendItems=n},afterBuildLabels:s,beforeFit:s,fit:function(){var t=this,n=t.options,a=n.labels,o=n.display,s=t.ctx,l=i.global,u=r.valueOrDefault,d=u(a.fontSize,l.defaultFontSize),c=u(a.fontStyle,l.defaultFontStyle),h=u(a.fontFamily,l.defaultFontFamily),f=r.fontString(d,c,h),g=t.legendHitBoxes=[],m=t.minSize,p=t.isHorizontal();if(p?(m.width=t.maxWidth,m.height=o?10:0):(m.width=o?10:0,m.height=t.maxHeight),o)if(s.font=f,p){var v=t.lineWidths=[0],y=t.legendItems.length?d+a.padding:0;s.textAlign="left",s.textBaseline="top",r.each(t.legendItems,function(n,i){var r=e(a,d)+d/2+s.measureText(n.text).width;v[v.length-1]+r+a.padding>=t.width&&(y+=d+a.padding,v[v.length]=t.left),g[i]={left:0,top:0,width:r,height:d},v[v.length-1]+=r+a.padding}),m.height+=y}else{var b=a.padding,x=t.columnWidths=[],_=a.padding,k=0,w=0,M=d+b;r.each(t.legendItems,function(t,n){var i=e(a,d)+d/2+s.measureText(t.text).width;w+M>m.height&&(_+=k+a.padding,x.push(k),k=0,w=0),k=Math.max(k,i),w+=M,g[n]={left:0,top:0,width:i,height:d}}),_+=k,x.push(k),m.width+=_}t.width=m.width,t.height=m.height},afterFit:s,isHorizontal:function(){return"top"===this.options.position||"bottom"===this.options.position},draw:function(){var t=this,n=t.options,a=n.labels,o=i.global,s=o.elements.line,l=t.width,u=t.lineWidths;if(n.display){var d,c=t.ctx,h=r.valueOrDefault,f=h(a.fontColor,o.defaultFontColor),g=h(a.fontSize,o.defaultFontSize),m=h(a.fontStyle,o.defaultFontStyle),p=h(a.fontFamily,o.defaultFontFamily),v=r.fontString(g,m,p);c.textAlign="left",c.textBaseline="middle",c.lineWidth=.5,c.strokeStyle=f,c.fillStyle=f,c.font=v;var y=e(a,g),b=t.legendHitBoxes,x=function(t,e,i){if(!(isNaN(y)||y<=0)){c.save(),c.fillStyle=h(i.fillStyle,o.defaultColor),c.lineCap=h(i.lineCap,s.borderCapStyle),c.lineDashOffset=h(i.lineDashOffset,s.borderDashOffset),c.lineJoin=h(i.lineJoin,s.borderJoinStyle),c.lineWidth=h(i.lineWidth,s.borderWidth),c.strokeStyle=h(i.strokeStyle,o.defaultColor);var a=0===h(i.lineWidth,s.borderWidth);if(c.setLineDash&&c.setLineDash(h(i.lineDash,s.borderDash)),n.labels&&n.labels.usePointStyle){var l=g*Math.SQRT2/2,u=l/Math.SQRT2,d=t+u,f=e+u;r.canvas.drawPoint(c,i.pointStyle,l,d,f)}else a||c.strokeRect(t,e,y,g),c.fillRect(t,e,y,g);c.restore()}},_=function(t,e,n,i){var a=g/2,r=y+a+t,o=e+a;c.fillText(n.text,r,o),n.hidden&&(c.beginPath(),c.lineWidth=2,c.moveTo(r,o),c.lineTo(r+i,o),c.stroke())},k=t.isHorizontal();d=k?{x:t.left+(l-u[0])/2,y:t.top+a.padding,line:0}:{x:t.left+a.padding,y:t.top+a.padding,line:0};var w=g+a.padding;r.each(t.legendItems,function(e,n){var i=c.measureText(e.text).width,r=y+g/2+i,o=d.x,s=d.y;k?o+r>=l&&(s=d.y+=w,d.line++,o=d.x=t.left+(l-u[d.line])/2):s+w>t.bottom&&(o=d.x=o+t.columnWidths[d.line]+a.padding,s=d.y=t.top+a.padding,d.line++),x(o,s,e),b[n].left=o,b[n].top=s,_(o,s,e,i),k?d.x+=r+a.padding:d.y+=w})}},handleEvent:function(t){var e=this,n=e.options,i="mouseup"===t.type?"click":t.type,a=!1;if("mousemove"===i){if(!n.onHover)return}else{if("click"!==i)return;if(!n.onClick)return}var r=t.x,o=t.y;if(r>=e.left&&r<=e.right&&o>=e.top&&o<=e.bottom)for(var s=e.legendHitBoxes,l=0;l<s.length;++l){var u=s[l];if(r>=u.left&&r<=u.left+u.width&&o>=u.top&&o<=u.top+u.height){if("click"===i){n.onClick.call(e,t.native,e.legendItems[l]),a=!0;break}if("mousemove"===i){n.onHover.call(e,t.native,e.legendItems[l]),a=!0;break}}}return a}}),{id:"legend",beforeInit:function(t){var e=t.options.legend;e&&n(t,e)},beforeUpdate:function(t){var e=t.options.legend,a=t.legend;e?(r.mergeIf(e,i.global.legend),a?(o.configure(t,a,e),a.options=e):n(t,e)):a&&(o.removeBox(t,a),delete t.legend)},afterEvent:function(t,e){var n=t.legend;n&&n.handleEvent(e)}}}},{25:25,26:26,45:45}],51:[function(t,e,n){"use strict";var i=t(25),a=t(26),r=t(45);i._set("global",{title:{display:!1,fontStyle:"bold",fullWidth:!0,lineHeight:1.2,padding:10,position:"top",text:"",weight:2e3}}),e.exports=function(t){function e(e,i){var a=new t.Title({ctx:e.ctx,options:i,chart:e});n.configure(e,a,i),n.addBox(e,a),e.titleBlock=a}var n=t.layoutService,o=r.noop;return t.Title=a.extend({initialize:function(t){var e=this;r.extend(e,t),e.legendHitBoxes=[]},beforeUpdate:o,update:function(t,e,n){var i=this;return i.beforeUpdate(),i.maxWidth=t,i.maxHeight=e,i.margins=n,i.beforeSetDimensions(),i.setDimensions(),i.afterSetDimensions(),i.beforeBuildLabels(),i.buildLabels(),i.afterBuildLabels(),i.beforeFit(),i.fit(),i.afterFit(),i.afterUpdate(),i.minSize},afterUpdate:o,beforeSetDimensions:o,setDimensions:function(){var t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0,t.minSize={width:0,height:0}},afterSetDimensions:o,beforeBuildLabels:o,buildLabels:o,afterBuildLabels:o,beforeFit:o,fit:function(){var t=this,e=r.valueOrDefault,n=t.options,a=n.display,o=e(n.fontSize,i.global.defaultFontSize),s=t.minSize,l=r.isArray(n.text)?n.text.length:1,u=r.options.toLineHeight(n.lineHeight,o),d=a?l*u+2*n.padding:0;t.isHorizontal()?(s.width=t.maxWidth,s.height=d):(s.width=d,s.height=t.maxHeight),t.width=s.width,t.height=s.height},afterFit:o,isHorizontal:function(){var t=this.options.position;return"top"===t||"bottom"===t},draw:function(){var t=this,e=t.ctx,n=r.valueOrDefault,a=t.options,o=i.global;if(a.display){var s,l,u,d=n(a.fontSize,o.defaultFontSize),c=n(a.fontStyle,o.defaultFontStyle),h=n(a.fontFamily,o.defaultFontFamily),f=r.fontString(d,c,h),g=r.options.toLineHeight(a.lineHeight,d),m=g/2+a.padding,p=0,v=t.top,y=t.left,b=t.bottom,x=t.right;e.fillStyle=n(a.fontColor,o.defaultFontColor),e.font=f,t.isHorizontal()?(l=y+(x-y)/2,u=v+m,s=x-y):(l="left"===a.position?y+m:x-m,u=v+(b-v)/2,s=b-v,p=Math.PI*("left"===a.position?-.5:.5)),e.save(),e.translate(l,u),e.rotate(p),e.textAlign="center",e.textBaseline="middle";var _=a.text;if(r.isArray(_))for(var k=0,w=0;w<_.length;++w)e.fillText(_[w],0,k,s),k+=g;else e.fillText(_,0,0,s);e.restore()}}}),{id:"title",beforeInit:function(t){var n=t.options.title;n&&e(t,n)},beforeUpdate:function(a){var o=a.options.title,s=a.titleBlock;o?(r.mergeIf(o,i.global.title),s?(n.configure(a,s,o),s.options=o):e(a,o)):s&&(t.layoutService.removeBox(a,s),delete a.titleBlock)}}}},{25:25,26:26,45:45}],52:[function(t,e,n){"use strict";e.exports=function(t){var e=t.Scale.extend({getLabels:function(){var t=this.chart.data;return this.options.labels||(this.isHorizontal()?t.xLabels:t.yLabels)||t.labels},determineDataLimits:function(){var t=this,e=t.getLabels();t.minIndex=0,t.maxIndex=e.length-1;var n;void 0!==t.options.ticks.min&&(n=e.indexOf(t.options.ticks.min),t.minIndex=-1!==n?n:t.minIndex),void 0!==t.options.ticks.max&&(n=e.indexOf(t.options.ticks.max),t.maxIndex=-1!==n?n:t.maxIndex),t.min=e[t.minIndex],t.max=e[t.maxIndex]},buildTicks:function(){var t=this,e=t.getLabels();t.ticks=0===t.minIndex&&t.maxIndex===e.length-1?e:e.slice(t.minIndex,t.maxIndex+1)},getLabelForIndex:function(t,e){var n=this,i=n.chart.data,a=n.isHorizontal();return i.yLabels&&!a?n.getRightValue(i.datasets[e].data[t]):n.ticks[t-n.minIndex]},getPixelForValue:function(t,e){var n,i=this,a=i.options.offset,r=Math.max(i.maxIndex+1-i.minIndex-(a?0:1),1);if(void 0!==t&&null!==t&&(n=i.isHorizontal()?t.x:t.y),void 0!==n||void 0!==t&&isNaN(e)){var o=i.getLabels();t=n||t;var s=o.indexOf(t);e=-1!==s?s:e}if(i.isHorizontal()){var l=i.width/r,u=l*(e-i.minIndex);return a&&(u+=l/2),i.left+Math.round(u)}var d=i.height/r,c=d*(e-i.minIndex);return a&&(c+=d/2),i.top+Math.round(c)},getPixelForTick:function(t){return this.getPixelForValue(this.ticks[t],t+this.minIndex,null)},getValueForPixel:function(t){var e=this,n=e.options.offset,i=Math.max(e._ticks.length-(n?0:1),1),a=e.isHorizontal(),r=(a?e.width:e.height)/i;return t-=a?e.left:e.top,n&&(t-=r/2),(t<=0?0:Math.round(t/r))+e.minIndex},getBasePixel:function(){return this.bottom}});t.scaleService.registerScaleType("category",e,{position:"bottom"})}},{}],53:[function(t,e,n){"use strict";var i=t(25),a=t(45),r=t(34);e.exports=function(t){var e={position:"left",ticks:{callback:r.formatters.linear}},n=t.LinearScaleBase.extend({determineDataLimits:function(){function t(t){return o?t.xAxisID===e.id:t.yAxisID===e.id}var e=this,n=e.options,i=e.chart,r=i.data.datasets,o=e.isHorizontal();e.min=null,e.max=null;var s=n.stacked;if(void 0===s&&a.each(r,function(e,n){if(!s){var a=i.getDatasetMeta(n);i.isDatasetVisible(n)&&t(a)&&void 0!==a.stack&&(s=!0)}}),n.stacked||s){var l={};a.each(r,function(r,o){var s=i.getDatasetMeta(o),u=[s.type,void 0===n.stacked&&void 0===s.stack?o:"",s.stack].join(".");void 0===l[u]&&(l[u]={positiveValues:[],negativeValues:[]});var d=l[u].positiveValues,c=l[u].negativeValues;i.isDatasetVisible(o)&&t(s)&&a.each(r.data,function(t,i){var a=+e.getRightValue(t);isNaN(a)||s.data[i].hidden||(d[i]=d[i]||0,c[i]=c[i]||0,n.relativePoints?d[i]=100:a<0?c[i]+=a:d[i]+=a)})}),a.each(l,function(t){var n=t.positiveValues.concat(t.negativeValues),i=a.min(n),r=a.max(n);e.min=null===e.min?i:Math.min(e.min,i),e.max=null===e.max?r:Math.max(e.max,r)})}else a.each(r,function(n,r){var o=i.getDatasetMeta(r);i.isDatasetVisible(r)&&t(o)&&a.each(n.data,function(t,n){var i=+e.getRightValue(t);isNaN(i)||o.data[n].hidden||(null===e.min?e.min=i:i<e.min&&(e.min=i),null===e.max?e.max=i:i>e.max&&(e.max=i))})});e.min=isFinite(e.min)&&!isNaN(e.min)?e.min:0,e.max=isFinite(e.max)&&!isNaN(e.max)?e.max:1,this.handleTickRangeOptions()},getTickLimit:function(){var t,e=this,n=e.options.ticks;if(e.isHorizontal())t=Math.min(n.maxTicksLimit?n.maxTicksLimit:11,Math.ceil(e.width/50));else{var r=a.valueOrDefault(n.fontSize,i.global.defaultFontSize);t=Math.min(n.maxTicksLimit?n.maxTicksLimit:11,Math.ceil(e.height/(2*r)))}return t},handleDirectionalChanges:function(){this.isHorizontal()||this.ticks.reverse()},getLabelForIndex:function(t,e){return+this.getRightValue(this.chart.data.datasets[e].data[t])},getPixelForValue:function(t){var e,n=this,i=n.start,a=+n.getRightValue(t),r=n.end-i;return n.isHorizontal()?(e=n.left+n.width/r*(a-i),Math.round(e)):(e=n.bottom-n.height/r*(a-i),Math.round(e))},getValueForPixel:function(t){var e=this,n=e.isHorizontal(),i=n?e.width:e.height,a=(n?t-e.left:e.bottom-t)/i;return e.start+(e.end-e.start)*a},getPixelForTick:function(t){return this.getPixelForValue(this.ticksAsNumbers[t])}});t.scaleService.registerScaleType("linear",n,e)}},{25:25,34:34,45:45}],54:[function(t,e,n){"use strict";var i=t(45),a=t(34);e.exports=function(t){var e=i.noop;t.LinearScaleBase=t.Scale.extend({getRightValue:function(e){return"string"==typeof e?+e:t.Scale.prototype.getRightValue.call(this,e)},handleTickRangeOptions:function(){var t=this,e=t.options.ticks;if(e.beginAtZero){var n=i.sign(t.min),a=i.sign(t.max);n<0&&a<0?t.max=0:n>0&&a>0&&(t.min=0)}var r=void 0!==e.min||void 0!==e.suggestedMin,o=void 0!==e.max||void 0!==e.suggestedMax;void 0!==e.min?t.min=e.min:void 0!==e.suggestedMin&&(null===t.min?t.min=e.suggestedMin:t.min=Math.min(t.min,e.suggestedMin)),void 0!==e.max?t.max=e.max:void 0!==e.suggestedMax&&(null===t.max?t.max=e.suggestedMax:t.max=Math.max(t.max,e.suggestedMax)),r!==o&&t.min>=t.max&&(r?t.max=t.min+1:t.min=t.max-1),t.min===t.max&&(t.max++,e.beginAtZero||t.min--)},getTickLimit:e,handleDirectionalChanges:e,buildTicks:function(){var t=this,e=t.options.ticks,n=t.getTickLimit(),r={maxTicks:n=Math.max(2,n),min:e.min,max:e.max,stepSize:i.valueOrDefault(e.fixedStepSize,e.stepSize)},o=t.ticks=a.generators.linear(r,t);t.handleDirectionalChanges(),t.max=i.max(o),t.min=i.min(o),e.reverse?(o.reverse(),t.start=t.max,t.end=t.min):(t.start=t.min,t.end=t.max)},convertTicksToLabels:function(){var e=this;e.ticksAsNumbers=e.ticks.slice(),e.zeroLineIndex=e.ticks.indexOf(0),t.Scale.prototype.convertTicksToLabels.call(e)}})}},{34:34,45:45}],55:[function(t,e,n){"use strict";var i=t(45),a=t(34);e.exports=function(t){var e={position:"left",ticks:{callback:a.formatters.logarithmic}},n=t.Scale.extend({determineDataLimits:function(){function t(t){return l?t.xAxisID===e.id:t.yAxisID===e.id}var e=this,n=e.options,a=n.ticks,r=e.chart,o=r.data.datasets,s=i.valueOrDefault,l=e.isHorizontal();e.min=null,e.max=null,e.minNotZero=null;var u=n.stacked;if(void 0===u&&i.each(o,function(e,n){if(!u){var i=r.getDatasetMeta(n);r.isDatasetVisible(n)&&t(i)&&void 0!==i.stack&&(u=!0)}}),n.stacked||u){var d={};i.each(o,function(a,o){var s=r.getDatasetMeta(o),l=[s.type,void 0===n.stacked&&void 0===s.stack?o:"",s.stack].join(".");r.isDatasetVisible(o)&&t(s)&&(void 0===d[l]&&(d[l]=[]),i.each(a.data,function(t,i){var a=d[l],r=+e.getRightValue(t);isNaN(r)||s.data[i].hidden||(a[i]=a[i]||0,n.relativePoints?a[i]=100:a[i]+=r)}))}),i.each(d,function(t){var n=i.min(t),a=i.max(t);e.min=null===e.min?n:Math.min(e.min,n),e.max=null===e.max?a:Math.max(e.max,a)})}else i.each(o,function(n,a){var o=r.getDatasetMeta(a);r.isDatasetVisible(a)&&t(o)&&i.each(n.data,function(t,n){var i=+e.getRightValue(t);isNaN(i)||o.data[n].hidden||(null===e.min?e.min=i:i<e.min&&(e.min=i),null===e.max?e.max=i:i>e.max&&(e.max=i),0!==i&&(null===e.minNotZero||i<e.minNotZero)&&(e.minNotZero=i))})});e.min=s(a.min,e.min),e.max=s(a.max,e.max),e.min===e.max&&(0!==e.min&&null!==e.min?(e.min=Math.pow(10,Math.floor(i.log10(e.min))-1),e.max=Math.pow(10,Math.floor(i.log10(e.max))+1)):(e.min=1,e.max=10))},buildTicks:function(){var t=this,e=t.options.ticks,n={min:e.min,max:e.max},r=t.ticks=a.generators.logarithmic(n,t);t.isHorizontal()||r.reverse(),t.max=i.max(r),t.min=i.min(r),e.reverse?(r.reverse(),t.start=t.max,t.end=t.min):(t.start=t.min,t.end=t.max)},convertTicksToLabels:function(){this.tickValues=this.ticks.slice(),t.Scale.prototype.convertTicksToLabels.call(this)},getLabelForIndex:function(t,e){return+this.getRightValue(this.chart.data.datasets[e].data[t])},getPixelForTick:function(t){return this.getPixelForValue(this.tickValues[t])},getPixelForValue:function(t){var e,n,a,r=this,o=r.start,s=+r.getRightValue(t),l=r.options.ticks;return r.isHorizontal()?(a=i.log10(r.end)-i.log10(o),0===s?n=r.left:(e=r.width,n=r.left+e/a*(i.log10(s)-i.log10(o)))):(e=r.height,0!==o||l.reverse?0===r.end&&l.reverse?(a=i.log10(r.start)-i.log10(r.minNotZero),n=s===r.end?r.top:s===r.minNotZero?r.top+.02*e:r.top+.02*e+.98*e/a*(i.log10(s)-i.log10(r.minNotZero))):0===s?n=l.reverse?r.top:r.bottom:(a=i.log10(r.end)-i.log10(o),e=r.height,n=r.bottom-e/a*(i.log10(s)-i.log10(o))):(a=i.log10(r.end)-i.log10(r.minNotZero),n=s===o?r.bottom:s===r.minNotZero?r.bottom-.02*e:r.bottom-.02*e-.98*e/a*(i.log10(s)-i.log10(r.minNotZero)))),n},getValueForPixel:function(t){var e,n,a=this,r=i.log10(a.end)-i.log10(a.start);return a.isHorizontal()?(n=a.width,e=a.start*Math.pow(10,(t-a.left)*r/n)):(n=a.height,e=Math.pow(10,(a.bottom-t)*r/n)/a.start),e}});t.scaleService.registerScaleType("logarithmic",n,e)}},{34:34,45:45}],56:[function(t,e,n){"use strict";var i=t(25),a=t(45),r=t(34);e.exports=function(t){function e(t){var e=t.options;return e.angleLines.display||e.pointLabels.display?t.chart.data.labels.length:0}function n(t){var e=t.options.pointLabels,n=a.valueOrDefault(e.fontSize,p.defaultFontSize),i=a.valueOrDefault(e.fontStyle,p.defaultFontStyle),r=a.valueOrDefault(e.fontFamily,p.defaultFontFamily);return{size:n,style:i,family:r,font:a.fontString(n,i,r)}}function o(t,e,n){return a.isArray(n)?{w:a.longestText(t,t.font,n),h:n.length*e+1.5*(n.length-1)*e}:{w:t.measureText(n).width,h:e}}function s(t,e,n,i,a){return t===i||t===a?{start:e-n/2,end:e+n/2}:t<i||t>a?{start:e-n-5,end:e}:{start:e,end:e+n+5}}function l(t){var i,r,l,u=n(t),d=Math.min(t.height/2,t.width/2),c={r:t.width,l:0,t:t.height,b:0},h={};t.ctx.font=u.font,t._pointLabelSizes=[];var f=e(t);for(i=0;i<f;i++){l=t.getPointPosition(i,d),r=o(t.ctx,u.size,t.pointLabels[i]||""),t._pointLabelSizes[i]=r;var g=t.getIndexAngle(i),m=a.toDegrees(g)%360,p=s(m,l.x,r.w,0,180),v=s(m,l.y,r.h,90,270);p.start<c.l&&(c.l=p.start,h.l=g),p.end>c.r&&(c.r=p.end,h.r=g),v.start<c.t&&(c.t=v.start,h.t=g),v.end>c.b&&(c.b=v.end,h.b=g)}t.setReductions(d,c,h)}function u(t){var e=Math.min(t.height/2,t.width/2);t.drawingArea=Math.round(e),t.setCenterPoint(0,0,0,0)}function d(t){return 0===t||180===t?"center":t<180?"left":"right"}function c(t,e,n,i){if(a.isArray(e))for(var r=n.y,o=1.5*i,s=0;s<e.length;++s)t.fillText(e[s],n.x,r),r+=o;else t.fillText(e,n.x,n.y)}function h(t,e,n){90===t||270===t?n.y-=e.h/2:(t>270||t<90)&&(n.y-=e.h)}function f(t){var i=t.ctx,r=a.valueOrDefault,o=t.options,s=o.angleLines,l=o.pointLabels;i.lineWidth=s.lineWidth,i.strokeStyle=s.color;var u=t.getDistanceFromCenterForValue(o.ticks.reverse?t.min:t.max),f=n(t);i.textBaseline="top";for(var g=e(t)-1;g>=0;g--){if(s.display){var m=t.getPointPosition(g,u);i.beginPath(),i.moveTo(t.xCenter,t.yCenter),i.lineTo(m.x,m.y),i.stroke(),i.closePath()}if(l.display){var v=t.getPointPosition(g,u+5),y=r(l.fontColor,p.defaultFontColor);i.font=f.font,i.fillStyle=y;var b=t.getIndexAngle(g),x=a.toDegrees(b);i.textAlign=d(x),h(x,t._pointLabelSizes[g],v),c(i,t.pointLabels[g]||"",v,f.size)}}}function g(t,n,i,r){var o=t.ctx;if(o.strokeStyle=a.valueAtIndexOrDefault(n.color,r-1),o.lineWidth=a.valueAtIndexOrDefault(n.lineWidth,r-1),t.options.gridLines.circular)o.beginPath(),o.arc(t.xCenter,t.yCenter,i,0,2*Math.PI),o.closePath(),o.stroke();else{var s=e(t);if(0===s)return;o.beginPath();var l=t.getPointPosition(0,i);o.moveTo(l.x,l.y);for(var u=1;u<s;u++)l=t.getPointPosition(u,i),o.lineTo(l.x,l.y);o.closePath(),o.stroke()}}function m(t){return a.isNumber(t)?t:0}var p=i.global,v={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,color:"rgba(0, 0, 0, 0.1)",lineWidth:1},gridLines:{circular:!1},ticks:{showLabelBackdrop:!0,backdropColor:"rgba(255,255,255,0.75)",backdropPaddingY:2,backdropPaddingX:2,callback:r.formatters.linear},pointLabels:{display:!0,fontSize:10,callback:function(t){return t}}},y=t.LinearScaleBase.extend({setDimensions:function(){var t=this,e=t.options,n=e.ticks;t.width=t.maxWidth,t.height=t.maxHeight,t.xCenter=Math.round(t.width/2),t.yCenter=Math.round(t.height/2);var i=a.min([t.height,t.width]),r=a.valueOrDefault(n.fontSize,p.defaultFontSize);t.drawingArea=e.display?i/2-(r/2+n.backdropPaddingY):i/2},determineDataLimits:function(){var t=this,e=t.chart,n=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY;a.each(e.data.datasets,function(r,o){if(e.isDatasetVisible(o)){var s=e.getDatasetMeta(o);a.each(r.data,function(e,a){var r=+t.getRightValue(e);isNaN(r)||s.data[a].hidden||(n=Math.min(r,n),i=Math.max(r,i))})}}),t.min=n===Number.POSITIVE_INFINITY?0:n,t.max=i===Number.NEGATIVE_INFINITY?0:i,t.handleTickRangeOptions()},getTickLimit:function(){var t=this.options.ticks,e=a.valueOrDefault(t.fontSize,p.defaultFontSize);return Math.min(t.maxTicksLimit?t.maxTicksLimit:11,Math.ceil(this.drawingArea/(1.5*e)))},convertTicksToLabels:function(){var e=this;t.LinearScaleBase.prototype.convertTicksToLabels.call(e),e.pointLabels=e.chart.data.labels.map(e.options.pointLabels.callback,e)},getLabelForIndex:function(t,e){return+this.getRightValue(this.chart.data.datasets[e].data[t])},fit:function(){this.options.pointLabels.display?l(this):u(this)},setReductions:function(t,e,n){var i=this,a=e.l/Math.sin(n.l),r=Math.max(e.r-i.width,0)/Math.sin(n.r),o=-e.t/Math.cos(n.t),s=-Math.max(e.b-i.height,0)/Math.cos(n.b);a=m(a),r=m(r),o=m(o),s=m(s),i.drawingArea=Math.min(Math.round(t-(a+r)/2),Math.round(t-(o+s)/2)),i.setCenterPoint(a,r,o,s)},setCenterPoint:function(t,e,n,i){var a=this,r=a.width-e-a.drawingArea,o=t+a.drawingArea,s=n+a.drawingArea,l=a.height-i-a.drawingArea;a.xCenter=Math.round((o+r)/2+a.left),a.yCenter=Math.round((s+l)/2+a.top)},getIndexAngle:function(t){return t*(2*Math.PI/e(this))+(this.chart.options&&this.chart.options.startAngle?this.chart.options.startAngle:0)*Math.PI*2/360},getDistanceFromCenterForValue:function(t){var e=this;if(null===t)return 0;var n=e.drawingArea/(e.max-e.min);return e.options.ticks.reverse?(e.max-t)*n:(t-e.min)*n},getPointPosition:function(t,e){var n=this,i=n.getIndexAngle(t)-Math.PI/2;return{x:Math.round(Math.cos(i)*e)+n.xCenter,y:Math.round(Math.sin(i)*e)+n.yCenter}},getPointPositionForValue:function(t,e){return this.getPointPosition(t,this.getDistanceFromCenterForValue(e))},getBasePosition:function(){var t=this,e=t.min,n=t.max;return t.getPointPositionForValue(0,t.beginAtZero?0:e<0&&n<0?n:e>0&&n>0?e:0)},draw:function(){var t=this,e=t.options,n=e.gridLines,i=e.ticks,r=a.valueOrDefault;if(e.display){var o=t.ctx,s=this.getIndexAngle(0),l=r(i.fontSize,p.defaultFontSize),u=r(i.fontStyle,p.defaultFontStyle),d=r(i.fontFamily,p.defaultFontFamily),c=a.fontString(l,u,d);a.each(t.ticks,function(e,a){if(a>0||i.reverse){var u=t.getDistanceFromCenterForValue(t.ticksAsNumbers[a]);if(n.display&&0!==a&&g(t,n,u,a),i.display){var d=r(i.fontColor,p.defaultFontColor);if(o.font=c,o.save(),o.translate(t.xCenter,t.yCenter),o.rotate(s),i.showLabelBackdrop){var h=o.measureText(e).width;o.fillStyle=i.backdropColor,o.fillRect(-h/2-i.backdropPaddingX,-u-l/2-i.backdropPaddingY,h+2*i.backdropPaddingX,l+2*i.backdropPaddingY)}o.textAlign="center",o.textBaseline="middle",o.fillStyle=d,o.fillText(e,0,-u),o.restore()}}}),(e.angleLines.display||e.pointLabels.display)&&f(t)}}});t.scaleService.registerScaleType("radialLinear",y,v)}},{25:25,34:34,45:45}],57:[function(t,e,n){"use strict";function i(t,e){return t-e}function a(t){var e,n,i,a={},r=[];for(e=0,n=t.length;e<n;++e)a[i=t[e]]||(a[i]=!0,r.push(i));return r}function r(t,e,n,i){if("linear"===i||!t.length)return[{time:e,pos:0},{time:n,pos:1}];var a,r,o,s,l,u=[],d=[e];for(a=0,r=t.length;a<r;++a)(s=t[a])>e&&s<n&&d.push(s);for(d.push(n),a=0,r=d.length;a<r;++a)l=d[a+1],o=d[a-1],s=d[a],void 0!==o&&void 0!==l&&Math.round((l+o)/2)===s||u.push({time:s,pos:a/(r-1)});return u}function o(t,e,n){for(var i,a,r,o=0,s=t.length-1;o>=0&&o<=s;){if(i=o+s>>1,a=t[i-1]||null,r=t[i],!a)return{lo:null,hi:r};if(r[e]<n)o=i+1;else{if(!(a[e]>n))return{lo:a,hi:r};s=i-1}}return{lo:r,hi:null}}function s(t,e,n,i){var a=o(t,e,n),r=a.lo?a.hi?a.lo:t[t.length-2]:t[0],s=a.lo?a.hi?a.hi:t[t.length-1]:t[1],l=s[e]-r[e],u=l?(n-r[e])/l:0,d=(s[i]-r[i])*u;return r[i]+d}function l(t,e){var n=e.parser,i=e.parser||e.format;return"function"==typeof n?n(t):"string"==typeof t&&"string"==typeof i?v(t,i):(t instanceof v||(t=v(t)),t.isValid()?t:"function"==typeof i?i(t):t)}function u(t,e){if(b.isNullOrUndef(t))return null;var n=e.options.time,i=l(e.getRightValue(t),n);return i.isValid()?(n.round&&i.startOf(n.round),i.valueOf()):null}function d(t,e,n,i){var a,r,o,s=e-t,l=k[n],u=l.size,d=l.steps;if(!d)return Math.ceil(s/((i||1)*u));for(a=0,r=d.length;a<r&&(o=d[a],!(Math.ceil(s/(u*o))<=i));++a);return o}function c(t,e,n,i){var a,r,o,s=w.length;for(a=w.indexOf(t);a<s-1;++a)if(r=k[w[a]],o=r.steps?r.steps[r.steps.length-1]:_,r.common&&Math.ceil((n-e)/(o*r.size))<=i)return w[a];return w[s-1]}function h(t,e,n,i){var a,r,o=v.duration(v(i).diff(v(n)));for(a=w.length-1;a>=w.indexOf(e);a--)if(r=w[a],k[r].common&&o.as(r)>=t.length)return r;return w[e?w.indexOf(e):0]}function f(t){for(var e=w.indexOf(t)+1,n=w.length;e<n;++e)if(k[w[e]].common)return w[e]}function g(t,e,n,i){var a,r=i.time,o=r.unit||c(r.minUnit,t,e,n),s=f(o),l=b.valueOrDefault(r.stepSize,r.unitStepSize),u="week"===o&&r.isoWeekday,h=i.ticks.major.enabled,g=k[o],m=v(t),p=v(e),y=[];for(l||(l=d(t,e,o,n)),u&&(m=m.isoWeekday(u),p=p.isoWeekday(u)),m=m.startOf(u?"day":o),(p=p.startOf(u?"day":o))<e&&p.add(1,o),a=v(m),h&&s&&!u&&!r.round&&(a.startOf(s),a.add(~~((m-a)/(g.size*l))*l,o));a<p;a.add(l,o))y.push(+a);return y.push(+a),y}function m(t,e,n,i,a){var r,o,l=0,u=0;return a.offset&&e.length&&(a.time.min||(r=e.length>1?e[1]:i,o=e[0],l=(s(t,"time",r,"pos")-s(t,"time",o,"pos"))/2),a.time.max||(r=e[e.length-1],o=e.length>1?e[e.length-2]:n,u=(s(t,"time",r,"pos")-s(t,"time",o,"pos"))/2)),{left:l,right:u}}function p(t,e){var n,i,a,r,o=[];for(n=0,i=t.length;n<i;++n)a=t[n],r=!!e&&a===+v(a).startOf(e),o.push({value:a,major:r});return o}var v=t(6);v="function"==typeof v?v:window.moment;var y=t(25),b=t(45),x=Number.MIN_SAFE_INTEGER||-9007199254740991,_=Number.MAX_SAFE_INTEGER||9007199254740991,k={millisecond:{common:!0,size:1,steps:[1,2,5,10,20,50,100,250,500]},second:{common:!0,size:1e3,steps:[1,2,5,10,30]},minute:{common:!0,size:6e4,steps:[1,2,5,10,30]},hour:{common:!0,size:36e5,steps:[1,2,3,6,12]},day:{common:!0,size:864e5,steps:[1,2,5]},week:{common:!1,size:6048e5,steps:[1,2,3,4]},month:{common:!0,size:2628e6,steps:[1,2,3]},quarter:{common:!1,size:7884e6,steps:[1,2,3,4]},year:{common:!0,size:3154e7}},w=Object.keys(k);e.exports=function(t){var e=t.Scale.extend({initialize:function(){if(!v)throw new Error("Chart.js - Moment.js could not be found! You must include it before Chart.js to use the time scale. Download at https://momentjs.com");this.mergeTicksOptions(),t.Scale.prototype.initialize.call(this)},update:function(){var e=this,n=e.options;return n.time&&n.time.format&&console.warn("options.time.format is deprecated and replaced by options.time.parser."),t.Scale.prototype.update.apply(e,arguments)},getRightValue:function(e){return e&&void 0!==e.t&&(e=e.t),t.Scale.prototype.getRightValue.call(this,e)},determineDataLimits:function(){var t,e,n,r,o,s,l=this,d=l.chart,c=l.options.time,h=_,f=x,g=[],m=[],p=[];for(t=0,n=d.data.labels.length;t<n;++t)p.push(u(d.data.labels[t],l));for(t=0,n=(d.data.datasets||[]).length;t<n;++t)if(d.isDatasetVisible(t))if(o=d.data.datasets[t].data,b.isObject(o[0]))for(m[t]=[],e=0,r=o.length;e<r;++e)s=u(o[e],l),g.push(s),m[t][e]=s;else g.push.apply(g,p),m[t]=p.slice(0);else m[t]=[];p.length&&(p=a(p).sort(i),h=Math.min(h,p[0]),f=Math.max(f,p[p.length-1])),g.length&&(g=a(g).sort(i),h=Math.min(h,g[0]),f=Math.max(f,g[g.length-1])),h=u(c.min,l)||h,f=u(c.max,l)||f,h=h===_?+v().startOf("day"):h,f=f===x?+v().endOf("day")+1:f,l.min=Math.min(h,f),l.max=Math.max(h+1,f),l._horizontal=l.isHorizontal(),l._table=[],l._timestamps={data:g,datasets:m,labels:p}},buildTicks:function(){var t,e,n,i=this,a=i.min,o=i.max,s=i.options,l=s.time,d=[],c=[];switch(s.ticks.source){case"data":d=i._timestamps.data;break;case"labels":d=i._timestamps.labels;break;case"auto":default:d=g(a,o,i.getLabelCapacity(a),s)}for("ticks"===s.bounds&&d.length&&(a=d[0],o=d[d.length-1]),a=u(l.min,i)||a,o=u(l.max,i)||o,t=0,e=d.length;t<e;++t)(n=d[t])>=a&&n<=o&&c.push(n);return i.min=a,i.max=o,i._unit=l.unit||h(c,l.minUnit,i.min,i.max),i._majorUnit=f(i._unit),i._table=r(i._timestamps.data,a,o,s.distribution),i._offsets=m(i._table,c,a,o,s),p(c,i._majorUnit)},getLabelForIndex:function(t,e){var n=this,i=n.chart.data,a=n.options.time,r=i.labels&&t<i.labels.length?i.labels[t]:"",o=i.datasets[e].data[t];return b.isObject(o)&&(r=n.getRightValue(o)),a.tooltipFormat&&(r=l(r,a).format(a.tooltipFormat)),r},tickFormatFunction:function(t,e,n,i){var a=this,r=a.options,o=t.valueOf(),s=r.time.displayFormats,l=s[a._unit],u=a._majorUnit,d=s[u],c=t.clone().startOf(u).valueOf(),h=r.ticks.major,f=h.enabled&&u&&d&&o===c,g=t.format(i||(f?d:l)),m=f?h:r.ticks.minor,p=b.valueOrDefault(m.callback,m.userCallback);return p?p(g,e,n):g},convertTicksToLabels:function(t){var e,n,i=[];for(e=0,n=t.length;e<n;++e)i.push(this.tickFormatFunction(v(t[e].value),e,t));return i},getPixelForOffset:function(t){var e=this,n=e._horizontal?e.width:e.height,i=e._horizontal?e.left:e.top,a=s(e._table,"time",t,"pos");return i+n*(e._offsets.left+a)/(e._offsets.left+1+e._offsets.right)},getPixelForValue:function(t,e,n){var i=this,a=null;if(void 0!==e&&void 0!==n&&(a=i._timestamps.datasets[n][e]),null===a&&(a=u(t,i)),null!==a)return i.getPixelForOffset(a)},getPixelForTick:function(t){var e=this.getTicks();return t>=0&&t<e.length?this.getPixelForOffset(e[t].value):null},getValueForPixel:function(t){var e=this,n=e._horizontal?e.width:e.height,i=e._horizontal?e.left:e.top,a=(n?(t-i)/n:0)*(e._offsets.left+1+e._offsets.left)-e._offsets.right,r=s(e._table,"pos",a,"time");return v(r)},getLabelWidth:function(t){var e=this,n=e.options.ticks,i=e.ctx.measureText(t).width,a=b.toRadians(n.maxRotation),r=Math.cos(a),o=Math.sin(a);return i*r+b.valueOrDefault(n.fontSize,y.global.defaultFontSize)*o},getLabelCapacity:function(t){var e=this,n=e.options.time.displayFormats.millisecond,i=e.tickFormatFunction(v(t),0,[],n),a=e.getLabelWidth(i),r=e.isHorizontal()?e.width:e.height;return Math.floor(r/a)}});t.scaleService.registerScaleType("time",e,{position:"bottom",distribution:"linear",bounds:"data",time:{parser:!1,format:!1,unit:!1,round:!1,displayFormat:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{millisecond:"h:mm:ss.SSS a",second:"h:mm:ss a",minute:"h:mm a",hour:"hA",day:"MMM D",week:"ll",month:"MMM YYYY",quarter:"[Q]Q - YYYY",year:"YYYY"}},ticks:{autoSkip:!1,source:"auto",major:{enabled:!1}}})}},{25:25,45:45,6:6}]},{},[7])(7)});
\ No newline at end of file
diff --git a/bemani/frontend/static/color.css b/bemani/frontend/static/color.css
new file mode 100644
index 0000000..9c18e0f
--- /dev/null
+++ b/bemani/frontend/static/color.css
@@ -0,0 +1,31 @@
+.bishi.border {
+    border-color: #EF6A32;
+}
+
+.ddr.border {
+    border-color: #017351;
+}
+
+.iidx.border {
+    border-color: #A12A5E;
+}
+
+.jubeat.border {
+    border-color: #FBBF45;
+}
+
+.museca.border {
+    border-color: #AAD962;
+}
+
+.pnm.border {
+    border-color: #ED0345;
+}
+
+.reflec.border {
+    border-color: #03C383;
+}
+
+.sdvx.border {
+    border-color: #710162;
+}
diff --git a/bemani/frontend/static/components/add.react.js b/bemani/frontend/static/components/add.react.js
new file mode 100644
index 0000000..6134501
--- /dev/null
+++ b/bemani/frontend/static/components/add.react.js
@@ -0,0 +1,16 @@
+/** @jsx React.DOM */
+
+var Add = React.createClass({
+    render: function() {
+        return (
+            <Button
+                className="add"
+                disabled={this.props.disabled}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title={this.props.title ? this.props.title : 'add'}
+            />
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/button.react.js b/bemani/frontend/static/components/button.react.js
new file mode 100644
index 0000000..a21a8ed
--- /dev/null
+++ b/bemani/frontend/static/components/button.react.js
@@ -0,0 +1,18 @@
+/** @jsx React.DOM */
+
+var Button = React.createClass({
+    render: function() {
+        return (
+            <button
+                className={this.props.className}
+                style={this.props.style}
+                disabled={this.props.disabled}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+            >
+                {this.props.title}
+            </button>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/card.react.js b/bemani/frontend/static/components/card.react.js
new file mode 100644
index 0000000..88f21b9
--- /dev/null
+++ b/bemani/frontend/static/components/card.react.js
@@ -0,0 +1,17 @@
+/** @jsx React.DOM */
+
+var Card = React.createClass({
+    render: function() {
+        return (
+            <div className="card">{
+                this.props.number.substring(0, 4) +
+                ' ' +
+                this.props.number.substring(4, 8) +
+                ' ' +
+                this.props.number.substring(8, 12) +
+                ' ' +
+                this.props.number.substring(12, 16)
+            }</div>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/chart.react.js b/bemani/frontend/static/components/chart.react.js
new file mode 100644
index 0000000..332fa5d
--- /dev/null
+++ b/bemani/frontend/static/components/chart.react.js
@@ -0,0 +1,75 @@
+/** @jsx React.DOM */
+
+var Graph = React.createClass({
+    componentDidMount: function() {
+        var config = {
+            type: this.props.type,
+            data: this.props.data,
+            options: this.props.options || {},
+        };
+        this.chart_instance = new Chart(this.element, config);
+    },
+
+    componentWillUnmount: function() {
+        this.chart_instance.destroy();
+    },
+
+    componentWillReceiveProps: function(nextProps) {
+        const dataChanged = this.props.data !== nextProps.data;
+        const optionsChanged = this.props.options !== nextProps.options;
+        if (optionsChanged || dataChanged) {
+            this.chart_instance.destroy();
+            var config = {
+                type: this.props.type,
+                data: nextProps.data,
+                options: nextProps.options || {},
+            };
+            this.chart_instance = new Chart(this.element, config);
+        }
+    },
+
+    ref: function(element) {
+        this.element = element;
+    },
+
+    render: function() {
+        return (
+            <canvas
+                ref={this.ref}
+                height={this.props.height}
+                width={this.props.width}
+            />
+        );
+    },
+
+});
+
+var LineGraph = React.createClass({
+
+    render: function() {
+        return (
+            <Graph
+                type="line"
+                data={this.props.data}
+                options={this.props.options}
+                width={this.props.width}
+                height={this.props.height}
+            />
+        );
+    },
+});
+
+var RadarGraph = React.createClass({
+
+    render: function() {
+        return (
+            <Graph
+                type="radar"
+                data={this.props.data}
+                options={this.props.options}
+                width={this.props.width}
+                height={this.props.height}
+            />
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/checkbox.react.js b/bemani/frontend/static/components/checkbox.react.js
new file mode 100644
index 0000000..cec47d3
--- /dev/null
+++ b/bemani/frontend/static/components/checkbox.react.js
@@ -0,0 +1,14 @@
+/** @jsx React.DOM */
+
+var Checkbox = React.createClass({
+    render: function() {
+        return (
+            <span className={this.props.className} onClick={this.props.onClick}>
+                {this.props.checked ?
+                    <span className="checkbox">&#9745;</span> :
+                    <span className="checkbox">&#9744;</span>
+                }
+            </span>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/delete.react.js b/bemani/frontend/static/components/delete.react.js
new file mode 100644
index 0000000..1c2ed09
--- /dev/null
+++ b/bemani/frontend/static/components/delete.react.js
@@ -0,0 +1,16 @@
+/** @jsx React.DOM */
+
+var Delete = React.createClass({
+    render: function() {
+        return (
+            <Button
+                className="delete"
+                disabled={this.props.disabled}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title={this.props.title ? this.props.title : 'delete'}
+            />
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/edit.react.js b/bemani/frontend/static/components/edit.react.js
new file mode 100644
index 0000000..a6e5de3
--- /dev/null
+++ b/bemani/frontend/static/components/edit.react.js
@@ -0,0 +1,16 @@
+/** @jsx React.DOM */
+
+var Edit = React.createClass({
+    render: function() {
+        return (
+            <Button
+                className="edit"
+                disabled={this.props.disabled}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title={this.props.title ? this.props.title : 'edit'}
+            />
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/events.react.js b/bemani/frontend/static/components/events.react.js
new file mode 100644
index 0000000..8b72824
--- /dev/null
+++ b/bemani/frontend/static/components/events.react.js
@@ -0,0 +1,343 @@
+/*** @jsx React.DOM */
+
+var UnknownEvent = React.createClass({
+    render: function() {
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="unknown">Unknown event {event.type}</td>
+                <td className="details">
+                    <div>Raw JSON:</div>
+                    <LongMessage>{JSON.stringify(event.data, null, 4)}</LongMessage>
+                </td>
+            </tr>
+        );
+    },
+});
+
+var ExceptionEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        var location = 'Unknown Service';
+        var details = 'No details for this type of exception!';
+        if (event.data.service == 'frontend') {
+            location = 'Web UI';
+            details = (
+                <span>
+                    <div>
+                        <div className="inline">URI:</div>
+                        <pre className="inline">{event.data.request}</pre>
+                    </div>
+                    <div>Exception:</div>
+                    <LongMessage>{event.data.traceback}</LongMessage>
+                </span>
+            );
+        } else if(event.data.service == 'xrpc') {
+            location = 'Game Services';
+            details = (
+                <span>
+                    <div>Request:</div>
+                    <LongMessage>{event.data.request}</LongMessage>
+                    <div>Exception:</div>
+                    <LongMessage>{event.data.traceback}</LongMessage>
+                </span>
+            );
+        } else if(event.data.service == 'scheduler') {
+            location = 'Work Scheduler';
+            details = (
+                <span>
+                    <div>Exception:</div>
+                    <LongMessage>{event.data.traceback}</LongMessage>
+                </span>
+            );
+        } else if (event.data.service == 'api') {
+            location = 'Data Exchange API';
+            details = (
+                <span>
+                    <div>
+                        <div className="inline">URI:</div>
+                        <pre className="inline">{event.data.request}</pre>
+                    </div>
+                    <div>Exception:</div>
+                    <LongMessage>{event.data.traceback}</LongMessage>
+                </span>
+            );
+        }
+
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="exception">
+                    <div className="circle" />
+                    Exception Occurred In {location}
+                </td>
+                <td className="details">{details}</td>
+            </tr>
+        );
+    },
+});
+
+var UnhandledPacketEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="unhandled">
+                    <div className="circle" />
+                    Unhandled Packet Received In Game Services
+                </td>
+                <td className="details">
+                    <div>Request:</div>
+                    <LongMessage>{event.data.request}</LongMessage>
+                </td>
+            </tr>
+        );
+    },
+});
+
+var UnauthorizedClientEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="unauthorized">
+                    <div className="circle" />
+                    Unauthorized Client Connected To Game Services
+                </td>
+                <td className="details">
+                    <div>
+                        <div className="inline">Model:</div>
+                        <pre className="inline">{event.data.model}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">PCBID:</div>
+                        <pre className="inline">{event.data.pcbid}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">IP Addres:</div>
+                        <pre className="inline">{event.data.ip}</pre>
+                    </div>
+                </td>
+            </tr>
+        );
+    },
+});
+
+var PCBEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="pcbevent">
+                    <div className="circle" />
+                    PCB Event
+                </td>
+                <td className="details">
+                    <div>
+                        <div className="inline">Model:</div>
+                        <pre className="inline">{event.data.model}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">PCBID:</div>
+                        <pre className="inline">{event.data.pcbid}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">IP Addres:</div>
+                        <pre className="inline">{event.data.ip}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">Name:</div>
+                        <pre className="inline">{event.data.name}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">Value:</div>
+                        <pre className="inline">{event.data.value}</pre>
+                    </div>
+                </td>
+            </tr>
+        );
+    },
+});
+
+var PASELITransactionEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        var username = null;
+        var user = null;
+        if (this.props.users) {
+            if (this.props.users[event.userid]) {
+                username = this.props.users[event.userid];
+            }
+            if (username == null) {
+                user = <span className="placeholder">anonymous account</span>;
+            } else {
+                user = <span>{username}</span>;
+            }
+        }
+
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="transaction">
+                    <div className="circle" />
+                    PASELI Transaction
+                </td>
+                <td className="details">
+                    { user ?
+                        <div>
+                            <div className="inline">User:</div>
+                            <div className="inline"><a href={Link.get('viewuser', event.userid)}>{user}</a></div>
+                        </div> : null
+                    }
+                    { this.props.arcades ?
+                        <div>
+                            <div className="inline">Arcade:</div>
+                            <div className="inline">{this.props.arcades[event.arcadeid]}</div>
+                        </div> : null
+                    }
+                    { event.data['pcbid'] ?
+                        <div>
+                            <div className="inline">PCBID:</div>
+                            <pre className="inline">{event.data.pcbid}</pre>
+                        </div> : null
+                    }
+                    <div>
+                        <div className="inline">Reason:</div>
+                        <pre className="inline">{event.data.reason}</pre>
+                    </div>
+                    <div>
+                        <div className="inline">Transaction Amount:</div>
+                        <pre className="inline">{event.data.delta}</pre>
+                    </div>
+                    { event.data['service'] && event.data['service'] != 0 ?
+                        <div>
+                            <div className="inline">Service PASELI Amount:</div>
+                            <pre className="inline">{event.data.service}</pre>
+                        </div> : null
+                    }
+                    <div>
+                        <div className="inline">New Balance:</div>
+                        <pre className="inline">{event.data.balance}</pre>
+                    </div>
+                </td>
+            </tr>
+        );
+    },
+});
+
+var JubeatLeagueCourseEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        var game = this.props.versions[event.data.version];
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="scheduled">
+                    <div className="circle" />
+                    Generated New {game} League Course
+                </td>
+                <td className="details">
+                    <div>Songs:</div>
+                    {event.data.songs.map(function(songid) {
+                        return (
+                            <div>
+                                <a href={Link.get('jubeatsong', songid)}>
+                                    {this.props.songs[songid].artist}{this.props.songs[songid].artist ? " - " : ""}{this.props.songs[songid].name}
+                                </a>
+                            </div>
+                        );
+                    }.bind(this))}
+                </td>
+            </tr>
+        );
+    },
+});
+
+var JubeatFCChallengeEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        var game = this.props.versions[event.data.version];
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="scheduled">
+                    <div className="circle" />
+                    Generated New {game} Full Combo Challenge Songs
+                </td>
+                <td className="details">
+                    <div>Challenge:</div>
+                    <div>
+                        <a href={Link.get('jubeatsong', event.data.today)}>
+                            {this.props.songs[event.data.today].artist}{this.props.songs[event.data.today].artist ? " - " : ""}{this.props.songs[event.data.today].name}
+                        </a>
+                    </div>
+                    {event.data.whim ?
+                        <div>
+                            <div>Whim:</div>
+                            <div>
+                                <a href={Link.get('jubeatsong', event.data.whim)}>
+                                    {this.props.songs[event.data.whim].artist}{this.props.songs[event.data.whim].artist ? " - " : ""}{this.props.songs[event.data.whim].name}
+                                </a>
+                            </div>
+                        </div> : null
+                    }
+                </td>
+            </tr>
+        );
+    },
+});
+
+var IIDXDailyChartsEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        var game = this.props.versions[event.data.version];
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="scheduled">
+                    <div className="circle" />
+                    Generated New {game} Dailies
+                </td>
+                <td className="details">
+                    <div>Songs:</div>
+                    {event.data.music.map(function(songid) {
+                        return (
+                            <div>
+                                <a href={Link.get('iidxsong', songid)}>
+                                    {this.props.songs[songid].artist} - {this.props.songs[songid].name}
+                                </a>
+                            </div>
+                        );
+                    }.bind(this))}
+                </td>
+            </tr>
+        );
+    },
+});
+
+var PopnMusicCourseEvent = React.createClass({
+    render: function() {
+        var event = this.props.event;
+        var game = this.props.versions[event.data.version];
+        return (
+            <tr key={event.id}>
+                <td><Timestamp timestamp={event.timestamp} /></td>
+                <td className="scheduled">
+                    <div className="circle" />
+                    Generated New {game} Weekly Course Song
+                </td>
+                <td className="details">
+                    <div>Song:</div>
+                    <div>
+                        <a href={Link.get('pnmsong', event.data.song)}>
+                            {this.props.songs[event.data.song].artist}{this.props.songs[event.data.song].artist ? " - " : ""}{this.props.songs[event.data.song].name}
+                        </a>
+                    </div>
+                </td>
+            </tr>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/labelledsection.react.js b/bemani/frontend/static/components/labelledsection.react.js
new file mode 100644
index 0000000..8910f5a
--- /dev/null
+++ b/bemani/frontend/static/components/labelledsection.react.js
@@ -0,0 +1,23 @@
+/** @jsx React.DOM */
+
+var LabelledSection = React.createClass({
+    render: function() {
+        var classname = "labelledsection"
+        if (this.props.vertical) {
+            classname = classname + " vertical";
+        } else {
+            classname = classname + " horizontal";
+        }
+        if (this.props.className) {
+            classname = classname + " " + this.props.className;
+        }
+        return (
+            <div
+                className={classname}
+            >
+                <div className="label">{this.props.label}</div>
+                <div className="content">{this.props.children}</div>
+            </div>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/longmessage.react.js b/bemani/frontend/static/components/longmessage.react.js
new file mode 100644
index 0000000..1d5da90
--- /dev/null
+++ b/bemani/frontend/static/components/longmessage.react.js
@@ -0,0 +1,43 @@
+/** @jsx React.DOM */
+
+var LongMessage = React.createClass({
+    getInitialState: function(props) {
+        return {
+            expanded: false,
+        };
+    },
+
+    render: function() {
+        var length = this.props.length ? this.props.length : 50;
+        var text = this.props.children;
+        if (text.length > length) {
+            if (this.state.expanded) {
+                return (
+                    <div className="longmessage">
+                        <pre>{text}</pre>
+                        <button
+                            className="viewmore"
+                            onClick={function(event) {
+                                this.setState({expanded: false});
+                            }.bind(this)}
+                        >view less</button>
+                    </div>
+                );
+            } else {
+                return (
+                    <div className="longmessage">
+                        <pre>{text.substring(0, length)}...</pre>
+                        <button
+                            className="viewmore"
+                            onClick={function(event) {
+                                this.setState({expanded: true});
+                            }.bind(this)}
+                        >view more</button>
+                    </div>
+                );
+            }
+        } else {
+            return <div className="longmessage"><pre>{text}</pre></div>;
+        }
+    },
+});
diff --git a/bemani/frontend/static/components/nav.react.js b/bemani/frontend/static/components/nav.react.js
new file mode 100644
index 0000000..57a8827
--- /dev/null
+++ b/bemani/frontend/static/components/nav.react.js
@@ -0,0 +1,32 @@
+/** @jsx React.DOM */
+
+var Nav = React.createClass({
+    render: function() {
+        var cls = 'nav';
+        if (this.props.active) {
+            cls += ' active';
+        }
+        cls += " " + this.props.title;
+
+        var title = (
+           <span>
+                {this.props.title}
+                {this.props.showAlert ?
+                    <span className="alert">&#9888;</span> :
+                    null
+                }
+            </span>
+        );
+        return (
+            <Button
+                className={cls}
+                disabled={this.props.disabled}
+                style={this.props.style}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title={title}
+            />
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/next.react.js b/bemani/frontend/static/components/next.react.js
new file mode 100644
index 0000000..fed9295
--- /dev/null
+++ b/bemani/frontend/static/components/next.react.js
@@ -0,0 +1,36 @@
+/** @jsx React.DOM */
+
+var Next = React.createClass({
+    render: function() {
+        return (
+            <Nav
+                disabled={this.props.disabled}
+                style={this.props.style}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title="next"
+            />
+        );
+    },
+
+    handler: function(e) {
+        if (e.which == 39) {
+            this.props.onClick(e);
+            e.preventDefault();
+        }
+    },
+
+    componentDidMount: function() {
+        this.boundhandler = this.handler.bind(this);
+        $(document).keydown(this.boundhandler);
+    },
+
+    componentWillUnmount: function() {
+        if (this.boundhandler) {
+            $(document).unbind('keydown', this.boundhandler);
+            this.boundhandler = null;
+        }
+    }
+
+});
diff --git a/bemani/frontend/static/components/prev.react.js b/bemani/frontend/static/components/prev.react.js
new file mode 100644
index 0000000..8bbdce8
--- /dev/null
+++ b/bemani/frontend/static/components/prev.react.js
@@ -0,0 +1,35 @@
+/** @jsx React.DOM */
+
+var Prev = React.createClass({
+    render: function() {
+        return (
+            <Nav
+                disabled={this.props.disabled}
+                style={this.props.style}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title="prev"
+            />
+        );
+    },
+
+    handler: function(e) {
+        if (e.which == 37) {
+            this.props.onClick(e);
+            e.preventDefault();
+        }
+    },
+
+    componentDidMount: function() {
+        this.boundhandler = this.handler.bind(this);
+        $(document).keydown(this.boundhandler);
+    },
+
+    componentWillUnmount: function() {
+        if (this.boundhandler) {
+            $(document).unbind('keydown', this.boundhandler);
+            this.boundhandler = null;
+        }
+    }
+});
diff --git a/bemani/frontend/static/components/rival.react.js b/bemani/frontend/static/components/rival.react.js
new file mode 100644
index 0000000..0b84662
--- /dev/null
+++ b/bemani/frontend/static/components/rival.react.js
@@ -0,0 +1,11 @@
+/** @jsx React.DOM */
+
+var Rival = React.createClass({
+    render: function() {
+        if (this.props.player.remote) {
+            return <span>{ this.props.player.name }</span>;
+        } else {
+            return <a href={Link.get('player', this.props.userid)}>{ this.props.player.name }</a>;
+        }
+    },
+});
diff --git a/bemani/frontend/static/components/selectarcade.react.js b/bemani/frontend/static/components/selectarcade.react.js
new file mode 100644
index 0000000..d99d28a
--- /dev/null
+++ b/bemani/frontend/static/components/selectarcade.react.js
@@ -0,0 +1,27 @@
+/** @jsx React.DOM */
+
+var SelectArcade = React.createClass({
+    render: function() {
+        return (
+            <select
+                name={this.props.name}
+                disabled={this.props.disabled}
+                value={this.props.value ? this.props.value : "__NOTHING_VALUE__"}
+                onChange={function(event) {
+                    var owner = event.target.value;
+                    if (owner == "__NOTHING_VALUE__") {
+                        owner = null;
+                    }
+                    if (this.props.onChange) {
+                        this.props.onChange(owner);
+                    }
+                }.bind(this)}
+            >
+                <option className="placeholder" value="__NOTHING_VALUE__">no arcade</option>
+                {Object.keys(this.props.arcades).map(function(key, index) {
+                    return <option value={key}>{ this.props.arcades[key] }</option>;
+                }.bind(this))}
+            </select>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/selectint.react.js b/bemani/frontend/static/components/selectint.react.js
new file mode 100644
index 0000000..9d53407
--- /dev/null
+++ b/bemani/frontend/static/components/selectint.react.js
@@ -0,0 +1,40 @@
+/** @jsx React.DOM */
+
+var SelectInt = React.createClass({
+    __renderChoices: function() {
+        if (this.props.choices instanceof Array) {
+            // Given to us as an array, the index of the value is the selected value
+            return (
+                this.props.choices.map(function(choice, index) {
+                    if (choice == null) { return null; }
+                    return <option value={index}>{ choice }</option>;
+                }.bind(this))
+            );
+        } else {
+            // Assume given as an object, the keys are the values and the values are the displays
+            return (
+                Object.keys(this.props.choices).map(function(choice) {
+                    return <option value={choice}>{ this.props.choices[choice] }</option>;
+                }.bind(this))
+            );
+        }
+    },
+
+    render: function() {
+        return (
+            <select
+                name={this.props.name}
+                disabled={this.props.disabled}
+                value={this.props.value ? this.props.value : 0}
+                onChange={function(event) {
+                    var integer = parseInt(event.target.value);
+                    if (this.props.onChange) {
+                        this.props.onChange(integer);
+                    }
+                }.bind(this)}
+            >
+                {this.__renderChoices()}
+            </select>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/selectuser.react.js b/bemani/frontend/static/components/selectuser.react.js
new file mode 100644
index 0000000..110a2f5
--- /dev/null
+++ b/bemani/frontend/static/components/selectuser.react.js
@@ -0,0 +1,27 @@
+/** @jsx React.DOM */
+
+var SelectUser = React.createClass({
+    render: function() {
+        return (
+            <select
+                name={this.props.name}
+                disabled={this.props.disabled}
+                value={this.props.value ? this.props.value : "__NOBODY_VALUE__"}
+                onChange={function(event) {
+                    var owner = event.target.value;
+                    if (owner == "__NOBODY_VALUE__") {
+                        owner = null;
+                    }
+                    if (this.props.onChange) {
+                        this.props.onChange(owner);
+                    }
+                }.bind(this)}
+            >
+                <option className="placeholder" value="__NOBODY_VALUE__">nobody</option>
+                {this.props.usernames.map(function(username) {
+                    return <option value={username}>{ username }</option>;
+                }.bind(this))}
+            </select>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/table.react.js b/bemani/frontend/static/components/table.react.js
new file mode 100644
index 0000000..080b593
--- /dev/null
+++ b/bemani/frontend/static/components/table.react.js
@@ -0,0 +1,153 @@
+/** @jsx React.DOM */
+
+var Table = React.createClass({
+    getInitialState: function(props) {
+        var sortCol = -1;
+        var sortDir = -1;
+        this.props.columns.map(function(column, index) {
+            if (column.sort) {
+                if ((this.props.defaultsort && column.name == this.props.defaultsort) || sortCol == -1) {
+                    sortCol = index;
+                    sortDir = column.reverse ? 1 : -1;
+                }
+            }
+        }.bind(this));
+
+        return {
+            offset: 0,
+            sortCol: sortCol,
+            sortDir: sortDir,
+            key: Math.floor(Math.random() * 573573573),
+        };
+    },
+
+    colLength: function() {
+        var len = 0;
+        this.props.columns.map(function(column) {
+            if (column.hidden) { return; }
+            len = len + 1;
+        }.bind(this));
+        return len;
+    },
+
+    sort: function() {
+        if (this.state.sortCol < 0 || this.state.sortCol >= this.colLength()) {
+            return this.props.rows;
+        } else if (this.props.rows.length == 0) {
+            return [];
+        } else {
+            return this.props.rows.concat().sort(function(a, b) {
+                var val = this.props.columns[this.state.sortCol].sort(a, b);
+                if (this.state.sortDir < 0) {
+                    return val;
+                } else {
+                    return -val;
+                }
+            }.bind(this));
+        }
+    },
+
+    render: function() {
+        if (this.props.rows.length == 0) {
+            var msg = this.props.emptymessage ? this.props.emptymessage : 'There is no data to display.';
+            return <span className="placeholder">{msg}</span>;
+        }
+
+        return (
+            <table className={this.props.className} key={this.props.key ? this.props.key : this.state.key}>
+                <thead>
+                    <tr>
+                        {this.props.columns.map(function(column, index) {
+                            if (column.hidden) { return null; }
+
+                            var sort = <span />;
+                            var click = null;
+                            if (index == this.state.sortCol) {
+                                if (this.state.sortDir < 0) {
+                                    sort = <span className="sort"> &#8593;</span>;
+                                    click = function() {
+                                        this.setState({sortDir: 1});
+                                    }.bind(this);
+                                } else {
+                                    sort = <span className="sort"> &#8595;</span>;
+                                    click = function() {
+                                        this.setState({sortDir: -1});
+                                    }.bind(this);
+                                }
+                            } else {
+                                if (column.sort) {
+                                    sort = <span className="sort"> &#8597;</span>;
+                                    click = function() {
+                                        this.setState({sortCol: index, sortDir: column.reverse ? 1 : -1});
+                                    }.bind(this);
+                                }
+                            }
+
+                            if (column.action) {
+                                return (
+                                    <th className="action" onClick={click}>{column.name}{sort}</th>
+                                );
+                            } else {
+                                return (
+                                    <th onClick={click}>{column.name}{sort}</th>
+                                );
+                            }
+                        }.bind(this))}
+                    </tr>
+                </thead>
+                <tbody>
+                    {this.sort().map(function(row, index) {
+                        if (this.props.paginate) {
+                            if (index < this.state.offset || index >= this.state.offset + this.props.paginate) {
+                                return null;
+                            }
+                        }
+
+                        return (
+                            <tr>
+                                {this.props.columns.map(function(column) {
+                                    if (column.hidden) { return null; }
+
+                                    return (
+                                        <td className={column.action ? "edit" : column.className}>{
+                                            column.render(row)
+                                        }</td>
+                                    );
+                                }.bind(this))}
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                { this.props.paginate ?
+                    <tfoot>
+                        <tr>
+                            <td colSpan={this.colLength()}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.props.paginate;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.props.paginate) < this.props.rows.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.props.paginate;
+                                         if (page >= this.props.rows.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.props.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more data...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot> : null
+                }
+            </table>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/timestamp.react.js b/bemani/frontend/static/components/timestamp.react.js
new file mode 100644
index 0000000..878ed9c
--- /dev/null
+++ b/bemani/frontend/static/components/timestamp.react.js
@@ -0,0 +1,15 @@
+/** @jsx React.DOM */
+
+var Timestamp = React.createClass({
+    render: function() {
+        if (this.props.timestamp <= 0) {
+            return <div className="timestamp">N/A</div>;
+        }
+
+        var t = new Date(this.props.timestamp * 1000);
+        var formatted = t.format('Y/m/d @ g:i:s a');
+        return (
+            <div className="timestamp">{ formatted }</div>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/tip.react.js b/bemani/frontend/static/components/tip.react.js
new file mode 100644
index 0000000..e6fdffc
--- /dev/null
+++ b/bemani/frontend/static/components/tip.react.js
@@ -0,0 +1,12 @@
+/** @jsx React.DOM */
+
+var Tip = React.createClass({
+    render: function() {
+        return (
+            <div className="tooltip">
+                {this.props.children}
+                <span className="tooltiptext">{this.props.text}</span>
+            </div>
+        );
+    },
+});
diff --git a/bemani/frontend/static/components/toggle.react.js b/bemani/frontend/static/components/toggle.react.js
new file mode 100644
index 0000000..3173d38
--- /dev/null
+++ b/bemani/frontend/static/components/toggle.react.js
@@ -0,0 +1,16 @@
+/** @jsx React.DOM */
+
+var Toggle = React.createClass({
+    render: function() {
+        return (
+            <Button
+                className="toggle"
+                disabled={this.props.disabled}
+                onClick={function(event) {
+                    this.props.onClick(event);
+                }.bind(this)}
+                title={this.props.title ? this.props.title : 'toggle'}
+            />
+        );
+    },
+});
diff --git a/bemani/frontend/static/controllers/account/account.react.js b/bemani/frontend/static/controllers/account/account.react.js
new file mode 100644
index 0000000..67fc24a
--- /dev/null
+++ b/bemani/frontend/static/controllers/account/account.react.js
@@ -0,0 +1,268 @@
+/*** @jsx React.DOM */
+
+var account_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            email: window.email,
+            new_email: window.email,
+            email_password: '',
+            editing_email: false,
+            username: window.username,
+            editing_pin: false,
+            new_pin: '',
+            editing_password: false,
+            old_password: '',
+            new_password1: '',
+            new_password2: '',
+        };
+    },
+
+    saveEmail: function(event) {
+        AJAX.post(
+            Link.get('updateemail'),
+            {
+                email: this.state.new_email,
+                password: this.state.email_password,
+            },
+            function(response) {
+                this.setState({
+                    email: response.email,
+                    new_email: response.email,
+                    email_password: '',
+                    editing_email: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    savePin: function(event) {
+        AJAX.post(
+            Link.get('updatepin'),
+            {pin: this.state.new_pin},
+            function(response) {
+                this.setState({
+                    new_pin: '',
+                    editing_pin: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    savePassword: function(event) {
+        AJAX.post(
+            Link.get('updatepassword'),
+            {
+                old: this.state.old_password,
+                new1: this.state.new_password1,
+                new2: this.state.new_password2,
+            },
+            function(response) {
+                this.setState({
+                    old_password: '',
+                    new_password1: '',
+                    new_password2: '',
+                    editing_password: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderUsername: function() {
+        return (
+            <LabelledSection vertical={true} label="Username">{ this.state.username }</LabelledSection>
+        );
+    },
+
+    renderPassword: function() {
+        return (
+            <LabelledSection vertical={true} label="Password">{
+                !this.state.editing_password ?
+                    <span>
+                        <span>&bull;&bull;&bull;&bull;&bull;&bull;</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_password: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.savePassword}>
+                        <div>
+                            <label for="old">Current password:</label>
+                            <input
+                                type="password"
+                                value={this.state.old_password}
+                                onChange={function(event) {
+                                    this.setState({old_password: event.target.value});
+                                }.bind(this)}
+                                name="old"
+                            />
+                        </div>
+                        <div>
+                            <label for="new1">New password:</label>
+                            <input
+                                type="password"
+                                value={this.state.new_password1}
+                                onChange={function(event) {
+                                    this.setState({new_password1: event.target.value});
+                                }.bind(this)}
+                                name="new1"
+                            />
+                        </div>
+                        <div>
+                            <label for="new2">New password (again):</label>
+                            <input
+                                type="password"
+                                value={this.state.new_password2}
+                                onChange={function(event) {
+                                    this.setState({new_password2: event.target.value});
+                                }.bind(this)}
+                                name="new2"
+                            />
+                        </div>
+                        <div className="buttons">
+                            <input
+                                type="submit"
+                                value="save"
+                            />
+                            <input
+                                type="button"
+                                value="cancel"
+                                onClick={function(event) {
+                                    this.setState({
+                                        old_password: '',
+                                        new_password1: '',
+                                        new_password2: '',
+                                        editing_password: false,
+                                    });
+                                }.bind(this)}
+                            />
+                        </div>
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderEmail: function() {
+        return (
+            <LabelledSection vertical={true} label="Email Address">{
+                !this.state.editing_email ?
+                    <span>
+                        <span>{ this.state.email }</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_email: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveEmail}>
+                        <div>
+                            <label for="old">Current password:</label>
+                            <input
+                                type="password"
+                                value={this.state.email_password}
+                                onChange={function(event) {
+                                    this.setState({email_password: event.target.value});
+                                }.bind(this)}
+                                name="old"
+                            />
+                        </div>
+                        <div>
+                            <label for="email">New email address:</label>
+                            <input
+                                type="text"
+                                value={this.state.new_email}
+                                onChange={function(event) {
+                                    this.setState({new_email: event.target.value});
+                                }.bind(this)}
+                                name="email"
+                            />
+                        </div>
+                        <div className="buttons">
+                            <input
+                                type="submit"
+                                value="save"
+                            />
+                            <input
+                                type="button"
+                                value="cancel"
+                                onClick={function(event) {
+                                    this.setState({
+                                        new_email: this.state.email,
+                                        email_password: '',
+                                        editing_email: false,
+                                    });
+                                }.bind(this)}
+                            />
+                        </div>
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderPIN: function() {
+        return (
+            <LabelledSection vertical={true} label="PIN">{
+                !this.state.editing_pin ?
+                    <span>
+                        <span>&bull;&bull;&bull;&bull;</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_pin: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.savePin}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="4"
+                            size="4"
+                            value={this.state.new_pin}
+                            onChange={function(event) {
+                                var intRegex = /^\d*$/;
+                                if (event.target.value.length <= 4 && intRegex.test(event.target.value)) {
+                                    this.setState({new_pin: event.target.value});
+                                }
+                            }.bind(this)}
+                            name="pin"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_pin: '',
+                                    editing_pin: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    {this.renderUsername()}
+                    {this.renderPassword()}
+                    {this.renderEmail()}
+                    {this.renderPIN()}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(account_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/account/cards.react.js b/bemani/frontend/static/controllers/account/cards.react.js
new file mode 100644
index 0000000..8baad05
--- /dev/null
+++ b/bemani/frontend/static/controllers/account/cards.react.js
@@ -0,0 +1,109 @@
+/*** @jsx React.DOM */
+
+var card_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            cards: window.cards,
+            newCard: '',
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshCardList();
+    },
+
+    addNewCard: function(event) {
+        AJAX.post(
+            Link.get('addcard'),
+            {card: this.state.newCard},
+            function(response) {
+                this.setState({
+                    cards: response.cards,
+                    newCard: '',
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    deleteExistingCard: function(card) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Card',
+            content: 'Are you sure you want to delete this card from your account?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removecard'),
+                            {card: card},
+                            function(response) {
+                                this.setState({
+                                    cards: response.cards,
+                                    newCard: '',
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+    },
+
+    refreshCardList: function() {
+        AJAX.get(
+            Link.get('listcards'),
+            function(response) {
+                this.setState({
+                    cards: response.cards,
+                });
+                setTimeout(this.refreshCardList, 2500);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <h3>Your Cards</h3>
+                    {this.state.cards.map(function(card) {
+                        return (
+                            <div>
+                                <Card number={card} />
+                                <Delete
+                                    onClick={this.deleteExistingCard.bind(this, card)}
+                                />
+                            </div>
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+                    <h3>Add Card</h3>
+                    <form onSubmit={this.addNewCard}>
+                        <input
+                            type="text"
+                            className="inline"
+                            value={this.state.newCard}
+                            onChange={function(event) {
+                                this.setState({newCard: event.target.value});
+                            }.bind(this)}
+                            name="card_number"
+                        />
+                        <input type="submit" value="add card" />
+                    </form>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(card_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/api.react.js b/bemani/frontend/static/controllers/admin/api.react.js
new file mode 100644
index 0000000..10686a3
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/api.react.js
@@ -0,0 +1,601 @@
+/*** @jsx React.DOM */
+
+var api_management = React.createClass({
+    getInitialState: function(props) {
+        var info = this.scheduleServerInfo(window.servers);
+        return {
+            new_client: {
+                name: '',
+            },
+            new_server: {
+                uri: 'https://',
+                token: '',
+            },
+            info: info,
+            clients: window.clients,
+            servers: window.servers,
+            editing_client: null,
+            editing_server: null,
+        };
+    },
+
+    scheduleServerInfo: function(servers) {
+        var info = {};
+
+        servers.map(function(server) {
+            if (this.state && this.state.info[server.id]) {
+                // We already got this info
+                info[server.id] = this.state.info[server.id];
+                return;
+            }
+
+            // We don't have this looked up yet
+            info[server.id] = {loading: true};
+            AJAX.get(
+               Link.get('queryserver', server.id),
+               function(response) {
+                   var sinfo = this.state.info;
+                   sinfo[server.id] = response;
+                   sinfo[server.id].loading = false;
+                   this.setState({info: sinfo});
+               }.bind(this)
+            );
+        }.bind(this));
+
+        return info;
+    },
+
+    addNewClient: function(event) {
+        AJAX.post(
+            Link.get('addclient'),
+            {client: this.state.new_client},
+            function(response) {
+                this.setState({
+                    clients: response.clients,
+                    new_client: {
+                        name: '',
+                    },
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveClient: function(event) {
+        AJAX.post(
+            Link.get('updateclient'),
+            {client: this.state.editing_client},
+            function(response) {
+                this.setState({
+                    clients: response.clients,
+                    editing_client: null,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    deleteExistingClient: function(event, clientid) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Client',
+            content: 'Are you sure you want to delete and de-auth this client from the network?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removeclient'),
+                            {clientid: clientid},
+                            function(response) {
+                                this.setState({
+                                    clients: response.clients,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+        event.preventDefault();
+    },
+
+    addNewServer: function(event) {
+        AJAX.post(
+            Link.get('addserver'),
+            {server: this.state.new_server},
+            function(response) {
+                // Schedule probe of new server just added
+                var info = this.scheduleServerInfo(response.servers);
+                this.setState({
+                    servers: response.servers,
+                    info: info,
+                    new_server: {
+                        uri: 'https://',
+                        token: '',
+                    },
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveServer: function(event) {
+        var serverid = this.state.editing_server.id;
+        AJAX.post(
+            Link.get('updateserver'),
+            {server: this.state.editing_server},
+            function(response) {
+                // Kill our existing info so we can refresh with changes
+                delete this.state.info[serverid];
+                var info = this.scheduleServerInfo(response.servers);
+                this.setState({
+                    info: info,
+                    servers: response.servers,
+                    editing_server: null,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    deleteExistingServer: function(event, serverid) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Server',
+            content: 'Are you sure you want to delete this remote server from the network?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removeserver'),
+                            {serverid: serverid},
+                            function(response) {
+                                // Kill the entry we no longer need
+                                var info = this.state.info;
+                                delete info[serverid];
+                                this.setState({
+                                    info: info,
+                                    servers: response.servers,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+        event.preventDefault();
+    },
+
+    renderClientEditButton: function(client) {
+        if(this.state.editing_client) {
+            if (this.state.editing_client.id == client.id) {
+                return (
+                    <span>
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    editing_client: null,
+                                });
+                            }.bind(this)}
+                        />
+                    </span>
+                );
+            } else {
+                return <span></span>;
+            }
+        } else {
+            return (
+                <span>
+                    <Edit
+                        onClick={function(event) {
+                            var editing_client = null;
+                            this.state.clients.map(function(a) {
+                                if (a.id == client.id) {
+                                    editing_client = jQuery.extend(true, {}, a);
+                                }
+                            });
+                            this.setState({
+                                editing_client: editing_client,
+                            });
+                        }.bind(this)}
+                    />
+                    <Delete
+                        onClick={function(event) {
+                            this.deleteExistingClient(event, client.id);
+                        }.bind(this)}
+                    />
+                </span>
+            );
+        }
+    },
+
+    renderClientName: function(client) {
+        if (this.state.editing_client && client.id == this.state.editing_client.id) {
+            return <input
+                name="name"
+                type="text"
+                value={ this.state.editing_client.name }
+                onChange={function(event) {
+                    var client = this.state.editing_client;
+                    client.name = event.target.value;
+                    this.setState({
+                        editing_client: client,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ client.name }</span>;
+        }
+    },
+
+    sortClientName: function(a, b) {
+        return a.name.localeCompare(b.name);
+    },
+
+    renderClientToken: function(client) {
+        return <span>{ client.token }</span>;
+    },
+
+    sortClientToken: function(a, b) {
+        return a.token.localeCompare(b.token);
+    },
+
+    renderServerEditButton: function(server) {
+        if(this.state.editing_server) {
+            if (this.state.editing_server.id == server.id) {
+                return (
+                    <span>
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    editing_server: null,
+                                });
+                            }.bind(this)}
+                        />
+                    </span>
+                );
+            } else {
+                return <span></span>;
+            }
+        } else {
+            return (
+                <span>
+                    <Edit
+                        onClick={function(event) {
+                            var editing_server = null;
+                            this.state.servers.map(function(a) {
+                                if (a.id == server.id) {
+                                    editing_server = jQuery.extend(true, {}, a);
+                                }
+                            });
+                            this.setState({
+                                editing_server: editing_server,
+                            });
+                        }.bind(this)}
+                    />
+                    <Delete
+                        onClick={function(event) {
+                            this.deleteExistingServer(event, server.id);
+                        }.bind(this)}
+                    />
+                </span>
+            );
+        }
+    },
+
+    renderServerURI: function(server) {
+        if (this.state.editing_server && server.id == this.state.editing_server.id) {
+            return <input
+                name="uri"
+                type="text"
+                value={ this.state.editing_server.uri }
+                onChange={function(event) {
+                    var server = this.state.editing_server;
+                    server.uri = event.target.value;
+                    this.setState({
+                        editing_server: server,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ server.uri }</span>;
+        }
+    },
+
+    sortServerURI: function(a, b) {
+        return a.uri.localeCompare(b.uri);
+    },
+
+    renderServerToken: function(server) {
+        if (this.state.editing_server && server.id == this.state.editing_server.id) {
+            return <input
+                name="token"
+                type="text"
+                value={ this.state.editing_server.token }
+                onChange={function(event) {
+                    var server = this.state.editing_server;
+                    server.token = event.target.value;
+                    this.setState({
+                        editing_server: server,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ server.token }</span>;
+        }
+    },
+
+    sortServerToken: function(a, b) {
+        return a.token.localeCompare(b.token);
+    },
+
+    renderServerInfo: function(server) {
+        if (!this.state.info[server.id]) {
+            return <span className='placeholder'>No info!</span>;
+        }
+        if (this.state.info[server.id].loading) {
+            return (
+                <span>
+                     <img className="loading" src={Link.get('static', 'loading-16.gif')} />
+                     {' querying server for info...'}
+                 </span>
+             );
+        }
+        if (this.state.info[server.id].status == 'badauth') {
+            return (
+                <span>Invalid auth token provided!</span>
+            );
+        }
+        if (this.state.info[server.id].status == 'error') {
+            return (
+                <span>Error requesting server info!</span>
+            );
+        }
+
+        return (
+            <span>
+                <div>
+                    <b>{this.state.info[server.id].name}</b>
+                    {' administered by '}
+                    <a href={'mailto:' + this.state.info[server.id].email}>{this.state.info[server.id].email}</a>
+                </div>
+                { this.state.info[server.id].status == 'badversion' ?
+                    <span className='placeholder'>This server supports an incompatible version of the API!</span> : null
+                }
+            </span>
+        );
+    },
+
+    renderServerAllowedData: function(server) {
+        if (this.state.editing_server && server.id == this.state.editing_server.id) {
+            return (
+                <span>
+                    <div>
+                        <input
+                            name="stats"
+                            id="stats"
+                            type="checkbox"
+                            checked={ this.state.editing_server.allow_stats }
+                            onChange={function(event) {
+                                var server = this.state.editing_server;
+                                server.allow_stats = event.target.checked;
+                                this.setState({
+                                    editing_server: server,
+                                });
+                            }.bind(this)}
+                        />
+                        <label htmlFor="stats">play statistics</label>
+                    </div>
+                    <div>
+                        <input
+                            name="scores"
+                            id="scores"
+                            type="checkbox"
+                            checked={ this.state.editing_server.allow_scores }
+                            onChange={function(event) {
+                                var server = this.state.editing_server;
+                                server.allow_scores = event.target.checked;
+                                this.setState({
+                                    editing_server: server,
+                                });
+                            }.bind(this)}
+                        />
+                        <label htmlFor="scores">rivals and scores</label>
+                    </div>
+                </span>
+            );
+        } else {
+            if (!server.allow_stats && !server.allow_scores) {
+                return <span className="placeholder">remote data fetching disabled</span>;
+            }
+            var enabled = [];
+            if (server.allow_stats) {
+                enabled.push('play statistics');
+            }
+            if (server.allow_scores) {
+                enabled.push('rivals');
+                enabled.push('scores');
+            }
+            return <span>{ enabled.join(', ') }</span>;
+        }
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <h3>Authorized Clients</h3>
+                    <form className="inline" onSubmit={this.saveClient}>
+                        <Table
+                            className="list client"
+                            columns={[
+                                {
+                                    name: 'Name',
+                                    render: this.renderClientName,
+                                    sort: this.sortClientName,
+                                },
+                                {
+                                    name: 'Auth Token',
+                                    render: this.renderClientToken,
+                                    sort: this.sortClientToken,
+                                },
+                                {
+                                    name: '',
+                                    render: this.renderClientEditButton,
+                                    action: true,
+                                },
+                            ]}
+                            rows={this.state.clients}
+                            emptymessage="There are no clients authorized to talk to this network."
+                        />
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>Add Client</h3>
+                    <form className="inline" onSubmit={this.addNewClient}>
+                        <table className="add client">
+                            <thead>
+                                <tr>
+                                    <th>Name</th>
+                                    <th></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            name="name"
+                                            type="text"
+                                            value={ this.state.new_client.name }
+                                            onChange={function(event) {
+                                                var client = this.state.new_client;
+                                                client.name = event.target.value;
+                                                this.setState({new_client: client});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            type="submit"
+                                            value="save"
+                                        />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>Remote Servers</h3>
+                    <form className="inline" onSubmit={this.saveServer}>
+                        <Table
+                            className="list server"
+                            columns={[
+                                {
+                                    name: 'URI',
+                                    render: this.renderServerURI,
+                                    sort: this.sortServerURI,
+                                },
+                                {
+                                    name: 'Auth Token',
+                                    render: this.renderServerToken,
+                                    sort: this.sortServerToken,
+                                },
+                                {
+                                    name: 'Server Info',
+                                    render: this.renderServerInfo,
+                                },
+                                {
+                                    name: 'Allowed Data',
+                                    render: this.renderServerAllowedData,
+                                },
+                                {
+                                    name: '',
+                                    render: this.renderServerEditButton,
+                                    action: true,
+                                },
+                            ]}
+                            rows={this.state.servers}
+                            emptymessage="There are no remote servers on this network."
+                        />
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>Add Remote Server</h3>
+                    <form className="inline" onSubmit={this.addNewServer}>
+                        <table className="add server">
+                            <thead>
+                                <tr>
+                                    <th>Name</th>
+                                    <th>Token</th>
+                                    <th></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            name="uri"
+                                            type="text"
+                                            value={ this.state.new_server.uri }
+                                            onChange={function(event) {
+                                                var server = this.state.new_server;
+                                                server.uri = event.target.value;
+                                                this.setState({new_server: server});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            name="token"
+                                            type="text"
+                                            value={ this.state.new_server.token }
+                                            onChange={function(event) {
+                                                var server = this.state.new_server;
+                                                server.token = event.target.value;
+                                                this.setState({new_server: server});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            type="submit"
+                                            value="save"
+                                        />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(api_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/arcades.react.js b/bemani/frontend/static/controllers/admin/arcades.react.js
new file mode 100644
index 0000000..93af99f
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/arcades.react.js
@@ -0,0 +1,467 @@
+/*** @jsx React.DOM */
+
+var card_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            new_arcade: {
+                name: '',
+                description: '',
+                paseli_enabled: window.paseli_enabled,
+                paseli_infinite: window.paseli_infinite,
+                mask_services_url: window.mask_services_url,
+                owners: [null],
+            },
+            arcades: window.arcades,
+            usernames: window.usernames,
+            editing_arcade: null,
+        };
+    },
+
+    addNewArcade: function(event) {
+        AJAX.post(
+            Link.get('addarcade'),
+            {arcade: this.state.new_arcade},
+            function(response) {
+                this.setState({
+                    arcades: response.arcades,
+                    new_arcade: {
+                        name: '',
+                        description: '',
+                        paseli_enabled: window.paseli_enabled,
+                        paseli_infinite: window.paseli_infinite,
+                        mask_services_url: window.mask_services_url,
+                        owners: [null],
+                    },
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveArcade: function(event) {
+        AJAX.post(
+            Link.get('updatearcade'),
+            {arcade: this.state.editing_arcade},
+            function(response) {
+                this.setState({
+                    arcades: response.arcades,
+                    editing_arcade: null,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    deleteExistingArcade: function(event, arcadeid) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Arcade',
+            content: 'Are you sure you want to delete this arcade from the network?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removearcade'),
+                            {arcadeid: arcadeid},
+                            function(response) {
+                                this.setState({
+                                    arcades: response.arcades,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+        event.preventDefault();
+    },
+
+    renderEditButton: function(arcade) {
+        if(this.state.editing_arcade) {
+            if (this.state.editing_arcade.id == arcade.id) {
+                return (
+                    <span>
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    editing_arcade: null,
+                                });
+                            }.bind(this)}
+                        />
+                    </span>
+                );
+            } else {
+                return <span></span>;
+            }
+        } else {
+            return (
+                <span>
+                    <Edit
+                        onClick={function(event) {
+                            var editing_arcade = null;
+                            this.state.arcades.map(function(a) {
+                                if (a.id == arcade.id) {
+                                    editing_arcade = jQuery.extend(true, {}, a);
+                                    editing_arcade.owners.push(null);
+                                }
+                            });
+                            this.setState({
+                                editing_arcade: editing_arcade,
+                            });
+                        }.bind(this)}
+                    />
+                    <Delete
+                        onClick={function(event) {
+                            this.deleteExistingArcade(event, arcade.id);
+                        }.bind(this)}
+                    />
+                </span>
+            );
+        }
+    },
+
+    renderName: function(arcade) {
+        if (this.state.editing_arcade && arcade.id == this.state.editing_arcade.id) {
+            return <input
+                name="name"
+                type="text"
+                value={ this.state.editing_arcade.name }
+                onChange={function(event) {
+                    var arcade = this.state.editing_arcade;
+                    arcade.name = event.target.value;
+                    this.setState({
+                        editing_arcade: arcade,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ arcade.name }</span>;
+        }
+    },
+
+    sortName: function(a, b) {
+        return a.name.localeCompare(b.name);
+    },
+
+    renderDescription: function(arcade) {
+        if (this.state.editing_arcade && arcade.id == this.state.editing_arcade.id) {
+            return <input
+                name="description"
+                type="text"
+                value={ this.state.editing_arcade.description }
+                onChange={function(event) {
+                    var arcade = this.state.editing_arcade;
+                    arcade.description = event.target.value;
+                    this.setState({
+                        editing_arcade: arcade,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ arcade.description }</span>;
+        }
+    },
+
+    sortDescription: function(a, b) {
+        return a.description.localeCompare(b.description);
+    },
+
+    renderOwners: function(arcade) {
+        if (this.state.editing_arcade && arcade.id == this.state.editing_arcade.id) {
+            return this.state.editing_arcade.owners.map(function(owner, index) {
+                return (
+                    <div>
+                        <SelectUser
+                            name="owner"
+                            key={index}
+                            value={ this.state.editing_arcade.owners[index] }
+                            usernames={ this.state.usernames }
+                            onChange={function(owner) {
+                                var arcade = this.state.editing_arcade;
+                                if (owner) {
+                                    /* Update the owner */
+                                    arcade.owners[index] = owner;
+                                    if (arcade.owners[arcade.owners.length - 1]) {
+                                        arcade.owners.push(null);
+                                    }
+                                } else {
+                                    /* We should kill this if there is more
+                                       than one owner. */
+                                    if (arcade.owners.length > 1) {
+                                        arcade.owners.splice(index, 1);
+                                    } else {
+                                        arcade.owners[index] = null;
+                                    }
+                                }
+                                this.setState({
+                                    editing_arcade: arcade,
+                                });
+                            }.bind(this)}
+                        />
+                    </div>
+                );
+            }.bind(this))
+        } else {
+            return (
+                (arcade.owners.length > 0) ?
+                    <ul className="ownerlist">{
+                        arcade.owners.map(function(owner) {
+                            return <li>{ owner }</li>;
+                        }.bind(this))
+                    }</ul> :
+                    <span className="placeholder">nobody</span>
+            );
+        }
+    },
+
+    renderPaseliEnabled: function(arcade) {
+        if (this.state.editing_arcade && arcade.id == this.state.editing_arcade.id) {
+            return <input
+                name="paseli_enabled"
+                type="checkbox"
+                checked={ this.state.editing_arcade.paseli_enabled }
+                onChange={function(event) {
+                    var arcade = this.state.editing_arcade;
+                    arcade.paseli_enabled = event.target.checked;
+                    this.setState({
+                        editing_arcade: arcade,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ arcade.paseli_enabled ? "yes" : "no"  }</span>;
+        }
+    },
+
+    renderPaseliInfinite: function(arcade) {
+        if (this.state.editing_arcade && arcade.id == this.state.editing_arcade.id) {
+            return <input
+                name="paseli_infinite"
+                type="checkbox"
+                checked={ this.state.editing_arcade.paseli_infinite }
+                onChange={function(event) {
+                    var arcade = this.state.editing_arcade;
+                    arcade.paseli_infinite = event.target.checked;
+                    this.setState({
+                        editing_arcade: arcade,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ arcade.paseli_infinite ? "yes" : "no"  }</span>;
+        }
+    },
+
+    renderMaskServicesURL: function(arcade) {
+        if (this.state.editing_arcade && arcade.id == this.state.editing_arcade.id) {
+            return <input
+                name="mask_services_url"
+                type="checkbox"
+                checked={ this.state.editing_arcade.mask_services_url }
+                onChange={function(event) {
+                    var arcade = this.state.editing_arcade;
+                    arcade.mask_services_url = event.target.checked;
+                    this.setState({
+                        editing_arcade: arcade,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return <span>{ arcade.mask_services_url ? "yes" : "no"  }</span>;
+        }
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <form className="inline" onSubmit={this.saveArcade}>
+                        <Table
+                            className="list arcade"
+                            columns={[
+                                {
+                                    name: 'Name',
+                                    render: this.renderName,
+                                    sort: this.sortName,
+                                },
+                                {
+                                    name: 'Description',
+                                    render: this.renderDescription,
+                                    sort: this.sortDescription,
+                                },
+                                {
+                                    name: 'Owners',
+                                    render: this.renderOwners,
+                                },
+                                {
+                                    name: 'PASELI Enabled',
+                                    render: this.renderPaseliEnabled,
+                                },
+                                {
+                                    name: 'PASELI Infinite',
+                                    render: this.renderPaseliInfinite,
+                                },
+                                {
+                                    name: 'Mask Web Address',
+                                    render: this.renderMaskServicesURL,
+                                },
+                                {
+                                    name: '',
+                                    render: this.renderEditButton,
+                                    action: true,
+                                },
+                            ]}
+                            rows={this.state.arcades}
+                            emptymessage="There are no arcades on this network."
+                        />
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>Add Arcade</h3>
+                    <form className="inline" onSubmit={this.addNewArcade}>
+                        <table className="add arcade">
+                            <thead>
+                                <tr>
+                                    <th>Name</th>
+                                    <th>Description</th>
+                                    <th>Owners</th>
+                                    <th>PASELI Enabled</th>
+                                    <th>PASELI Infinite</th>
+                                    <th>Mask Web Address</th>
+                                    <th></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            name="name"
+                                            type="text"
+                                            value={ this.state.new_arcade.name }
+                                            onChange={function(event) {
+                                                var arcade = this.state.new_arcade;
+                                                arcade.name = event.target.value;
+                                                this.setState({new_arcade: arcade});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            name="description"
+                                            type="text"
+                                            value={ this.state.new_arcade.description }
+                                            onChange={function(event) {
+                                                var arcade = this.state.new_arcade;
+                                                arcade.description = event.target.value;
+                                                this.setState({new_arcade: arcade});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>{
+                                        this.state.new_arcade.owners.map(function(owner, index) {
+                                            return (
+                                                <div>
+                                                    <SelectUser
+                                                        name="owner"
+                                                        key={index}
+                                                        value={ this.state.new_arcade.owners[index] }
+                                                        usernames={ this.state.usernames }
+                                                        onChange={function(owner) {
+                                                            var arcade = this.state.new_arcade;
+                                                            if (owner) {
+                                                                /* Update the owner */
+                                                                arcade.owners[index] = owner;
+                                                                if (arcade.owners[arcade.owners.length - 1]) {
+                                                                    arcade.owners.push(null);
+                                                                }
+                                                            } else {
+                                                                /* We should kill this if there is more
+                                                                   than one owner. */
+                                                                if (arcade.owners.length > 1) {
+                                                                    arcade.owners.splice(index, 1);
+                                                                } else {
+                                                                    arcade.owners[index] = null;
+                                                                }
+                                                            }
+                                                            this.setState({
+                                                                new_arcade: arcade,
+                                                            });
+                                                        }.bind(this)}
+                                                    />
+                                                </div>
+                                            );
+                                        }.bind(this))
+                                    }</td>
+                                    <td>
+                                        <input
+                                            name="paseli_enabled"
+                                            type="checkbox"
+                                            checked={ this.state.new_arcade.paseli_enabled }
+                                            onChange={function(event) {
+                                                var arcade = this.state.new_arcade;
+                                                arcade.paseli_enabled = event.target.checked;
+                                                this.setState({
+                                                    new_arcade: arcade,
+                                                });
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            name="paseli_infinite"
+                                            type="checkbox"
+                                            checked={ this.state.new_arcade.paseli_infinite }
+                                            onChange={function(event) {
+                                                var arcade = this.state.new_arcade;
+                                                arcade.paseli_infinite = event.target.checked;
+                                                this.setState({
+                                                    new_arcade: arcade,
+                                                });
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            name="mask_services_url"
+                                            type="checkbox"
+                                            checked={ this.state.new_arcade.mask_services_url }
+                                            onChange={function(event) {
+                                                var arcade = this.state.new_arcade;
+                                                arcade.mask_services_url = event.target.checked;
+                                                this.setState({
+                                                    new_arcade: arcade,
+                                                });
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            type="submit"
+                                            value="save"
+                                        />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(card_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/cards.react.js b/bemani/frontend/static/controllers/admin/cards.react.js
new file mode 100644
index 0000000..eab95a4
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/cards.react.js
@@ -0,0 +1,187 @@
+/*** @jsx React.DOM */
+
+var card_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            cards: window.cards,
+            usernames: window.usernames,
+            new_card: {
+                number: '',
+                owner: null,
+            },
+        };
+    },
+
+    addNewCard: function(event) {
+        if (!this.state.new_card.owner) {
+            Messages.error('You must select an owner for new cards!');
+        } else {
+            AJAX.post(
+                Link.get('addcard'),
+                {card: this.state.new_card},
+                function(response) {
+                    this.setState({
+                        cards: response.cards,
+                        new_card: {
+                            number: '',
+                            owner: null,
+                        },
+                    });
+                }.bind(this)
+            );
+        }
+        event.preventDefault();
+    },
+
+    deleteExistingCard: function(card) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Card',
+            content: 'Are you sure you want to delete this card?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removecard'),
+                            {card: card},
+                            function(response) {
+                                this.setState({
+                                    cards: response.cards,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+    },
+
+    renderNumber: function(card) {
+        return <Card number={card.number} />;
+    },
+
+    sortNumber: function(a, b) {
+        return a.number.localeCompare(b.number);
+    },
+
+    renderOwner: function(card) {
+        if (card.owner) {
+            return (
+                <span>{ card.owner }</span>
+            );
+        } else {
+            return (
+                <span className="placeholder">
+                    anonymous account
+                </span>
+            );
+        }
+    },
+
+    sortOwner: function(a, b) {
+        var aown = a.owner ? a.owner : '';
+        var bown = b.owner ? b.owner : '';
+        return aown.localeCompare(bown);
+    },
+
+    renderEditButton: function(card) {
+        return (
+            <span>
+                <Nav
+                    title="view/edit"
+                    onClick={function(event) {
+                        window.location=Link.get('viewuser', card.id);
+                    }.bind(this)}
+                />
+                <Delete onClick={this.deleteExistingCard.bind(this, card.number)} />
+            </span>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <h3>All cards</h3>
+                    <Table
+                        className="list cards"
+                        columns={[
+                            {
+                                name: 'Card Number',
+                                render: this.renderNumber,
+                                sort: this.sortNumber,
+                            },
+                            {
+                                name: 'Owner',
+                                render: this.renderOwner,
+                                sort: this.sortOwner,
+                            },
+                            {
+                                name: '',
+                                action: true,
+                                render: this.renderEditButton,
+                            },
+                        ]}
+                        rows={this.state.cards}
+                        emptymessage="There are no cards in use on this network."
+                    />
+                </div>
+                <div className="section">
+                    <h3>Add Card</h3>
+                    <form onSubmit={this.addNewCard}>
+                        <table className="add cards">
+                            <thead>
+                                <th>Card Number</th>
+                                <th>Owner</th>
+                                <th></th>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            type="text"
+                                            value={this.state.new_card.number}
+                                            onChange={function(event) {
+                                                var card = this.state.new_card;
+                                                card.number = event.target.value;
+                                                this.setState({new_card: card});
+                                            }.bind(this)}
+                                            name="card_number"
+                                        />
+                                    </td>
+                                    <td>
+                                        <SelectUser
+                                            name="owner"
+                                            value={ this.state.new_card.owner }
+                                            usernames={ this.state.usernames }
+                                            onChange={function(owner) {
+                                                var card = this.state.new_card;
+                                                card.owner = owner;
+                                                this.setState({
+                                                    new_card: card,
+                                                });
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input type="submit" value="add card" />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(card_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/events.react.js b/bemani/frontend/static/controllers/admin/events.react.js
new file mode 100644
index 0000000..3e8cab8
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/events.react.js
@@ -0,0 +1,214 @@
+/*** @jsx React.DOM */
+
+var possible_events = [
+    'unhandled_packet',
+    'exception',
+    'unauthorized_pcbid',
+    'jubeat_league_course',
+    'jubeat_fc_challenge_charts',
+    'iidx_daily_charts',
+    'pcbevent',
+    'paseli_transaction',
+    'pnm_course',
+];
+
+var event_names = {
+    'unhandled_packet': 'Unhandled Packets',
+    'exception': 'Exceptions',
+    'unauthorized_pcbid': 'Unauthorized PCBIDs',
+    'jubeat_league_course': 'Jubeat League Courses',
+    'jubeat_fc_challenge_charts': 'Jubeat Full Combo Challenge Charts',
+    'iidx_daily_charts': 'IIDX Daily Charts',
+    'pnm_course': 'Pop\'n Music Course',
+    'pcbevent': 'PCB Events',
+    'paseli_transaction': 'PASELI Transactions',
+};
+
+var mergehandler = new MergeManager(function(evt) { return evt.id; }, MergeManager.MERGE_POLICY_DROP);
+
+var audit_events = React.createClass({
+    getInitialState: function(props) {
+        return {
+            events: mergehandler.add(window.events),
+            users: window.users,
+            arcades: window.arcades,
+            iidxsongs: window.iidxsongs,
+            jubeatsongs: window.jubeatsongs,
+            pnmsongs: window.pnmsongs,
+            iidxversions: window.iidxversions,
+            jubeatversions: window.jubeatversions,
+            pnmversions: window.pnmversions,
+            filtering: window.possible_events,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.loadOldEvents();
+        this.refreshEvents();
+    },
+
+    loadOldEvents: function() {
+        // If there's no events on the network, don't try loading old ones
+        if (this.state.events.length == 0) { return; }
+
+        var min_id = this.state.events.reduce(function(a, b) {
+            return a < b.id ? a : b.id;
+        }, this.state.events[0].id);
+        AJAX.get(
+            Link.get('backfill', min_id),
+            function(response) {
+                this.setState({
+                    events: mergehandler.add(response.events),
+                });
+                // Keep loading until we grab all events
+                if (response.events.length > 0) {
+                    setTimeout(this.loadOldEvents, 1);
+                }
+            }.bind(this)
+        );
+    },
+
+    refreshEvents: function() {
+        var max_id = this.state.events.reduce(function(a, b) {
+            if (!a) { return b.id; }
+            return a > b.id ? a : b.id;
+        }, 0);
+        AJAX.get(
+            Link.get('refresh', max_id),
+            function(response) {
+                this.setState({
+                    events: mergehandler.add(response.events),
+                    users: response.users,
+                    arcades: response.arcades,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshEvents, 5000);
+            }.bind(this)
+        );
+    },
+
+    getEvents: function() {
+        return this.state.events.filter(function(event) {
+            return this.state.filtering.indexOf(event.type) >= 0;
+        }.bind(this));
+    },
+
+    renderFilters: function() {
+        return (
+            <div className="section">
+                {window.possible_events.map(function(event_id) {
+                    return (
+                        <span className="filter">
+                            <input
+                                name={event_id}
+                                id={event_id}
+                                type="checkbox"
+                                checked={this.state.filtering.indexOf(event_id) >= 0}
+                                onChange={function(event) {
+                                    var filtering = this.state.filtering;
+                                    if (event.target.checked) {
+                                        filtering.push(event_id);
+                                    } else {
+                                        filtering = filtering.filter(function(f) {
+                                            return f != event_id;
+                                        }.bind(this));
+                                    }
+                                    this.setState({filtering: filtering, offset: 0});
+                                }.bind(this)}
+                            />
+                            <label htmlFor={event_id}>{window.event_names[event_id]}</label>
+                        </span>
+                    );
+                }.bind(this))}
+            </div>
+        );
+    },
+
+    render: function() {
+        var events = this.getEvents().sort(function(a, b) {
+            return b.id - a.id;
+        });
+        if (events.length == 0) {
+            return (
+                <div>
+                    {this.renderFilters()}
+                    <div className="section">
+                        <span className="placeholder">No events to display!</span>
+                    </div>
+                </div>
+            );
+        }
+        return (
+            <div>
+                {this.renderFilters()}
+                <div className="section">
+                    <table className="list events">
+                        <thead>
+                            <tr>
+                                <th>Timestamp</th>
+                                <th>Event</th>
+                                <th>Details</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {events.map(function(event, index) {
+                                if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                    return null;
+                                }
+
+                                if (event.type == 'unhandled_packet') {
+                                    return <UnhandledPacketEvent event={event} />;
+                                } else if(event.type == 'exception') {
+                                    return <ExceptionEvent event={event} />;
+                                } else if(event.type == 'unauthorized_pcbid') {
+                                    return <UnauthorizedClientEvent event={event} />;
+                                } else if(event.type == 'jubeat_league_course') {
+                                    return <JubeatLeagueCourseEvent event={event} versions={this.state.jubeatversions} songs={this.state.jubeatsongs} />;
+                                } else if(event.type == 'jubeat_fc_challenge_charts') {
+                                    return <JubeatFCChallengeEvent event={event} versions={this.state.jubeatversions} songs={this.state.jubeatsongs} />;
+                                } else if(event.type == 'iidx_daily_charts') {
+                                    return <IIDXDailyChartsEvent event={event} versions={this.state.iidxversions} songs={this.state.iidxsongs} />;
+                                } else if(event.type == 'pcbevent') {
+                                    return <PCBEvent event={event} />;
+                                } else if(event.type == 'paseli_transaction') {
+                                    return <PASELITransactionEvent event={event} users={this.state.users} arcades={this.state.arcades} />;
+                                } else if(event.type == 'pnm_course') {
+                                    return <PopnMusicCourseEvent event={event} versions={this.state.pnmversions} songs={this.state.pnmsongs} />;
+                                } else {
+                                    return <UnknownEvent event={event} />;
+                                }
+                            }.bind(this))}
+                        </tbody>
+                        <tfoot>
+                            <tr>
+                                <td colSpan={3}>
+                                    { this.state.offset > 0 ?
+                                        <Prev onClick={function(event) {
+                                             var page = this.state.offset - this.state.limit;
+                                             if (page < 0) { page = 0; }
+                                             this.setState({offset: page});
+                                        }.bind(this)}/> : null
+                                    }
+                                    { (this.state.offset + this.state.limit) < events.length ?
+                                        <Next style={ {float: 'right'} } onClick={function(event) {
+                                             var page = this.state.offset + this.state.limit;
+                                             if (page >= events.length) { return }
+                                             this.setState({offset: page});
+                                        }.bind(this)}/> : null
+                                    }
+                                </td>
+                            </tr>
+                        </tfoot>
+                    </table>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(audit_events, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/machines.react.js b/bemani/frontend/static/controllers/admin/machines.react.js
new file mode 100644
index 0000000..27aa5d1
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/machines.react.js
@@ -0,0 +1,579 @@
+/*** @jsx React.DOM */
+
+var machine_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            machines: window.machines,
+            arcades: window.arcades,
+            editing_machine: null,
+            add_machine: {
+                pcbid: '',
+                name: '',
+                description: '',
+                arcade: null,
+            },
+            random_pcbid: {
+                name: '',
+                description: '',
+                arcade: null,
+            },
+        };
+    },
+
+    generateNewMachine: function(event) {
+        AJAX.post(
+            Link.get('generatepcbid'),
+            {machine: this.state.random_pcbid},
+            function(response) {
+                this.setState({
+                    machines: response.machines,
+                    random_pcbid: {
+                        name: '',
+                        description: '',
+                        arcade: null,
+                    },
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addNewMachine: function(event) {
+        AJAX.post(
+            Link.get('addpcbid'),
+            {machine: this.state.add_machine},
+            function(response) {
+                this.setState({
+                    machines: response.machines,
+                    add_machine: {
+                        pcbid: '',
+                        name: '',
+                        description: '',
+                        arcade: null,
+                    },
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveMachine: function(event) {
+        AJAX.post(
+            Link.get('updatepcbid'),
+            {machine: this.state.editing_machine},
+            function(response) {
+                this.setState({
+                    machines: response.machines,
+                    editing_machine: null,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    deleteExistingMachine: function(event, pcbid) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Arcade',
+            content: 'Are you sure you want to delete this arcade from the network?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removepcbid'),
+                            {pcbid: pcbid},
+                            function(response) {
+                                this.setState({
+                                    machines: response.machines,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+        event.preventDefault();
+    },
+
+    renderPCBID: function(machine) {
+        return (
+            <span>{ machine.pcbid }</span>
+        );
+    },
+
+    sortPCBID: function(a, b) {
+        return a.pcbid.localeCompare(b.pcbid);
+    },
+
+    renderName: function(machine) {
+        return (
+            <span>{ machine.name }</span>
+        );
+    },
+
+    sortName: function(a, b) {
+        return a.name.localeCompare(b.name);
+    },
+
+    renderDescription: function(machine) {
+        if (this.state.editing_machine && machine.pcbid == this.state.editing_machine.pcbid) {
+            return <input
+                name="description"
+                type="text"
+                value={ this.state.editing_machine.description }
+                onChange={function(event) {
+                    var machine = this.state.editing_machine;
+                    machine.description = event.target.value;
+                    this.setState({
+                        editing_machine: machine,
+                    });
+                }.bind(this)}
+            />;
+        } else {
+            return (
+                <span>{ machine.description }</span>
+            );
+        }
+    },
+
+    sortDescription: function(a, b) {
+        return a.description.localeCompare(b.description);
+    },
+
+    renderSeriesList: function(machine) {
+        return (
+            <select
+                name="game"
+                value={this.state.editing_machine.game}
+                onChange={function(event) {
+                    var machine = this.state.editing_machine;
+                    machine.game = event.target.value;
+                    this.setState({
+                        editing_machine: machine,
+                    });
+                }.bind(this)}
+            >
+                {Object.keys(window.series).map(function(key, index) {
+                    return <option value={key}>{ window.series[key] }</option>;
+                }.bind(this))}
+            </select>
+        );
+    },
+
+    renderGameList: function(machine, negate) {
+        return (
+            <select
+                name="game"
+                value={this.state.editing_machine.game + '_' + this.state.editing_machine.version}
+                onChange={function(event) {
+                    var data = event.target.value.split('_');
+                    var machine = this.state.editing_machine;
+                    machine.game = data[0];
+                    machine.version = parseInt(data[1]);
+                    this.setState({
+                        editing_machine: machine,
+                    });
+                }.bind(this)}
+            >
+                {Object.keys(window.games).map(function(game) {
+                    return Object.keys(window.games[game]).map(function(version) {
+                        if (negate) {
+                            version = -version;
+                        }
+                        return <option value={game + '_' + version}>{ window.games[game][Math.abs(version)] }</option>;
+                    }.bind(this));
+                }.bind(this))}
+            </select>
+        );
+    },
+
+    renderGame: function(machine) {
+        if (this.state.editing_machine && machine.pcbid == this.state.editing_machine.pcbid) {
+            var value;
+            var extra;
+
+            if (this.state.editing_machine.game == 'any') {
+                value = 'any';
+                extra = null;
+            } else if(!this.state.editing_machine.version) {
+                value = 'series';
+                extra = this.renderSeriesList(machine);
+            } else if(this.state.editing_machine.version > 0) {
+                value = 'exact';
+                extra = this.renderGameList(machine, false);
+            } else if(this.state.editing_machine.version < 0) {
+                value = 'atmost';
+                extra = this.renderGameList(machine, true);
+            };
+
+            return (
+                <span>
+                    <select
+                        name="function"
+                        value={value}
+                        onChange={function(event) {
+                            var nv = event.target.value;
+                            var machine = this.state.editing_machine;
+                            if (nv == 'any') {
+                                machine.game = 'any';
+                                machine.version = null;
+                            } else if(nv == 'series') {
+                                machine.game = Object.keys(window.series)[0];
+                                machine.version = null;
+                            } else if(nv == 'exact') {
+                                machine.game = Object.keys(window.series)[0];
+                                machine.version = Object.keys(window.games[machine.game])[0];
+                            } else if(nv == 'atmost') {
+                                machine.game = Object.keys(window.series)[0];
+                                machine.version = -Object.keys(window.games[machine.game])[0];
+                            }
+                            this.setState({
+                                editing_machine: machine,
+                            });
+                        }.bind(this)}
+                    >
+                        <option value="any">any supported game</option>
+                        <option value="series">specific series</option>
+                        <option value="exact">specific game</option>
+                        <option value="atmost">specific game or older</option>
+                    </select>
+                    {extra}
+                </span>
+            );
+        } else {
+            if (machine.game == 'any') {
+                return (
+                    <span>any game</span>
+                );
+            } else if(!machine.version) {
+                return (
+                    <span>{ window.series[machine.game] }</span>
+                );
+            } else if(machine.version > 0) {
+                return (
+                    <span>{ window.games[machine.game][machine.version] }</span>
+                );
+            } else if(machine.version < 0) {
+                return (
+                    <span>{ window.games[machine.game][-machine.version] } or older</span>
+                );
+            }
+        }
+    },
+
+    sortGame: function(a, b) {
+        var ag = null;
+        var bg = null;
+        if (a.game == 'any') {
+            ag = 'any game';
+        } else if(!a.version) {
+            ag = window.series[a.game];
+        } else if(a.version > 0) {
+            ag = window.games[a.game][a.version];
+        } else if(a.version < 0) {
+            ag = window.games[a.game][-a.version] + ' or older';
+        }
+        if (b.game == 'any') {
+            bg = 'any game';
+        } else if(!b.version) {
+            bg = window.series[b.game];
+        } else if(b.version > 0) {
+            bg = window.games[b.game][b.version];
+        } else if(b.version < 0) {
+            bg = window.games[b.game][-b.version] + ' or older';
+        }
+        return ag.localeCompare(bg);
+    },
+
+    renderArcade: function(machine) {
+        if (this.state.editing_machine && machine.pcbid == this.state.editing_machine.pcbid) {
+            return (
+                <span>
+                    <SelectArcade
+                        name="owner"
+                        value={ this.state.editing_machine.arcade }
+                        arcades={ this.state.arcades }
+                        onChange={function(owner) {
+                            var machine = this.state.editing_machine;
+                            machine.arcade = parseInt(owner);
+                            this.setState({
+                                editing_machine: machine,
+                             });
+                         }.bind(this)}
+                     />
+                 </span>
+             );
+        } else {
+            if (machine.arcade) {
+                return (
+                    <span>{ this.state.arcades[machine.arcade] }</span>
+                );
+            } else {
+                return (
+                    <span className="placeholder">no arcade</span>
+                );
+            }
+        }
+    },
+
+    sortArcade: function(a, b) {
+        var aarc = this.state.arcades[a.arcade];
+        var barc = this.state.arcades[b.arcade];
+        aarc = aarc ? aarc : '';
+        barc = barc ? barc : '';
+        return aarc.localeCompare(barc);
+    },
+
+    renderPort: function(machine) {
+        if (this.state.editing_machine && machine.pcbid == this.state.editing_machine.pcbid) {
+            return <input
+                name="port"
+                type="text"
+                value={ this.state.editing_machine.port }
+                onChange={function(event) {
+                    var machine = this.state.editing_machine;
+                    var intRegex = /^\d*$/;
+                    if (intRegex.test(event.target.value)) {
+                        machine.port = parseInt(event.target.value);
+                        this.setState({
+                            editing_machine: machine,
+                        });
+                    }
+                }.bind(this)}
+            />;
+        } else {
+            return (
+                <span>{ machine.port }</span>
+            );
+        }
+    },
+
+    sortPort: function(a, b) {
+        return a.port - b.port;
+    },
+
+    renderEditButton: function(machine) {
+        if (this.state.editing_machine) {
+            if (this.state.editing_machine.pcbid == machine.pcbid) {
+                return (
+                    <span>
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    editing_machine: null,
+                                });
+                            }.bind(this)}
+                        />
+                    </span>
+                );
+            } else {
+                return <span></span>;
+            }
+        } else {
+            return (
+                <span>
+                    <Edit
+                        onClick={function(event) {
+                            var editing_machine = null;
+                            this.state.machines.map(function(a) {
+                                if (a.pcbid == machine.pcbid) {
+                                    editing_machine = jQuery.extend(true, {}, a);
+                                }
+                            });
+                            this.setState({
+                                editing_machine: editing_machine,
+                            });
+                        }.bind(this)}
+                    />
+                    <Delete
+                        onClick={function(event) {
+                            this.deleteExistingMachine(event, machine.pcbid);
+                        }.bind(this)}
+                    />
+                </span>
+            );
+        }
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <form className="inline" onSubmit={this.saveMachine}>
+                        <Table
+                            className="list machines"
+                            columns={[
+                                {
+                                    name: 'PCBID',
+                                    render: this.renderPCBID,
+                                    sort: this.sortPCBID,
+                                },
+                                {
+                                    name: 'Name',
+                                    render: this.renderName,
+                                    sort: this.sortName,
+                                },
+                                {
+                                    name: 'Description',
+                                    render: this.renderDescription,
+                                    sort: this.sortDescription,
+                                },
+                                {
+                                    name: 'Arcade',
+                                    render: this.renderArcade,
+                                    sort: this.sortArcade,
+                                },
+                                {
+                                    name: 'Applicable Game',
+                                    render: this.renderGame,
+                                    sort: this.sortGame,
+                                    hidden: !window.enforcing,
+                                },
+                                {
+                                    name: 'Port',
+                                    render: this.renderPort,
+                                    sort: this.sortPort,
+                                },
+                                {
+                                    name: '',
+                                    render: this.renderEditButton,
+                                },
+                            ]}
+                            rows={this.state.machines}
+                            emptymessage="There are no PCBIDs assigned to this network."
+                        />
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>Add PCBID</h3>
+                    <form className="inline" onSubmit={this.addNewMachine}>
+                        <table className="add machine">
+                            <thead>
+                                <tr>
+                                    <th>PCBID</th>
+                                    <th>Description</th>
+                                    <th>Arcade</th>
+                                    <th></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            name="pcbid"
+                                            type="text"
+                                            value={ this.state.add_machine.pcbid }
+                                            onChange={function(event) {
+                                                var machine = this.state.add_machine;
+                                                machine.pcbid = event.target.value;
+                                                this.setState({add_machine: machine});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            name="description"
+                                            type="text"
+                                            value={ this.state.add_machine.description }
+                                            onChange={function(event) {
+                                                var machine = this.state.add_machine;
+                                                machine.description = event.target.value;
+                                                this.setState({add_machine: machine});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <SelectArcade
+                                            name="owner"
+                                            value={ this.state.add_machine.arcade }
+                                            arcades={ this.state.arcades }
+                                            onChange={function(owner) {
+                                                var machine = this.state.add_machine;
+                                                machine.arcade = parseInt(owner);
+                                                this.setState({
+                                                    add_machine: machine,
+                                                 });
+                                             }.bind(this)}
+                                         />
+                                    </td>
+                                    <td>
+                                        <input
+                                            type="submit"
+                                            value="save"
+                                        />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>Generate Random PCBID</h3>
+                    <form className="inline" onSubmit={this.generateNewMachine}>
+                        <table className="add machine">
+                            <thead>
+                                <tr>
+                                    <th>Description</th>
+                                    <th>Arcade</th>
+                                    <th></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            name="description"
+                                            type="text"
+                                            value={ this.state.random_pcbid.description }
+                                            onChange={function(event) {
+                                                var pcbid = this.state.random_pcbid;
+                                                pcbid.description = event.target.value;
+                                                this.setState({random_pcbid: pcbid});
+                                            }.bind(this)}
+                                        />
+                                    </td>
+                                    <td>
+                                        <SelectArcade
+                                            name="owner"
+                                            value={ this.state.random_pcbid.arcade }
+                                            arcades={ this.state.arcades }
+                                            onChange={function(owner) {
+                                                var arcade = this.state.random_pcbid;
+                                                arcade.arcade = parseInt(owner);
+                                                this.setState({
+                                                    random_pcbid: arcade,
+                                                 });
+                                             }.bind(this)}
+                                         />
+                                    </td>
+                                    <td>
+                                        <input
+                                            type="submit"
+                                            value="save"
+                                        />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(machine_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/news.react.js b/bemani/frontend/static/controllers/admin/news.react.js
new file mode 100644
index 0000000..5e98f11
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/news.react.js
@@ -0,0 +1,287 @@
+/*** @jsx React.DOM */
+
+var news_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            news: window.news,
+            editing_news: null,
+            new_entry: {
+                title: '',
+                body: '',
+            },
+        };
+    },
+
+    deleteExistingNews: function(event, newsid) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Entry',
+            content: 'Are you sure you want to delete this news entry?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removenews'),
+                            {newsid: newsid},
+                            function(response) {
+                                this.setState({
+                                    news: response.news,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+        event.preventDefault();
+    },
+
+    addNews: function(event) {
+        AJAX.post(
+            Link.get('addnews'),
+            {news: this.state.new_entry},
+            function(response) {
+                this.setState({
+                    news: response.news,
+                    new_entry: {
+                        title: '',
+                        body: '',
+                    },
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveNews: function(event) {
+        AJAX.post(
+            Link.get('updatenews'),
+            {news: this.state.editing_news},
+            function(response) {
+                this.setState({
+                    news: response.news,
+                    editing_news: null,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    previewNews: function(event, entry) {
+        $.confirm({
+            escapeKey: 'Close',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: entry.title.length > 0 ? entry.title : 'No Title',
+            content: entry.body.length > 0 ? entry.body : 'No body.',
+            buttons: {
+                Close: function() {
+                },
+            }
+        });
+        event.preventDefault();
+    },
+
+    renderDate: function(entry) {
+        return (
+            <Timestamp timestamp={entry.timestamp} />
+        );
+    },
+
+    renderTitle: function(entry) {
+        if (this.state.editing_news && entry.id == this.state.editing_news.id) {
+            return (
+                <input
+                    name="title"
+                    type="text"
+                    value={ this.state.editing_news.title }
+                    onChange={function(event) {
+                        var entry = this.state.editing_news;
+                        entry.title = event.target.value;
+                        this.setState({
+                            editing_news: entry,
+                        });
+                    }.bind(this)}
+                />
+            );
+        } else {
+            return (
+                <span>{ entry.title }</span>
+            );
+        }
+    },
+
+    renderBody: function(entry) {
+        if (this.state.editing_news && entry.id == this.state.editing_news.id) {
+            return (
+                <textarea
+                    name="body"
+                    cols="60"
+                    rows="10"
+                    value={ this.state.editing_news.body }
+                    onChange={function(event) {
+                        var entry = this.state.editing_news;
+                        entry.body = event.target.value;
+                        this.setState({
+                            editing_news: entry,
+                        });
+                    }.bind(this)}
+                />
+            );
+        } else {
+            return (
+                <span>{ entry.body }</span>
+            );
+        }
+    },
+
+    renderEditButton: function(entry) {
+        if (this.state.editing_news) {
+            if (this.state.editing_news.id == entry.id) {
+                return (
+                    <span>
+                        <input
+                            type="button"
+                            value="preview"
+                            onClick={function(event) {
+                                this.previewNews(event, this.state.editing_news);
+                            }.bind(this)}
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    editing_news: null,
+                                });
+                            }.bind(this)}
+                        />
+                    </span>
+                );
+            } else {
+                return <span></span>;
+            }
+        } else {
+            return (
+                <span>
+                    <Edit
+                        onClick={function(event) {
+                            var editing_news = null;
+                            this.state.news.map(function(a) {
+                                if (a.id == entry.id) {
+                                    editing_news = jQuery.extend(true, {}, a);
+                                }
+                            });
+                            this.setState({
+                                editing_news: editing_news,
+                            });
+                        }.bind(this)}
+                    />
+                    <Delete
+                        onClick={function(event) {
+                            this.deleteExistingNews(event, entry.id);
+                        }.bind(this)}
+                    />
+                </span>
+            );
+        }
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    { this.state.news.length > 0 ?
+                        <form className="inline" onSubmit={this.saveNews}>
+                            <table className="list news">
+                                <thead>
+                                    <tr>
+                                        <th>Date</th>
+                                        <th>Title</th>
+                                        <th>Body</th>
+                                        <th className="action"></th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    {
+                                        this.state.news.map(function(entry) {
+                                            return (
+                                                <tr>
+                                                    <td>{ this.renderDate(entry) }</td>
+                                                    <td>{ this.renderTitle(entry) }</td>
+                                                    <td>{ this.renderBody(entry) }</td>
+                                                    <td className="edit">{ this.renderEditButton(entry) }</td>
+                                                </tr>
+                                            );
+                                        }.bind(this))
+                                    }
+                                </tbody>
+                            </table>
+                        </form> :
+                        <span className="placeholder">
+                            There are no news entries on this network.
+                        </span>
+                    }
+                </div>
+                <div className="section">
+                    <h3>Add Entry</h3>
+                    <form className="inline" onSubmit={this.addNews}>
+                        <LabelledSection vertical={true} label="Title">
+                            <input
+                                name="title"
+                                type="text"
+                                size="50"
+                                value={ this.state.new_entry.title }
+                                onChange={function(event) {
+                                    var entry = this.state.new_entry;
+                                    entry.title = event.target.value;
+                                    this.setState({new_entry: entry});
+                                }.bind(this)}
+                            />
+                        </LabelledSection>
+                        <LabelledSection vertical={true} label="Body">
+                            <textarea
+                                name="body"
+                                cols="80"
+                                rows="10"
+                                value={ this.state.new_entry.body }
+                                onChange={function(event) {
+                                    var entry = this.state.new_entry;
+                                    entry.body = event.target.value;
+                                    this.setState({new_entry: entry});
+                                }.bind(this)}
+                            />
+                        </LabelledSection>
+                        <LabelledSection vertical={true}>
+                            <input
+                                type="button"
+                                value="preview"
+                                onClick={function(event) {
+                                    this.previewNews(event, this.state.new_entry);
+                                }.bind(this)}
+                            />
+                            <input
+                                type="submit"
+                                value="save"
+                            />
+                        </LabelledSection>
+                    </form>
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(news_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/user.react.js b/bemani/frontend/static/controllers/admin/user.react.js
new file mode 100644
index 0000000..64230e5
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/user.react.js
@@ -0,0 +1,529 @@
+/*** @jsx React.DOM */
+
+var user_management = React.createClass({
+    getInitialState: function(props) {
+        var credits = {};
+        Object.keys(window.arcades).map(function(arcadeid) {
+            credits[arcadeid] = '';
+        });
+        return {
+            editing_email: false,
+            email: window.user.email,
+            new_email: window.user.email,
+            editing_username: false,
+            username: window.user.username,
+            new_username: window.user.username,
+            editing_pin: false,
+            new_pin: '',
+            editing_password: false,
+            new_password1: '',
+            new_password2: '',
+            cards: window.cards,
+            new_card: '',
+            balances: window.balances,
+            credits: credits,
+            arcades: window.arcades,
+            events: window.events,
+            eventoffset: 0,
+            eventlimit: 5,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshUser();
+    },
+
+    refreshUser: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    cards: response.cards,
+                    balances: response.balances,
+                    arcades: response.arcades,
+                    events: response.events,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshUser, 5000);
+            }.bind(this)
+        );
+    },
+
+    deleteExistingCard: function(card) {
+        $.confirm({
+            escapeKey: 'Cancel',
+            animation: 'none',
+            closeAnimation: 'none',
+            title: 'Delete Card',
+            content: 'Are you sure you want to delete this card from this account?',
+            buttons: {
+                Delete: {
+                    btnClass: 'delete',
+                    action: function() {
+                        AJAX.post(
+                            Link.get('removeusercard'),
+                            {card: card},
+                            function(response) {
+                                this.setState({
+                                    cards: response.cards,
+                                });
+                            }.bind(this)
+                        );
+                    }.bind(this),
+                },
+                Cancel: function() {
+                },
+            }
+        });
+    },
+
+    addNewCard: function(event) {
+        AJAX.post(
+            Link.get('addusercard'),
+            {card: this.state.new_card},
+            function(response) {
+                this.setState({
+                    cards: response.cards,
+                    new_card: '',
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    updateBalance: function(event) {
+        var updates = {};
+        Object.keys(this.state.credits).map(function(arcadeid) {
+            var intval = parseInt(this.state.credits[arcadeid]);
+            if (!isNaN(intval)) {
+                updates[arcadeid] = intval;
+            }
+        }.bind(this));
+        AJAX.post(
+            Link.get('updatebalance'),
+            {credits: updates},
+            function(response) {
+                var credits = {};
+                Object.keys(response.arcades).map(function(arcadeid) {
+                    credits[arcadeid] = '';
+                });
+                this.setState({
+                    arcades: response.arcades,
+                    balances: response.balances,
+                    credits: credits,
+                    events: response.events,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveUsername: function(event) {
+        AJAX.post(
+            Link.get('updateusername'),
+            {
+                username: this.state.new_username,
+            },
+            function(response) {
+                this.setState({
+                    username: response.username,
+                    new_username: response.username,
+                    editing_username: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveEmail: function(event) {
+        AJAX.post(
+            Link.get('updateemail'),
+            {
+                email: this.state.new_email,
+            },
+            function(response) {
+                this.setState({
+                    email: response.email,
+                    new_email: response.email,
+                    editing_email: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    savePin: function(event) {
+        AJAX.post(
+            Link.get('updatepin'),
+            {pin: this.state.new_pin},
+            function(response) {
+                this.setState({
+                    new_pin: '',
+                    editing_pin: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    savePassword: function(event) {
+        AJAX.post(
+            Link.get('updatepassword'),
+            {
+                new1: this.state.new_password1,
+                new2: this.state.new_password2,
+            },
+            function(response) {
+                this.setState({
+                    new_password1: '',
+                    new_password2: '',
+                    editing_password: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderUsername: function() {
+        return (
+            <LabelledSection vertical={true} label="Username">{
+                !this.state.editing_username ?
+                    <span>
+                        {
+                            this.state.username ?
+                                <span>{ this.state.username }</span> :
+                                <span className="placeholder">unset</span>
+                        }
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_username: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveUsername}>
+                        <input
+                            type="text"
+                            className="inline"
+                            value={this.state.new_username}
+                            onChange={function(event) {
+                                this.setState({new_username: event.target.value});
+                            }.bind(this)}
+                            name="username"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_username: this.state.username,
+                                    editing_username: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderPassword: function() {
+        return (
+            <LabelledSection vertical={true} label="Password">{
+                !this.state.editing_password ?
+                    <span>
+                        <span>&bull;&bull;&bull;&bull;&bull;&bull;</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_password: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.savePassword}>
+                        <div>
+                            <label htmlFor="new1">New password:</label>
+                            <input
+                                type="password"
+                                value={this.state.new_password1}
+                                onChange={function(event) {
+                                    this.setState({new_password1: event.target.value});
+                                }.bind(this)}
+                                name="new1"
+                            />
+                        </div>
+                        <div>
+                            <label htmlFor="new2">New password (again):</label>
+                            <input
+                                type="password"
+                                value={this.state.new_password2}
+                                onChange={function(event) {
+                                    this.setState({new_password2: event.target.value});
+                                }.bind(this)}
+                                name="new2"
+                            />
+                        </div>
+                        <div className="buttons">
+                            <input
+                                type="submit"
+                                value="save"
+                            />
+                            <input
+                                type="button"
+                                value="cancel"
+                                onClick={function(event) {
+                                    this.setState({
+                                        new_password1: '',
+                                        new_password2: '',
+                                        editing_password: false,
+                                    });
+                                }.bind(this)}
+                            />
+                        </div>
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderEmail: function() {
+        return (
+            <LabelledSection vertical={true} label="Email Address">{
+                !this.state.editing_email ?
+                    <span>
+                        {
+                            this.state.email ?
+                                <span>{ this.state.email }</span> :
+                                <span className="placeholder">unset</span>
+                        }
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_email: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveEmail}>
+                        <input
+                            type="text"
+                            className="inline"
+                            value={this.state.new_email}
+                            onChange={function(event) {
+                                this.setState({new_email: event.target.value});
+                            }.bind(this)}
+                            name="email"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_email: this.state.email,
+                                    editing_email: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderPIN: function() {
+        return (
+            <LabelledSection vertical={true} label="PIN">{
+                !this.state.editing_pin ?
+                    <span>
+                        <span>&bull;&bull;&bull;&bull;</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_pin: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.savePin}>
+                        <input
+                            type="text"
+                            maxlength="4"
+                            size="4"
+                            className="inline"
+                            value={this.state.new_pin}
+                            onChange={function(event) {
+                                var intRegex = /^\d*$/;
+                                if (event.target.value.length <= 4 && intRegex.test(event.target.value)) {
+                                    this.setState({new_pin: event.target.value});
+                                }
+                            }.bind(this)}
+                            name="pin"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_pin: '',
+                                    editing_pin: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <h3>User Details</h3>
+                    {this.renderUsername()}
+                    {this.renderPassword()}
+                    {this.renderEmail()}
+                    {this.renderPIN()}
+                </div>
+                <div className="section">
+                    <h3>Cards</h3>
+                    {this.state.cards.map(function(card) {
+                        return (
+                            <div>
+                                <Card number={card} />
+                                <Delete
+                                    onClick={this.deleteExistingCard.bind(this, card)}
+                                />
+                            </div>
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+                    <h3>Add Card</h3>
+                    <form onSubmit={this.addNewCard}>
+                        <input
+                            type="text"
+                            className="inline"
+                            value={this.state.new_card}
+                            onChange={function(event) {
+                                this.setState({new_card: event.target.value});
+                            }.bind(this)}
+                            name="card_number"
+                        />
+                        <input type="submit" value="add card" />
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>PASELI Balance</h3>
+                    { Object.keys(this.state.arcades).length == 0 ?
+                        <div>
+                            <span className="placeholder">No arcades present!</span>
+                        </div> :
+                        <form onSubmit={this.updateBalance}>
+                            <Table
+                                className="list balance"
+                                columns={[
+                                    {
+                                        name: 'Arcade',
+                                        render: function(arcadeid) {
+                                            return this.state.arcades[arcadeid];
+                                        }.bind(this),
+                                        sort: function(a, b) {
+                                            return this.state.arcades[a].localeCompare(this.state.arcades[b]);
+                                        }.bind(this),
+                                    },
+                                    {
+                                        name: 'Current Balance',
+                                        render: function(arcadeid) {
+                                            return this.state.balances[arcadeid];
+                                        }.bind(this),
+                                    },
+                                    {
+                                        name: 'Credit Amount',
+                                        render: function(arcadeid) {
+                                            return (
+                                                <input
+                                                    type="text"
+                                                    className="inline"
+                                                    value={this.state.credits[arcadeid]}
+                                                    onChange={function(event) {
+                                                        var credits = this.state.credits;
+                                                        credits[arcadeid] = event.target.value;
+                                                        this.setState({credits: credits});
+                                                    }.bind(this)}
+                                                    name="credits"
+                                                />
+                                            );
+                                        }.bind(this),
+                                    }
+                                ]}
+                                rows={Object.keys(this.state.arcades)}
+                                emptymessage="There are no arcades on this network."
+                            />
+                            <div className="action">
+                                <input type="submit" value="update balance" />
+                            </div>
+                        </form>
+                    }
+                </div>
+                <div className="section">
+                    <h3>PASELI Transaction History</h3>
+                    { this.state.events.length == 0 ?
+                        <div>
+                            <span className="placeholder">No events to display!</span>
+                        </div> :
+                        <table className="list events">
+                            <thead>
+                                <tr>
+                                    <th>Timestamp</th>
+                                    <th>Event</th>
+                                    <th>Details</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {this.state.events.map(function(event, index) {
+                                    if (index < this.state.eventoffset || index >= this.state.eventoffset + this.state.eventlimit) {
+                                        return null;
+                                    }
+
+                                    if(event.type == 'paseli_transaction') {
+                                        return <PASELITransactionEvent event={event} arcades={this.state.arcades} />;
+                                    } else {
+                                        return null;
+                                    }
+                                }.bind(this))}
+                            </tbody>
+                            <tfoot>
+                                <tr>
+                                    <td colSpan={3}>
+                                        { this.state.eventoffset > 0 ?
+                                            <Prev onClick={function(event) {
+                                                 var page = this.state.eventoffset - this.state.eventlimit;
+                                                 if (page < 0) { page = 0; }
+                                                 this.setState({eventoffset: page});
+                                            }.bind(this)}/> : null
+                                        }
+                                        { (this.state.eventoffset + this.state.eventlimit) < this.state.events.length ?
+                                            <Next style={ {float: 'right'} } onClick={function(event) {
+                                                 var page = this.state.eventoffset + this.state.eventlimit;
+                                                 if (page >= this.state.events.length) { return }
+                                                 this.setState({eventoffset: page});
+                                            }.bind(this)}/> : null
+                                        }
+                                    </td>
+                                </tr>
+                            </tfoot>
+                        </table>
+                    }
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(user_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/admin/users.react.js b/bemani/frontend/static/controllers/admin/users.react.js
new file mode 100644
index 0000000..d059cc5
--- /dev/null
+++ b/bemani/frontend/static/controllers/admin/users.react.js
@@ -0,0 +1,136 @@
+/*** @jsx React.DOM */
+
+var card_management = React.createClass({
+    getInitialState: function(props) {
+        return {
+            users: window.users,
+            user_search: {
+                card: '',
+            },
+            searching: false,
+        };
+    },
+
+    searchUsers: function(event) {
+        this.setState({searching: true});
+        AJAX.post(
+            Link.get('searchusers'),
+            {user_search: this.state.user_search},
+            function(response) {
+                this.setState({
+                    users: response.users,
+                    searching: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderID: function(user) {
+        return <span>{user.id}</span>;
+    },
+
+    sortID: function(a, b) {
+        return a.id - b.id;
+    },
+
+    renderUsername: function(user) {
+        return user.username ?
+            <span>{user.username}</span> :
+            <span className="placeholder">anonymous account</span>;
+    },
+
+    sortUsername: function(a, b) {
+        var au = a.username ? a.username : '';
+        var bu = b.username ? b.username : '';
+        return au.localeCompare(bu);
+    },
+
+    renderEmail: function(user) {
+        return user.email ?
+            <span>{user.email}</span> :
+            <span className="placeholder">no email</span>;
+    },
+
+    sortEmail: function(a, b) {
+        var ae = a.email ? a.email : '';
+        var be = b.email ? b.email : '';
+        return ae.localeCompare(be);
+    },
+
+    renderEditButton: function(user) {
+        return (
+            <Nav
+                title="view/edit"
+                onClick={function(event) {
+                    window.location=Link.get('viewuser', user.id);
+                }.bind(this)}
+            />
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <h3>User Search</h3>
+                    <form onSubmit={this.searchUsers}>
+                        <label htmlFor="card">Card Number:</label>
+                        <br />
+                        <input
+                            type="text"
+                            className="inline"
+                            value={this.state.user_search.card}
+                            onChange={function(event) {
+                                var user = this.state.user_search;
+                                user.card = event.target.value;
+                                this.setState({user_search: user});
+                            }.bind(this)}
+                            name="card"
+                        />
+                        <input type="submit" value="search" />
+                        { this.state.searching ?
+                            <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                        }
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>User List</h3>
+                    <Table
+                        className="list users"
+                        columns={[
+                            {
+                                name: 'ID',
+                                render: this.renderID,
+                                sort: this.sortID,
+                            },
+                            {
+                                name: 'Username',
+                                render: this.renderUsername,
+                                sort: this.sortUsername,
+                            },
+                            {
+                                name: 'Email',
+                                render: this.renderEmail,
+                                sort: this.sortEmail,
+                            },
+                            {
+                                name: '',
+                                action: true,
+                                render: this.renderEditButton,
+                            }
+                        ]}
+                        rows={this.state.users}
+                        emptymessage="There are no users to display."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(card_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/arcade/arcade.react.js b/bemani/frontend/static/controllers/arcade/arcade.react.js
new file mode 100644
index 0000000..fa29393
--- /dev/null
+++ b/bemani/frontend/static/controllers/arcade/arcade.react.js
@@ -0,0 +1,582 @@
+/*** @jsx React.DOM */
+
+function makeSettingName(game_settings) {
+    return game_settings.game + '-' + game_settings.version;
+}
+var valid_settings = window.game_settings.map(function(setting) {
+    return makeSettingName(setting);
+});
+var pagenav = new History(valid_settings);
+
+var arcade_management = React.createClass({
+    getInitialState: function(props) {
+        var credits = {};
+        Object.keys(window.users).map(function(userid) {
+            credits[userid] = '';
+        });
+        return {
+            id: window.arcade.id,
+            name: window.arcade.name,
+            description: window.arcade.description,
+            paseli_enabled: window.arcade.paseli_enabled,
+            paseli_infinite: window.arcade.paseli_infinite,
+            mask_services_url: window.arcade.mask_services_url,
+            pin: window.arcade.pin,
+            editing_pin: false,
+            new_pin: '',
+            paseli_enabled_saving: false,
+            paseli_infinite_saving: false,
+            mask_services_url_saving: false,
+            machines: window.machines,
+            settings: window.game_settings,
+            current_setting: pagenav.getInitialState(makeSettingName(window.game_settings[0])),
+            settings_changed: {},
+            settings_saving: {},
+            settings_saved: {},
+            users: window.users,
+            balances: window.balances,
+            credits: credits,
+            events: window.events,
+            eventoffset: 0,
+            eventlimit: 5,
+            credit_card: '',
+            credit_amount: '',
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(setting) {
+            this.setState({current_setting: setting});
+        }.bind(this));
+        this.refreshArcade();
+    },
+
+    refreshArcade: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    users: response.users,
+                    balances: response.balances,
+                    machines: response.machines,
+                    events: response.events,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshArcade, 5000);
+            }.bind(this)
+        );
+    },
+
+    savePin: function(event) {
+        AJAX.post(
+            Link.get('update_pin'),
+            {pin: this.state.new_pin},
+            function(response) {
+                this.setState({
+                    pin: response.pin,
+                    new_pin: '',
+                    editing_pin: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    getSettingIndex: function(setting_name) {
+        var real_index = -1;
+        this.state.settings.map(function(game_settings, index) {
+            var current = makeSettingName(game_settings);
+            if (current == setting_name) { real_index = index; }
+        }.bind(this));
+        return real_index;
+    },
+
+    togglePaseliEnabled: function(event) {
+        this.setState({paseli_enabled_saving: true})
+        AJAX.post(
+            Link.get('paseli_enabled'),
+            {value: !this.state.paseli_enabled},
+            function(response) {
+                this.setState({
+                    paseli_enabled: response.value,
+                    paseli_enabled_saving: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    togglePaseliInfinite: function(event) {
+        this.setState({paseli_infinite_saving: true})
+        AJAX.post(
+            Link.get('paseli_infinite'),
+            {value: !this.state.paseli_infinite},
+            function(response) {
+                this.setState({
+                    paseli_infinite: response.value,
+                    paseli_infinite_saving: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    toggleMaskServicesURL: function(event) {
+        this.setState({mask_services_url_saving: true})
+        AJAX.post(
+            Link.get('mask_services_url'),
+            {value: !this.state.mask_services_url},
+            function(response) {
+                this.setState({
+                    mask_services_url: response.value,
+                    mask_services_url_saving: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    setChanged: function(val) {
+        this.state.settings_changed[this.state.current_setting] = val;
+        return this.state.settings_changed;
+    },
+
+    setSaving: function(val) {
+        this.state.settings_saving[this.state.current_setting] = val;
+        return this.state.settings_saving;
+    },
+
+    setSaved: function(val) {
+        this.state.settings_saved[this.state.current_setting] = val;
+        return this.state.settings_saved;
+    },
+
+    saveSettings: function(event) {
+        var index = this.getSettingIndex(this.state.current_setting);
+        this.setState({settings_saving: this.setSaving(true), settings_saved: this.setSaved(false)});
+        AJAX.post(
+            Link.get('update_settings'),
+            this.state.settings[index],
+            function(response) {
+                this.state.settings[index] = response.game_settings;
+                this.setState({
+                    settings: this.state.settings,
+                    settings_saving: this.setSaving(false),
+                    settings_saved: this.setSaved(true),
+                    settings_changed: this.setChanged(false),
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addBalance: function(event) {
+        var intval = parseInt(this.state.credit_amount);
+        if (isNaN(intval)) {
+            intval = 0;
+        }
+        AJAX.post(
+            Link.get('add_balance'),
+            {
+                credits: intval,
+                card: this.state.credit_card,
+            },
+            function(response) {
+                var credits = {};
+                Object.keys(response.users).map(function(userid) {
+                    credits[userid] = '';
+                });
+                console.log('huh?');
+                this.setState({
+                    users: response.users,
+                    balances: response.balances,
+                    credits: credits,
+                    events: response.events,
+                    credit_card: '',
+                    credit_amount: '',
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    updateBalance: function(event) {
+        var updates = {};
+        Object.keys(this.state.credits).map(function(userid) {
+            var intval = parseInt(this.state.credits[userid]);
+            if (!isNaN(intval)) {
+                updates[userid] = intval;
+            }
+        }.bind(this));
+        AJAX.post(
+            Link.get('update_balance'),
+            {credits: updates},
+            function(response) {
+                var credits = {};
+                Object.keys(response.users).map(function(userid) {
+                    credits[userid] = '';
+                });
+                this.setState({
+                    users: response.users,
+                    balances: response.balances,
+                    credits: credits,
+                    events: response.events,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderPIN: function() {
+        return (
+            <LabelledSection vertical={true} label="PIN">{
+                !this.state.editing_pin ?
+                    <span>
+                        <span>{this.state.pin}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_pin: true, new_pin: this.state.pin});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.savePin}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="8"
+                            size="8"
+                            value={this.state.new_pin}
+                            onChange={function(event) {
+                                var intRegex = /^\d*$/;
+                                if (event.target.value.length <= 8 && intRegex.test(event.target.value)) {
+                                    this.setState({new_pin: event.target.value});
+                                }
+                            }.bind(this)}
+                            name="pin"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_pin: '',
+                                    editing_pin: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <LabelledSection vertical={true} label="Name">{ this.state.name }</LabelledSection>
+                    <LabelledSection vertical={true} label="Description">{
+                        this.state.description ?
+                            <span>{ this.state.description }</span> :
+                            <span className="placeholder">no description</span>
+                    }</LabelledSection>
+                    {this.renderPIN()}
+                    <LabelledSection vertical={true} label="PASELI Enabled">
+                        <span>{ this.state.paseli_enabled ? 'yes' : 'no' }</span>
+                        <Toggle onClick={this.togglePaseliEnabled.bind(this)} />
+                        { this.state.paseli_enabled_saving ?
+                            <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                        }
+                    </LabelledSection>
+                    <LabelledSection vertical={true} label="PASELI Infinite">
+                        <span>{ this.state.paseli_infinite ? 'yes' : 'no' }</span>
+                        <Toggle onClick={this.togglePaseliInfinite.bind(this)} />
+                        { this.state.paseli_infinite_saving ?
+                            <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                        }
+                    </LabelledSection>
+                    <LabelledSection vertical={true} label="Mask Web Address">
+                        <span>{ this.state.mask_services_url ? 'yes' : 'no' }</span>
+                        <Toggle onClick={this.toggleMaskServicesURL.bind(this)} />
+                        { this.state.mask_services_url_saving ?
+                            <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                        }
+                    </LabelledSection>
+                </div>
+                <div className="section">
+                    <h3>PCBIDs Assigned to This Arcade</h3>
+                    <Table
+                        className="list machine"
+                        columns={[
+                            {
+                                name: "PCBID",
+                                render: function(machine) { return machine.pcbid; },
+                                sort: function(a, b) { return a.pcbid.localeCompare(b.pcbid); },
+                            },
+                            {
+                                name: "Name",
+                                render: function(machine) { return machine.name; },
+                                sort: function(a, b) { return a.name.localeCompare(b.name); },
+                            },
+                            {
+                                name: "Description",
+                                render: function(machine) { return machine.description; },
+                                sort: function(a, b) { return a.description.localeCompare(b.description); },
+                            },
+                            {
+                                name: "Applicable Game",
+                                render: function(machine) { return machine.game; },
+                                sort: function(a, b) { return a.game.localeCompare(b.game); },
+                                hidden: !window.enforcing,
+                            },
+                            {
+                                name: "Port",
+                                render: function(machine) { return machine.port; },
+                                sort: function(a, b) { return a.port - b.port; },
+                            },
+                        ]}
+                        rows={this.state.machines}
+                        emptymessage="There are no PCBIDs assigned to this arcade."
+                    />
+                </div>
+                <div className="section">
+                    <h3>Game Settings For This Arcade</h3>
+                    { this.state.settings.map(function(game_settings) {
+                        var current = makeSettingName(game_settings);
+                        return (
+                            <Nav
+                                title={game_settings.name}
+                                active={this.state.current_setting == current}
+                                showAlert={this.state.settings_changed[current]}
+                                onClick={function(event) {
+                                    if (this.state.current_setting == current) { return; }
+                                    this.setState({current_setting: current});
+                                    pagenav.navigate(current);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+                    { this.state.settings[this.getSettingIndex(this.state.current_setting)].ints.map(function(setting, index) {
+                        return (
+                            <div className="arcade menuoption">
+                                <Tip
+                                    text={setting.tip}
+                                >
+                                    <label htmlFor={setting.setting}>{setting.name}:</label>
+                                    <SelectInt
+                                        name={setting.setting}
+                                        id={setting.setting}
+                                        value={setting.value}
+                                        choices={setting.values}
+                                        onChange={function(value) {
+                                            this.state.settings[this.getSettingIndex(this.state.current_setting)].ints[index].value = value;
+                                            this.setState({
+                                                settings: this.state.settings,
+                                                settings_changed: this.setChanged(true),
+                                            });
+                                        }.bind(this)}
+                                    />
+                                </Tip>
+                            </div>
+                        );
+                    }.bind(this))}
+                    { this.state.settings[this.getSettingIndex(this.state.current_setting)].bools.map(function(setting, index) {
+                        return (
+                            <div className="arcade menuoption">
+                                <Tip
+                                    text={setting.tip}
+                                >
+                                    <label htmlFor={setting.setting}>{setting.name}:</label>
+                                    <input
+                                        name={setting.setting}
+                                        id={setting.setting}
+                                        type="checkbox"
+                                        checked={setting.value}
+                                        onChange={function(event) {
+                                            this.state.settings[this.getSettingIndex(this.state.current_setting)].bools[index].value = event.target.checked;
+                                            this.setState({
+                                                settings: this.state.settings,
+                                                settings_changed: this.setChanged(true),
+                                            });
+                                        }.bind(this)}
+                                    />
+                                </Tip>
+                            </div>
+                        );
+                    }.bind(this))}
+                    <input
+                        type="submit"
+                        disabled={!this.state.settings_changed[this.state.current_setting]}
+                        value="save"
+                        onClick={function(event) {
+                            this.saveSettings(event);
+                        }.bind(this)}
+                    />
+                    { this.state.settings_saving[this.state.current_setting] ?
+                        <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                    }
+                    { this.state.settings_saved[this.state.current_setting] ?
+                        <span>&#x2713;</span> :
+                            null
+                    }
+                </div>
+                <div className="section">
+                    <h3>User PASELI Balances for This Arcade</h3>
+                    { Object.keys(this.state.balances).length == 0 ?
+                        <div>
+                            <span className="placeholder">No users with balances for this arcade!</span>
+                        </div> :
+                        <form onSubmit={this.updateBalance}>
+                            <table className="list blance">
+                                <thead>
+                                    <tr>
+                                        <th>User</th>
+                                        <th>Current Balance</th>
+                                        <th>Credit Amount</th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    {Object.keys(this.state.balances).map(function(userid) {
+                                        var user = this.state.users[userid];
+                                        return (
+                                            <tr>
+                                                <td>{ user ?
+                                                    <span>{user}</span> :
+                                                    <span className="placeholder">anonymous account</span>
+                                                }</td>
+                                                <td>{this.state.balances[userid]}</td>
+                                                <td>
+                                                    <input
+                                                        type="text"
+                                                        className="inline"
+                                                        value={this.state.credits[userid]}
+                                                        onChange={function(event) {
+                                                            var credits = this.state.credits;
+                                                            credits[userid] = event.target.value;
+                                                            this.setState({credits: credits});
+                                                        }.bind(this)}
+                                                        name="credits"
+                                                    />
+                                                </td>
+                                            </tr>
+                                        );
+                                    }.bind(this))}
+                                </tbody>
+                            </table>
+                            <div className="action">
+                                <input type="submit" value="update balance" />
+                            </div>
+                        </form>
+                    }
+                </div>
+                <div className="section">
+                    <h3>Credit PASELI via Card</h3>
+                    <form onSubmit={this.addBalance}>
+                        <table className="add blance">
+                            <thead>
+                                <tr>
+                                    <th>Card Number</th>
+                                    <th>Credit Amount</th>
+                                    <th></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <tr>
+                                    <td>
+                                        <input
+                                            type="text"
+                                            className="inline"
+                                            value={this.state.credit_card}
+                                            onChange={function(event) {
+                                                this.setState({credit_card: event.target.value});
+                                            }.bind(this)}
+                                            name="card"
+                                        />
+                                    </td>
+                                    <td>
+                                        <input
+                                            type="text"
+                                            className="inline"
+                                            value={this.state.credit_amount}
+                                            onChange={function(event) {
+                                                this.setState({credit_amount: event.target.value});
+                                            }.bind(this)}
+                                            name="credits"
+                                        />
+                                    </td>
+                                    <td>
+                                        <input type="submit" value="update balance" />
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </form>
+                </div>
+                <div className="section">
+                    <h3>PASELI Transaction History</h3>
+                    { this.state.events.length == 0 ?
+                        <div>
+                            <span className="placeholder">No events to display!</span>
+                        </div> :
+                        <table className="list events">
+                            <thead>
+                                <tr>
+                                    <th>Timestamp</th>
+                                    <th>Event</th>
+                                    <th>Details</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {this.state.events.map(function(event, index) {
+                                    if (index < this.state.eventoffset || index >= this.state.eventoffset + this.state.eventlimit) {
+                                        return null;
+                                    }
+
+                                    if(event.type == 'paseli_transaction') {
+                                        return <PASELITransactionEvent event={event} users={this.state.users} />;
+                                    } else {
+                                        return null;
+                                    }
+                                }.bind(this))}
+                            </tbody>
+                            <tfoot>
+                                <tr>
+                                    <td colSpan={3}>
+                                        { this.state.eventoffset > 0 ?
+                                            <Prev onClick={function(event) {
+                                                 var page = this.state.eventoffset - this.state.eventlimit;
+                                                 if (page < 0) { page = 0; }
+                                                 this.setState({eventoffset: page});
+                                            }.bind(this)}/> : null
+                                        }
+                                        { (this.state.eventoffset + this.state.eventlimit) < this.state.events.length ?
+                                            <Next style={ {float: 'right'} } onClick={function(event) {
+                                                 var page = this.state.eventoffset + this.state.eventlimit;
+                                                 if (page >= this.state.events.length) { return }
+                                                 this.setState({eventoffset: page});
+                                            }.bind(this)}/> : null
+                                        }
+                                    </td>
+                                </tr>
+                            </tfoot>
+                        </table>
+                    }
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(arcade_management, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/bishi/allplayers.react.js b/bemani/frontend/static/controllers/bishi/allplayers.react.js
new file mode 100644
index 0000000..6c0383e
--- /dev/null
+++ b/bemani/frontend/static/controllers/bishi/allplayers.react.js
@@ -0,0 +1,109 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'BishiBashi ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.plays;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.plays - b.plays;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                            {
+                                name: 'Region',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.shop_area;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.shop_area.localeCompare(b.shop_area);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Arcade',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.shop;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.shop.localeCompare(b.shop);
+                                }.bind(this),
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/bishi/player.react.js b/bemani/frontend/static/controllers/bishi/player.react.js
new file mode 100644
index 0000000..713ec33
--- /dev/null
+++ b/bemani/frontend/static/controllers/bishi/player.react.js
@@ -0,0 +1,108 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Total Plays">
+                            {player.plays}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="Home Shop">{player.shop}</LabelledSection>
+                        <LabelledSection label="Home Shop Area">{player.shop_area}</LabelledSection>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/bishi/settings.react.js b/bemani/frontend/static/controllers/bishi/settings.react.js
new file mode 100644
index 0000000..cc7b6a6
--- /dev/null
+++ b/bemani/frontend/static/controllers/bishi/settings.react.js
@@ -0,0 +1,240 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var settings_view = React.createClass({
+
+    sanitizeName: function(name) {
+        if (name == 'なし') {
+            return '';
+        }
+        return name;
+    },
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: this.sanitizeName(window.player[version].name),
+            editing_name: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.sanitizeName(this.state.player[response.version].name),
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="6"
+                            size="6"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+								var rawvalue = event.target.value;
+                                var value = "";
+                                // Nasty conversion to change typing into wide text
+                                for (var i = 0; i < rawvalue.length; i++) {
+                                    var c = rawvalue.charCodeAt(i);
+                                    if (c >= '0'.charCodeAt(0) && c <= '9'.charCodeAt(0)) {
+                                        c = 0xFF10 + (c - '0'.charCodeAt(0));
+                                    } else if(c >= 'A'.charCodeAt(0) && c <= 'Z'.charCodeAt(0)) {
+                                        c = 0xFF21 + (c - 'A'.charCodeAt(0));
+                                    } else if(c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
+                                        c = 0xFF41 + (c - 'a'.charCodeAt(0));
+                                    } else if(c == '@'.charCodeAt(0)) {
+                                        c = 0xFF20;
+                                    } else if(c == ' '.charCodeAt(0)) {
+                                        c = 0x3000;
+                                    } else if(c == '~'.charCodeAt(0)) {
+                                        c = 0x301C;
+                                    } else if(c == '-'.charCodeAt(0)) {
+                                        c = 0x2212;
+                                    } else if(c == '!'.charCodeAt(0)) {
+                                        c = 0xFF01;
+                                    } else if(c == '#'.charCodeAt(0)) {
+                                        c = 0xFF03;
+                                    } else if(c == '$'.charCodeAt(0)) {
+                                        c = 0xFF04;
+                                    } else if(c == '%'.charCodeAt(0)) {
+                                        c = 0xFF04;
+                                    } else if(c == '&'.charCodeAt(0)) {
+                                        c = 0xFF06;
+                                    } else if(c == '('.charCodeAt(0)) {
+                                        c = 0xFF08;
+                                    } else if(c == ')'.charCodeAt(0)) {
+                                        c = 0xFF09;
+                                    } else if(c == '*'.charCodeAt(0)) {
+                                        c = 0xFF0A;
+                                    } else if(c == '+'.charCodeAt(0)) {
+                                        c = 0xFF0B;
+                                    } else if(c == '/'.charCodeAt(0)) {
+                                        c = 0xFF0F;
+                                    } else if(c == '<'.charCodeAt(0)) {
+                                        c = 0xFF1C;
+                                    } else if(c == '='.charCodeAt(0)) {
+                                        c = 0xFF1D;
+                                    } else if(c == '>'.charCodeAt(0)) {
+                                        c = 0xFF1E;
+                                    } else if(c == '?'.charCodeAt(0)) {
+                                        c = 0xFF1F;
+                                    }
+                                    value = value + String.fromCharCode(c);
+                                }
+                                var nameRegex = new RegExp(
+                                    "^[" +
+                                    "\uFF20-\uFF3A" + // widetext A-Z, @
+                                    "\uFF41-\uFF5A" + // widetext a-z (will be uppercased in backend)
+                                    "\uFF10-\uFF19" + // widetext 0-9
+                                    "\u3041-\u308D\u308F\u3092\u3093" + // hiragana
+                                    "\u30A1-\u30ED\u30EF\u30F2\u30F3\u30FC" + // katakana
+                                    "\u3000" + // widetext blank space
+                                    "\u301C" + // widetext ~
+                                    "\u30FB" + // widetext middot
+                                    "\u30FC" + // widetext long dash
+                                    "\u2212" + // widetext short dash
+                                    "\u2605" + // widetext heavy star
+                                    "\uFF01" + // widetext !
+                                    "\uFF03" + // widetext #
+                                    "\uFF04" + // widetext $
+                                    "\uFF05" + // widetext %
+                                    "\uFF06" + // widetext &
+                                    "\uFF08" + // widetext (
+                                    "\uFF09" + // widetext )
+                                    "\uFF0A" + // widetext *
+                                    "\uFF0B" + // widetext +
+                                    "\uFF0F" + // widetext /
+                                    "\uFF1C" + // widetext <
+                                    "\uFF1D" + // widetext =
+                                    "\uFF1E" + // widetext >
+                                    "\uFF1F" + // widetext ?
+                                    "\uFFE5" + // widetext Yen symbol
+                                    "]*$"
+                                );
+                                if (value.length <= 6 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.sanitizeName(this.state.player[this.state.version].name),
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.sanitizeName(this.state.player[version].name),
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/allplayers.react.js b/bemani/frontend/static/controllers/ddr/allplayers.react.js
new file mode 100644
index 0000000..028df15
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/allplayers.react.js
@@ -0,0 +1,85 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'DDR ID', 
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.sp + player.dp;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return (a.sp + a.dp) - (b.sp + b.dp);
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/player.react.js b/bemani/frontend/static/controllers/ddr/player.react.js
new file mode 100644
index 0000000..29eaf97
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/player.react.js
@@ -0,0 +1,118 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Single Plays">
+                            {player.sp}回
+                        </LabelledSection>
+                        <LabelledSection label="Double Plays">
+                            {player.dp}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/records.react.js b/bemani/frontend/static/controllers/ddr/records.react.js
new file mode 100644
index 0000000..c221f82
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/records.react.js
@@ -0,0 +1,698 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['SP Beginner', 'SP Basic', 'SP Difficult', 'SP Expert', 'SP Challenge', 'DP Basic', 'DP Difficult', 'DP Expert', 'DP Challenge'];
+var valid_mixes = Object.keys(window.versions).map(function(mix) {
+    return (parseInt(mix) - 1).toString();
+});
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Score',
+    'clear': 'Clear Halo',
+};
+var chart_map = [0, 1, 2, 3, 4, 6, 7, 8, 9];
+
+var HighScore = React.createClass({
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="grade">{this.props.score.rank}</span>
+                    <span className="score">{this.props.score.points}</span>
+                </div>
+                { this.props.score.combo > 0 ?
+                    <div>
+                        <span className="label">Combo</span>
+                        <span className="score">{this.props.score.combo}</span>
+                    </div> : null
+                }
+                <div>
+                    <span className="status">{this.props.score.halo}</span>
+                </div>
+                { this.props.score.userid && window.shownames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 10; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}</span>;
+        }
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var acat = this.state.songs[a].category;
+            var bcat = this.state.songs[b].category;
+
+            if (acat == bcat) {
+                return parseInt(b) - parseInt(a)
+            } else {
+                return bcat - acat;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = this.state.songs[songids[i]].category;
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, -curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 0) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[-songid] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 0) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={(-songid).toString()}>
+                                            <td className="subheader">{ this.state.versions[-songid] }</td>
+                                            <td className="subheader">SP Beginner</td>
+                                            <td className="subheader">SP Basic</td>
+                                            <td className="subheader">SP Difficult</td>
+                                            <td className="subheader">SP Expert</td>
+                                            <td className="subheader">SP Challenge</td>
+                                            <td className="subheader">DP Basic</td>
+                                            <td className="subheader">DP Difficult</td>
+                                            <td className="subheader">DP Expert</td>
+                                            <td className="subheader">DP Challenge</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <a href={Link.get('individual_score', songid)}>
+                                                    <div className="songname">{ this.state.songs[songid].name }</div>
+                                                    <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                </a>
+                                                <div className="songdifficulties">
+                                                    <span>SP </span>
+                                                    {this.renderDifficulty(songid, 0)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 1)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 2)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 3)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 4)}
+                                                </div>
+                                                <div className="songdifficulties">
+                                                    <span>DP </span>
+                                                    {this.renderDifficulty(songid, 6)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 7)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 8)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 9)}
+                                                </div>
+                                            </td>
+                                            <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={3}
+                                                    score={records[3]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[4] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={4}
+                                                    score={records[4]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[6] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={6}
+                                                    score={records[6]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[7] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={7}
+                                                    score={records[7]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[8] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={8}
+                                                    score={records[8]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[9] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={9}
+                                                    score={records[9]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByPercent: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[window.chart_map[this.state.subtab]]; }
+            if (br) { bc = br[window.chart_map[this.state.subtab]]; }
+
+            // Get the lamp only if the current chart exisrts
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearLamp: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[window.chart_map[this.state.subtab]]; }
+            if (br) { bc = br[window.chart_map[this.state.subtab]]; }
+
+            // Get the lamp only if the current chart exisrts
+            if (ac) { al = ac.lamp; }
+            if (bc) { bl = bc.lamp; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <th className="subheader">SP Beginner</th>
+                        <th className="subheader">SP Basic</th>
+                        <th className="subheader">SP Difficult</th>
+                        <th className="subheader">SP Expert</th>
+                        <th className="subheader">SP Challenge</th>
+                        <th className="subheader">DP Basic</th>
+                        <th className="subheader">DP Difficult</th>
+                        <th className="subheader">DP Expert</th>
+                        <th className="subheader">DP Challenge</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var difficulties = this.state.songs[songid].difficulties;
+                        var plays = this.getPlays(records);
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        <span>SP </span>
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 3)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 4)}
+                                    </div>
+                                    <div className="songdifficulties">
+                                        <span>DP </span>
+                                        {this.renderDifficulty(songid, 6)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 7)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 8)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 9)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                                <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={3}
+                                        score={records[3]}
+                                    />
+                                </td>
+                                <td className={difficulties[4] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={4}
+                                        score={records[4]}
+                                    />
+                                </td>
+                                <td className={difficulties[6] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={6}
+                                        score={records[6]}
+                                    />
+                                </td>
+                                <td className={difficulties[7] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={7}
+                                        score={records[7]}
+                                    />
+                                </td>
+                                <td className={difficulties[8] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={8}
+                                        score={records[8]}
+                                    />
+                                </td>
+                                <td className={difficulties[9] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={9}
+                                        score={records[9]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={10}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByPercent();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearLamp();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/rivals.react.js b/bemani/frontend/static/controllers/ddr/rivals.react.js
new file mode 100644
index 0000000..ba1c1be
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/rivals.react.js
@@ -0,0 +1,371 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.rivals);
+var pagenav = new History(valid_versions);
+
+var rivals_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.rivals);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            rivals: window.rivals,
+            players: window.players,
+            profiles: profiles,
+            version: version,
+            term: "",
+            results: {},
+            searching: false,
+            offset: 0,
+            limit: 5,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version, offset: 0});
+        }.bind(this));
+        this.refreshRivals();
+    },
+
+    refreshRivals: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+				setTimeout(this.refreshRivals, 5000);
+            }.bind(this)
+        );
+    },
+
+    searchForPlayers: function(event) {
+        this.setState({searching: true});
+        AJAX.post(
+            Link.get('search'),
+            {
+                version: this.state.version,
+                term: this.state.term,
+            },
+            function(response) {
+                this.setState({
+                    results: response.results,
+                    searching: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRival: function(event, userid) {
+        AJAX.post(
+            Link.get('addrival'),
+            {
+                version: this.state.version,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    removeRival: function(event, userid, pos) {
+        AJAX.post(
+            Link.get('removerival'),
+            {
+                version: this.state.version,
+                userid: userid,
+                position: pos,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    setActiveRival: function(event, userid, pos) {
+        AJAX.post(
+            Link.get('setactiverival'),
+            {
+                version: this.state.version,
+                userid: userid,
+                position: pos,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    setInactiveRival: function(event, userid, pos) {
+        AJAX.post(
+            Link.get('setinactiverival'),
+            {
+                version: this.state.version,
+                userid: userid,
+                position: pos,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRivals: function(userid) {
+        if (userid == window.userid) {
+            return null;
+        }
+
+        var avail = (this.state.rivals[this.state.version].length < 10);
+        var current_rivals = this.state.rivals[this.state.version];
+        for (var i = 0; i < current_rivals.length; i++) {
+            if (current_rivals[i].userid == userid) {
+                avail = false;
+                break;
+            }
+        }
+
+        return (
+            <span>
+                {avail ?
+                    <Add
+                        title="Add Rival"
+                        onClick={function(event) {
+                            this.addRival(event, userid);
+                        }.bind(this)}
+                    /> :
+                    null
+                }
+            </span>
+        );
+    },
+
+    render: function() {
+        if (this.state.rivals[this.state.version]) {
+            var rivals = [];
+            var active = 0;
+            this.state.rivals[this.state.version].map(function(rival) {
+                rivals[rival.position] = rival;
+                if (rivals[rival.position].active) {
+                    active++;
+                }
+            }.bind(this));
+            var resultlength = 0;
+            Object.keys(this.state.results).map(function(userid) {
+                var player = this.state.results[userid][this.state.version];
+                if (player) { resultlength++; }
+            }.bind(this));
+            return (
+                <div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            offset: 0,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <form onSubmit={this.searchForPlayers}>
+                            <label for="search">Name or DDR ID:</label>
+                            <br />
+                            <input
+                                type="text"
+                                className="inline"
+                                maxlength="9"
+                                value={this.state.term}
+                                onChange={function(event) {
+                                    var value = event.target.value.toUpperCase();
+                                    var nameRegex = /^[-&$\\.\\?!A-Z0-9 ]*$/;
+                                    // Normally, names are <= 8 characters, but we allow DDR IDs here too
+                                    if (value.length <= 9 && nameRegex.test(value)) {
+                                        this.setState({term: value});
+                                    }
+                                }.bind(this)}
+                                name="search"
+                            />
+                            <input type="submit" value="search" />
+                            { this.state.searching ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </form>
+                        {resultlength > 0 ?
+                            <table className="list players">
+                                <thead>
+                                    <tr>
+                                        <th>Name</th>
+                                        <th>DDR ID</th>
+                                        <th className="action"></th>
+                                    </tr>
+                                </thead>
+                                <tbody>{
+                                    Object.keys(this.state.results).map(function(userid, index) {
+                                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                            return null;
+                                        }
+                                        var player = this.state.results[userid][this.state.version];
+                                        if (!player) { return null; }
+
+                                        return (
+                                            <tr>
+                                                <td><Rival userid={userid} player={player} /></td>
+                                                <td>{ player.extid }</td>
+                                                <td className="edit">{this.addRivals(userid)}</td>
+                                            </tr>
+                                        );
+                                    }.bind(this))
+                                }</tbody>
+                                <tfoot>
+                                    <tr>
+                                        <td colSpan={2}>
+                                            { this.state.offset > 0 ?
+                                                <Prev onClick={function(event) {
+                                                     var page = this.state.offset - this.state.limit;
+                                                     if (page < 0) { page = 0; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                            { (this.state.offset + this.state.limit) < resultlength ?
+                                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                                     var page = this.state.offset + this.state.limit;
+                                                     if (page >= resultlength) { return; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                        </td>
+                                    </tr>
+                                </tfoot>
+                            </table> :
+                            <div className="placeholder">No players match the specified search.</div>
+                        }
+                    </div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        <table className="list players">
+                            <thead>
+                                <tr>
+                                    <th>Name</th>
+                                    <th>DDR ID</th>
+                                    <th className="action"></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(function(rivalno) {
+                                    if (!rivals[rivalno]) {
+                                        return (
+                                            <tr>
+                                                <td colSpan={2}>
+                                                    <span className="placeholder">
+                                                        no rival in this slot
+                                                    </span>
+                                                </td>
+                                            </tr>
+                                        );
+                                    }
+                                    var rival = rivals[rivalno];
+                                    var player = this.state.players[rival.userid][this.state.version];
+                                    return (
+                                        <tr>
+                                            <td>
+                                                <td><Rival userid={rival.userid} player={player} /></td>
+                                                { rival.active ?
+                                                    <div className="pill">active</div> :
+                                                    null
+                                                }
+                                            </td>
+                                            <td>{ player.extid }</td>
+                                            <td className="edit">
+                                                <Delete
+                                                    title="Remove Rival"
+                                                    onClick={function(event) {
+                                                        this.removeRival(event, rival.userid, rivalno);
+                                                    }.bind(this)}
+                                                />
+                                                { rival.active ?
+                                                    <Add
+                                                        title="Set Inactive"
+                                                        onClick={function(event) {
+                                                            this.setInactiveRival(event, rival.userid, rivalno);
+                                                        }.bind(this)}
+                                                    /> :
+                                                    (active < window.max_active_rivals[this.state.version] ?
+                                                        <Add
+                                                            title="Set Active"
+                                                            onClick={function(event) {
+                                                                this.setActiveRival(event, rival.userid, rivalno);
+                                                            }.bind(this)}
+                                                        /> :
+                                                        null
+                                                    )
+                                                }
+                                            </td>
+                                        </tr>
+                                    );
+                                }.bind(this))}
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version, offset: 0});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(rivals_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/scores.react.js b/bemani/frontend/static/controllers/ddr/scores.react.js
new file mode 100644
index 0000000..05aba33
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/scores.react.js
@@ -0,0 +1,170 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            versions: window.versions,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'SP Beginner';
+            case 1:
+                return 'SP Basic';
+            case 2:
+                return 'SP Difficult';
+            case 3:
+                return 'SP Expert';
+            case 4:
+                return 'SP Challenge';
+            case 6:
+                return 'SP Basic';
+            case 7:
+                return 'SP Difficult';
+            case 8:
+                return 'SP Expert';
+            case 9:
+                return 'SP Challenge';
+            default:
+                return 'u broke it';
+        }
+    },
+
+    renderScore: function(score) {
+        return (
+            <div className="score">
+                <div>
+                    <span className="grade">{score.rank}</span>
+                    <span className="score">{score.points}</span>
+                </div>
+                { score.combo > 0 ?
+                    <div>
+                        <span className="label">Combo</span>
+                        <span className="score">{score.combo}</span>
+                    </div> : null
+                }
+                <div>
+                    <span className="status">{score.halo}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.shownames ? <th>Name</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.shownames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            <a href={Link.get('individual_score', attempt.songid, this.convertChart(attempt.chart))}>{
+                                                 this.convertChart(attempt.chart)
+                                            }</a>
+                                        </div>
+                                        <div>
+                                            <span>{window.songs[attempt.songid].difficulties[attempt.chart]}</span>
+                                        </div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={5}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/settings.react.js b/bemani/frontend/static/controllers/ddr/settings.react.js
new file mode 100644
index 0000000..720f9f2
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/settings.react.js
@@ -0,0 +1,409 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var option_names = {
+    'character': 'Character',
+    'arrowskin': 'Arrow Skin',
+    'guidelines': 'Guide Lines',
+    'filter': 'Filter',
+};
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: window.player[version].name,
+            new_weight: (window.player[version].weight / 10).toFixed(1),
+            new_workout_mode: window.player[version].workout_mode,
+            options_changed: {},
+            options_saving: {},
+            options_saved: {},
+            editing_name: false,
+            editing_weight: false,
+            saving_early_late: false,
+            saving_background_combo: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    setOptionsChanged: function(val) {
+        this.state.options_changed[this.state.version] = val;
+        return this.state.options_changed;
+    },
+
+    setOptionsSaving: function(val) {
+        this.state.options_saving[this.state.version] = val;
+        return this.state.options_saving;
+    },
+
+    setOptionsSaved: function(val) {
+        this.state.options_saved[this.state.version] = val;
+        return this.state.options_saved;
+    },
+
+    saveOptions: function(event) {
+        this.setState({options_saving: this.setOptionsSaving(true), options_saved: this.setOptionsSaved(false)});
+        AJAX.post(
+            Link.get('updatesettings'),
+            {
+                version: this.state.version,
+                settings: this.state.player[this.state.version].settings,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].settings = response.player[this.state.version].settings;
+                this.setState({
+                    player: player,
+                    options_saving: this.setOptionsSaving(false),
+                    options_saved: this.setOptionsSaved(true),
+                    options_changed: this.setOptionsChanged(false),
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    toggleEarlyLate: function(event) {
+        this.setState({saving_early_late: true})
+        AJAX.post(
+            Link.get('updateearlylate'),
+            {
+                value: !this.state.player[this.state.version].early_late,
+                version: this.state.version,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].early_late = response.value;
+                this.setState({
+                    player: player,
+                    saving_early_late: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    toggleBackgroundCombo: function(event) {
+        this.setState({saving_background_combo: true})
+        AJAX.post(
+            Link.get('updatebackgroundcombo'),
+            {
+                value: !this.state.player[this.state.version].background_combo,
+                version: this.state.version,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].background_combo = response.value;
+                this.setState({
+                    player: player,
+                    saving_background_combo: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveWeight: function(event) {
+        AJAX.post(
+            Link.get('updateweight'),
+            {
+                version: this.state.version,
+                weight: this.state.new_weight,
+                enabled: this.state.new_workout_mode,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].weight = response.weight;
+                player[response.version].workout_mode = response.enabled;
+                this.setState({
+                    player: player,
+                    new_weight: (this.state.player[response.version].weight / 10).toFixed(1),
+                    new_workout_mode: this.state.player[response.version].workout_mode,
+                    editing_weight: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="8"
+                            size="8"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var value = event.target.value.toUpperCase();
+                                var nameRegex = /^[-&$\\.\\?!A-Z0-9 ]*$/;
+                                if (value.length <= 8 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderWeight: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Weight">{
+                !this.state.editing_weight ?
+                    <span>
+                        { player.workout_mode ?
+                            <span>{player.weight / 10} kg</span> :
+                            <span className="placeholder">workout mode disabled</span>
+                        }
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_weight: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveWeight}>
+                        <div className="row">
+                            <input
+                                name="enable_workout_mode"
+                                id="enable_workout_mode"
+                                type="checkbox"
+                                className="inline"
+                                checked={this.state.new_workout_mode}
+                                onChange={function(event) {
+                                    this.setState({
+                                        new_workout_mode: event.target.checked,
+                                    });
+                                }.bind(this)}
+                            />
+                            <label
+                                htmlFor="enable_workout_mode"
+                                className="inline"
+                            >
+                                enable workout mode
+                            </label>
+                        </div>
+                        { this.state.new_workout_mode ?
+                            <input
+                                type="text"
+                                className="inline"
+                                maxlength="5"
+                                size="5"
+                                value={this.state.new_weight}
+                                onChange={function(event) {
+                                    var value = event.target.value.toUpperCase();
+                                    var weightRegex = /^[0-9]?[0-9]?[0-9]?(\.([0-9])?)?$/;
+                                    if (value.length <= 5 && weightRegex.test(value)) {
+                                        this.setState({new_weight: value});
+                                    }
+                                }.bind(this)}
+                                name="name"
+                            /> :
+                            null
+                        }
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_weight: (this.state.player[this.state.version].weight / 10).toFixed(1),
+                                    new_workout_mode: this.state.player[this.state.version].workout_mode,
+                                    editing_weight: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    showAlert={this.state.options_changed[version]}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.editing_weight) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                            new_weight: (this.state.player[version].weight / 10).toFixed(1),
+                                            new_workout_mode: this.state.player[version].workout_mode,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                        <LabelledSection vertical={true} label="Fast/Slow Display">
+                            <span>{ this.state.player[this.state.version].early_late ? 'on' : 'off' }</span>
+                            <Toggle onClick={this.toggleEarlyLate.bind(this)} />
+                            { this.state.saving_early_late ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </LabelledSection>
+                        <LabelledSection vertical={true} label="Combo Position">
+                            <span>{ this.state.player[this.state.version].background_combo ? 'background' : 'foreground' }</span>
+                            <Toggle onClick={this.toggleBackgroundCombo.bind(this)} />
+                            { this.state.saving_background_combo ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </LabelledSection>
+                        {this.renderWeight(player)}
+                    </div>
+                    { this.state.player[this.state.version].settings ?
+                        <div className="section">
+                            <h3>Options</h3>
+                            {Object.keys(DDROptions[this.state.version]).map(function(option) {
+                                return (
+                                    <LabelledSection
+                                        className="ddr option"
+                                        vertical={true}
+                                        label={option_names[option]}
+                                    >
+                                        <SelectInt
+                                            name={option}
+                                            value={this.state.player[this.state.version].settings[option]}
+                                            choices={DDROptions[this.state.version][option]}
+                                            onChange={function(choice) {
+                                                var player = this.state.player;
+                                                player[this.state.version].settings[option] = choice;
+                                                this.setState({
+                                                    player: player,
+                                                    options_changed: this.setOptionsChanged(true),
+                                                });
+                                            }.bind(this)}
+                                        />
+                                    </LabelledSection>
+                                );
+                            }.bind(this))}
+                            <input
+                                type="submit"
+                                value="save"
+                                disabled={!this.state.options_changed[this.state.version]}
+                                onClick={function(event) {
+                                    this.saveOptions(event);
+                                }.bind(this)}
+                            />
+                            { this.state.options_saving[this.state.version] ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                            { this.state.options_saved[this.state.version] ?
+                                <span>&#x2713;</span> :
+                                null
+                            }
+                        </div> : null
+                    }
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/ddr/topscores.react.js b/bemani/frontend/static/controllers/ddr/topscores.react.js
new file mode 100644
index 0000000..a33f674
--- /dev/null
+++ b/bemani/frontend/static/controllers/ddr/topscores.react.js
@@ -0,0 +1,217 @@
+/*** @jsx React.DOM */
+
+var chart_map = [0, 1, 2, 3, 4, 6, 7, 8, 9];
+var valid_charts = ['SP Beginner', 'SP Basic', 'SP Difficult', 'SP Expert', 'SP Challenge', 'DP Basic', 'DP Difficult', 'DP Expert', 'DP Challenge'].filter(function(val, index) {
+    return window.difficulties[window.chart_map[index]] > 0;
+});
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], [], [], [], [], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialState: function(props) {
+        return {
+            topscores: this.sortTopScores(window.topscores),
+            players: window.players,
+            chart: pagenav.getInitialState(valid_charts[0]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            this.setState({chart: chart});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'SP Beginner':
+                return 0;
+            case 'SP Basic':
+                return 1;
+            case 'SP Difficult':
+                return 2;
+            case 'SP Expert':
+                return 3;
+            case 'SP Challenge':
+                return 4;
+            case 'DP Basic':
+                return 5;
+            case 'DP Difficult':
+                return 6;
+            case 'DP Expert':
+                return 7;
+            case 'DP Challenge':
+                return 8;
+            default:
+                return null;
+        }
+    },
+
+    getGroove: function(chart) {
+        return [
+            500 + window.groove[chart].stream * 11,
+            500 + window.groove[chart].chaos * 0.5,
+            500 + window.groove[chart].freeze * 1,
+            500 + window.groove[chart].air * 64,
+            500 + window.groove[chart].voltage * 4.5,
+        ];
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+        if (
+            window.groove[window.chart_map[chart]].stream != 0 ||
+            window.groove[window.chart_map[chart]].chaos != 0 ||
+            window.groove[window.chart_map[chart]].freeze != 0 ||
+            window.groove[window.chart_map[chart]].air != 0 ||
+            window.groove[window.chart_map[chart]].voltage != 0
+        ) {
+            var hasGroove = true;
+        } else {
+            var hasGroove = false;
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { hasGroove ? <div className="floating right">
+                        <RadarGraph
+                            data={{
+                                labels: ['Stream', 'Chaos', 'Freeze', 'Air', 'Voltage'],
+                                datasets: [{
+                                    data: this.getGroove(window.chart_map[chart]),
+                                    fill: true,
+                                    backgroundColor: "rgba(54, 162, 235, 0.2)",
+                                    borderColor: "rgb(54, 162, 235)",
+                                }],
+                            }}
+                            options={{
+                                scale: {
+                                    ticks: {
+                                        callback: function(tick, index, ticks) {
+                                            return '';
+                                        },
+                                        min: 0,
+                                        max: 4000,
+                                        beginAtZero: true,
+                                        stepSize: 4000,
+                                    },
+                                },
+                                elements: {
+                                    point: {
+                                        radius: 0,
+                                    },
+                                },
+                                legend: {
+                                    display: false,
+                                },
+                                tooltips: {
+                                    enabled: false,
+                                },
+                                animation: false,
+                                responsive: false,
+                            }}
+                            width="250"
+                            height="200"
+                        />
+                    </div> : null }
+                    <div className="left">
+                        <div className="songname">{window.name}</div>
+                        <div className="songartist">{window.artist}</div>
+                        <div className="songdifficulty">{window.difficulties[window.chart_map[chart]]}</div>
+                    </div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    this.setState({chart: chart});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+                    <Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Grade',
+                                render: function(topscore) { return topscore.rank; },
+                            },
+                            {
+                                name: 'Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Combo',
+                                render: function(topscore) { return topscore.combo > 0 ? topscore.combo : ''; },
+                            },
+                            {
+                                name: 'Halo',
+                                render: function(topscore) { return topscore.halo; },
+                            },
+                        ]}
+                        defaultsort='Score'
+                        rows={this.state.topscores[window.chart_map[chart]]}
+                        key={window.chart_map[chart]}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/home.react.js b/bemani/frontend/static/controllers/home.react.js
new file mode 100644
index 0000000..82e7919
--- /dev/null
+++ b/bemani/frontend/static/controllers/home.react.js
@@ -0,0 +1,30 @@
+/*** @jsx React.DOM */
+
+var home = React.createClass({
+    getInitialState: function(props) {
+        return {
+            news: window.news,
+        };
+    },
+
+    render: function() {
+        return (
+            <div>{
+                this.state.news.map(function(entry) {
+                    return (
+                        <div className="section">
+                            <h3>{ entry.title }</h3>
+                            <Timestamp timestamp={entry.timestamp} />
+                            <div dangerouslySetInnerHTML={ {__html: entry.body} }></div>
+                        </div>
+                    );
+                }.bind(this))
+            }</div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(home, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/allplayers.react.js b/bemani/frontend/static/controllers/iidx/allplayers.react.js
new file mode 100644
index 0000000..54292be
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/allplayers.react.js
@@ -0,0 +1,149 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'DJ Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'IIDX ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.sp + player.dp;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return (a.sp + a.dp) - (b.sp + b.dp);
+                                }.bind(this),
+                                reverse: true,
+                            },
+                            {
+                                name: 'Arcade',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.arcade;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.arcade.localeCompare(b.arcade);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'SP Dan',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.sdan;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.srank - b.srank;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                            {
+                                name: 'DP Dan',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.ddan;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.drank - b.drank;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                            {
+                                name: 'SP DJ Points',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.sdjp;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.sdjp - b.sdjp;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                            {
+                                name: 'DP DJ Points',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.ddjp;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.ddjp - b.ddjp;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/player.react.js b/bemani/frontend/static/controllers/iidx/player.react.js
new file mode 100644
index 0000000..57db71c
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/player.react.js
@@ -0,0 +1,202 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            sp_rival: window.sp_rival,
+            dp_rival: window.dp_rival,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+            updating_rivals: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function(skip_timeout) {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                    sp_rival: response.sp_rival,
+                    dp_rival: response.dp_rival,
+                    updating_rivals: false,
+                });
+                if (skip_timeout) {
+                    // Don't refresh, we were called from rival code
+                } else {
+                    // Refresh every 5 seconds to show live rival updating
+                    setTimeout(this.refreshProfile, 5000);
+                }
+            }.bind(this)
+        );
+    },
+
+    addRival: function(event, type) {
+        this.setState({updating_rivals: true});
+        AJAX.post(
+            Link.get('addrival'),
+            {
+                version: this.state.version,
+                type: type,
+                userid: window.playerid,
+            },
+            function(response) {
+                this.refreshProfile(true);
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    removeRival: function(event, type, userid) {
+        this.setState({updating_rivals: true});
+        AJAX.post(
+            Link.get('removerival'),
+            {
+                version: this.state.version,
+                type: type,
+                userid: window.playerid,
+            },
+            function(response) {
+                this.refreshProfile(true);
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>dj {player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <LabelledSection className="centered padded filled" label="SP Stats">
+                            <div>{player.sdan}</div>
+                            <div>{player.sdjp} DJ POINT</div>
+                            <div>{player.sp}回</div>
+                        </LabelledSection>
+                        <LabelledSection className="centered padded filled" label="DP Stats">
+                            <div>{player.ddan}</div>
+                            <div>{player.ddjp} DJ POINT</div>
+                            <div>{player.dp}回</div>
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view dj {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all dj {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                    { window.own_profile ? null :
+                        <div className="section">
+                            { player.sp_rival ?
+                                <Delete
+                                    title="Remove SP Rival"
+                                    onClick={function(event) {
+                                        this.removeRival(event, 'sp_rival');
+                                    }.bind(this)}
+                                /> :
+                                <Add
+                                    title="Add SP Rival"
+                                    onClick={function(event) {
+                                        this.addRival(event, 'sp_rival');
+                                    }.bind(this)}
+                                />
+                            }
+                            { player.dp_rival ?
+                                <Delete
+                                    title="Remove DP Rival"
+                                    onClick={function(event) {
+                                        this.removeRival(event, 'dp_rival');
+                                    }.bind(this)}
+                                /> :
+                                <Add
+                                    title="Add DP Rival"
+                                    onClick={function(event) {
+                                        this.addRival(event, 'dp_rival');
+                                    }.bind(this)}
+                                />
+                            }
+                            { this.state.updating_rivals ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> : null
+                            }
+                        </div>
+                    }
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/records.react.js b/bemani/frontend/static/controllers/iidx/records.react.js
new file mode 100644
index 0000000..0e31fe2
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/records.react.js
@@ -0,0 +1,641 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['SPN', 'SPH', 'SPA', 'DPN', 'DPH', 'DPA'];
+var valid_mixes = Object.keys(window.versions).map(function(mix) {
+    return (parseInt(mix) - 1).toString();
+});
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Grade',
+    'clear': 'Clear Lamp',
+};
+
+var HighScore = React.createClass({
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        var topscore = window.songs[this.props.songid].notecounts[this.props.chart] * 2;
+        var percent = this.props.score.points / topscore;
+        var grade = parseInt(9.0 * percent);
+        var grades = [
+            "F",
+            "F",
+            "E",
+            "D",
+            "C",
+            "B",
+            "A",
+            "AA",
+            "AAA",
+            "MAX",
+        ];
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="grade">{grades[grade]}</span>
+                    <span className="percent">{(percent * 100).toFixed(2)}%</span>
+                </div>
+                <div>
+                    <span className="label">EX</span>
+                    <span className="score">{this.props.score.points}</span>
+                    <span className="label">M</span>
+                    <span className="score">{this.props.score.miss_count < 0 ? '-' : this.props.score.miss_count}</span>
+                </div>
+                <div>
+                    <span className="status">{this.props.score.status}</span>
+                </div>
+                { this.props.score.userid && window.showdjnames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 6; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}★</span>;
+        }
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            return parseInt(b) - parseInt(a)
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = Math.floor(songids[i] / 1000);
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 1000) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[songid] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 1000) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="subheader">{ this.state.versions[songid] }</td>
+                                            <td className="subheader">SPN</td>
+                                            <td className="subheader">SPH</td>
+                                            <td className="subheader">SPA</td>
+                                            <td className="subheader">DPN</td>
+                                            <td className="subheader">DPH</td>
+                                            <td className="subheader">DPA</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <a href={Link.get('individual_score', songid)}>
+                                                    <div className="songname">{ this.state.songs[songid].name }</div>
+                                                    <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                    <div className="songgenre">{ this.state.songs[songid].genre }</div>
+                                                </a>
+                                                <div className="songdifficulties">
+                                                    {this.renderDifficulty(songid, 0)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 1)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 2)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 3)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 4)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 5)}
+                                                </div>
+                                            </td>
+                                            <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={3}
+                                                    score={records[3]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[4] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={4}
+                                                    score={records[4]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[5] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={5}
+                                                    score={records[5]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByPercent: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+
+            // Get the lamp only if the current chart exisrts
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            var ats = window.songs[a].notecounts[this.state.subtab] * 2;
+            var bts = window.songs[b].notecounts[this.state.subtab] * 2;
+            var ap = as / ats;
+            var bp = bs / bts;
+
+            if (bts == ats) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearLamp: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+
+            // Get the lamp only if the current chart exisrts
+            if (ac) { al = ac.lamp; }
+            if (bc) { bl = bc.lamp; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <th className="subheader">SPN</th>
+                        <th className="subheader">SPH</th>
+                        <th className="subheader">SPA</th>
+                        <th className="subheader">DPN</th>
+                        <th className="subheader">DPH</th>
+                        <th className="subheader">DPA</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var difficulties = this.state.songs[songid].difficulties;
+                        var plays = this.getPlays(records);
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                            <div className="songgenre">{ this.state.songs[songid].genre }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 3)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 4)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 5)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                                <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={3}
+                                        score={records[3]}
+                                    />
+                                </td>
+                                <td className={difficulties[4] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={4}
+                                        score={records[4]}
+                                    />
+                                </td>
+                                <td className={difficulties[5] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={5}
+                                        score={records[5]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={7}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByPercent();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearLamp();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/rivals.react.js b/bemani/frontend/static/controllers/iidx/rivals.react.js
new file mode 100644
index 0000000..b21a4eb
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/rivals.react.js
@@ -0,0 +1,335 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.rivals);
+var pagenav = new History(valid_versions);
+
+var rivals_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.rivals);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            rivals: window.rivals,
+            players: window.players,
+            profiles: profiles,
+            version: version,
+            term: "",
+            results: {},
+            searching: false,
+            offset: 0,
+            limit: 5,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version, offset: 0});
+        }.bind(this));
+        this.refreshRivals();
+    },
+
+    refreshRivals: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+				setTimeout(this.refreshRivals, 5000);
+            }.bind(this)
+        );
+    },
+
+    searchForPlayers: function(event) {
+        this.setState({searching: true});
+        AJAX.post(
+            Link.get('search'),
+            {
+                version: this.state.version,
+                term: this.state.term,
+            },
+            function(response) {
+                this.setState({
+                    results: response.results,
+                    searching: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRival: function(event, type, userid) {
+        AJAX.post(
+            Link.get('addrival'),
+            {
+                version: this.state.version,
+                type: type,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    removeRival: function(event, type, userid) {
+        AJAX.post(
+            Link.get('removerival'),
+            {
+                version: this.state.version,
+                type: type,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addSPDPRivals: function(userid) {
+        if (userid == window.userid) {
+            return null;
+        }
+
+        var sp_avail = true;
+        var dp_avail = true;
+        var sp_count = 0;
+        var dp_count = 0;
+        var current_rivals = this.state.rivals[this.state.version];
+        for (var i = 0; i < current_rivals.length; i++) {
+            if (current_rivals[i].type == 'sp_rival') { sp_count++; }
+            if (current_rivals[i].type == 'dp_rival') { dp_count++; }
+            if (current_rivals[i].userid == userid) {
+                if (current_rivals[i].type == 'sp_rival') { sp_avail = false; }
+                if (current_rivals[i].type == 'dp_rival') { dp_avail = false; }
+            }
+        }
+
+        if (sp_count >= 5) { sp_avail = false; }
+        if (dp_count >= 5) { dp_avail = false; }
+
+        return (
+            <span>
+                {sp_avail ?
+                    <Add
+                        title="Add SP Rival"
+                        onClick={function(event) {
+                            this.addRival(event, 'sp_rival', userid);
+                        }.bind(this)}
+                    /> :
+                    null
+                }
+                {dp_avail ?
+                    <Add
+                        title="Add DP Rival"
+                        onClick={function(event) {
+                            this.addRival(event, 'dp_rival', userid);
+                        }.bind(this)}
+                    /> :
+                    null
+                }
+            </span>
+        );
+    },
+
+    render: function() {
+        if (this.state.rivals[this.state.version]) {
+            var rivals = this.state.rivals[this.state.version];
+            var resultlength = 0;
+            Object.keys(this.state.results).map(function(userid, index) {
+                var player = this.state.results[userid][this.state.version];
+                if (player) { resultlength++; }
+            }.bind(this));
+            return (
+                <div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            offset: 0,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <form onSubmit={this.searchForPlayers}>
+                            <label for="search">DJ Name or IIDX ID:</label>
+                            <br />
+                            <input
+                                type="text"
+                                className="inline"
+                                maxlength="9"
+                                value={this.state.term}
+                                onChange={function(event) {
+                                    var value = event.target.value.toUpperCase();
+                                    var intRegex = /^[-&$#\\.\\?\\*!A-Z0-9]*$/;
+                                    // Normally, names are <= 6 characters, but we allow IIDX IDs here too
+                                    if (value.length <= 9 && intRegex.test(value)) {
+                                        this.setState({term: value});
+                                    }
+                                }.bind(this)}
+                                name="search"
+                            />
+                            <input type="submit" value="search" />
+                            { this.state.searching ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </form>
+                        {resultlength > 0 ?
+                            <table className="list players">
+                                <thead>
+                                    <tr>
+                                        <th>DJ Name</th>
+                                        <th>IIDX ID</th>
+                                        <th>SP Dan</th>
+                                        <th>DP Dan</th>
+                                        <th>SP DJ Points</th>
+                                        <th>DP DJ Points</th>
+                                        <th className="action"></th>
+                                    </tr>
+                                </thead>
+                                <tbody>{
+                                    Object.keys(this.state.results).map(function(userid, index) {
+                                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                            return null;
+                                        }
+                                        var player = this.state.results[userid][this.state.version];
+                                        if (!player) { return null; }
+
+                                        return (
+                                            <tr>
+                                                <td><Rival userid={userid} player={player} /></td>
+                                                <td>{ player.extid }</td>
+                                                <td>{ player.sdan }</td>
+                                                <td>{ player.ddan }</td>
+                                                <td>{ player.sdjp }</td>
+                                                <td>{ player.ddjp }</td>
+                                                <td className="edit">{this.addSPDPRivals(userid)}</td>
+                                            </tr>
+                                        );
+                                    }.bind(this))
+                                }</tbody>
+                                <tfoot>
+                                    <tr>
+                                        <td colSpan={6}>
+                                            { this.state.offset > 0 ?
+                                                <Prev onClick={function(event) {
+                                                     var page = this.state.offset - this.state.limit;
+                                                     if (page < 0) { page = 0; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                            { (this.state.offset + this.state.limit) < resultlength ?
+                                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                                     var page = this.state.offset + this.state.limit;
+                                                     if (page >= resultlength) { return; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                        </td>
+                                    </tr>
+                                </tfoot>
+                            </table> :
+                            <div className="placeholder">No players match the specified search.</div>
+                        }
+                    </div>
+                    {['sp_rival', 'dp_rival'].map(function(rival_type) {
+                        var type = '';
+                        if (rival_type == 'sp_rival') {
+                            type = 'SP';
+                        } else {
+                            type = 'DP';
+                        }
+
+                        return (
+                            <div className="section">
+                                <h3>{type} Rivals</h3>
+                                <table className="list players">
+                                    <thead>
+                                        <tr>
+                                            <th>DJ Name</th>
+                                            <th>IIDX ID</th>
+                                            <th>{type} Dan</th>
+                                            <th>{type} DJ Points</th>
+                                            <th className="action"></th>
+                                        </tr>
+                                    </thead>
+                                    <tbody>
+                                        {this.state.rivals[this.state.version].map(function(rival, index) {
+                                            if (rival.type != rival_type) { return null; }
+                                            var player = this.state.players[rival.userid][this.state.version];
+                                            return (
+                                                <tr>
+                                                    <td><Rival userid={rival.userid} player={player} /></td>
+                                                    <td>{ player.extid }</td>
+                                                    <td>{ rival_type == 'sp_rival' ? player.sdan : player.ddan }</td>
+                                                    <td>{ rival_type == 'sp_rival' ? player.sdjp : player.ddjp }</td>
+                                                    <td className="edit">
+                                                        <Delete
+                                                            title="Remove Rival"
+                                                            onClick={function(event) {
+                                                                this.removeRival(event, rival_type, rival.userid);
+                                                            }.bind(this)}
+                                                        />
+                                                    </td>
+                                                </tr>
+                                            );
+                                        }.bind(this))}
+                                    </tbody>
+                                </table>
+                            </div>
+                        );
+                    }.bind(this))}
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version, offset: 0});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(rivals_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/scores.react.js b/bemani/frontend/static/controllers/iidx/scores.react.js
new file mode 100644
index 0000000..5d21da9
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/scores.react.js
@@ -0,0 +1,192 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            versions: window.versions,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'SPN';
+            case 1:
+                return 'SPH';
+            case 2:
+                return 'SPA';
+            case 3:
+                return 'DPN';
+            case 4:
+                return 'DPH';
+            case 5:
+                return 'DPA';
+            case 6:
+                return 'BEGINNER';
+            default:
+                return 'u broke it';
+        }
+    },
+
+    renderScore: function(score) {
+        var topscore = window.songs[score.songid].notecounts[score.chart] * 2;
+        var percent = score.points / topscore;
+        var grade = parseInt(9.0 * percent);
+        var grades = [
+            "F",
+            "F",
+            "E",
+            "D",
+            "C",
+            "B",
+            "A",
+            "AA",
+            "AAA",
+            "MAX",
+        ];
+
+        return (
+            <div className="score">
+                {topscore > 0 ?
+                    <div>
+                        <span className="grade">{grades[grade]}</span>
+                        <span className="percent">{(percent * 100).toFixed(2)}%</span>
+                    </div> :
+                    null
+                }
+                <div>
+                    <span className="label">EX</span>
+                    <span className="score">{score.points}</span>
+                    <span className="label">M</span>
+                    <span className="score">{score.miss_count < 0 ? '-' : score.miss_count}</span>
+                </div>
+                <div>
+                    <span className="status">{score.status}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.showdjnames ? <th>DJ Name</th> : null }
+                            { window.showdjnames ? <th>Arcade</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.showdjnames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    { window.showdjnames ? <td>{ this.state.players[attempt.userid].arcade }</td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                            <div className="songgenre">{ this.state.songs[attempt.songid].genre }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            {attempt.chart == 6 ?
+                                                this.convertChart(attempt.chart) :
+                                                <a href={Link.get('individual_score', attempt.songid, this.convertChart(attempt.chart))}>{
+                                                     this.convertChart(attempt.chart)
+                                                }</a>
+                                            }
+                                        </div>
+                                        <div>{attempt.chart == 6 ?
+                                            null :
+                                            <span>{window.songs[attempt.songid].difficulties[attempt.chart]}★</span>
+                                        }</div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={6}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/settings.react.js b/bemani/frontend/static/controllers/iidx/settings.react.js
new file mode 100644
index 0000000..657213f
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/settings.react.js
@@ -0,0 +1,461 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var menu_option_names = {
+    'alphabet': 'alphabet folders',
+    'difficulty': 'difficulty folders',
+    'disable_song_preview': 'disable song previews',
+    'effector_lock': 'lock effector',
+    'grade': 'grade folders',
+    'hide_play_count': 'hide play count on profile',
+    'rival_info': 'rival info box',
+    'rival_played': 'rival played folders',
+    'rival_win_lose': 'rival win/lose folders',
+    'status': 'status folders',
+};
+var valid_menu_options = [
+    'grade',
+    'status',
+    'difficulty',
+    'alphabet',
+    'rival_played',
+    'rival_win_lose',
+    'rival_info',
+    'hide_play_count',
+    'disable_song_preview',
+    'effector_lock',
+];
+var theme_option_names = {
+    'beam': 'Note Beam',
+    'bgm': 'Menu BGM',
+    'burst': 'Note Burst',
+    'frame': 'Frame',
+    'full_combo': 'Full Combo Effect',
+    'judge': 'Judge Font',
+    'noteskin': 'Note Skin',
+    'towel': 'Lane Cover',
+    'turntable': 'Turntable Decal',
+    'voice': 'Menu Announcer Voice',
+    'pacemaker': 'Pacemaker Skin',
+    'effector_preset': 'Effector Preset',
+};
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            menu_changed: {},
+            theme_changed: {},
+            menu_saving: {},
+            theme_saving: {},
+            menu_saved: {},
+            theme_saved: {},
+            new_name: window.player[version].name,
+            editing_name: false,
+            new_prefecture: window.player[version].prefecture,
+            editing_prefecture: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    setMenuChanged: function(val) {
+        this.state.menu_changed[this.state.version] = val;
+        return this.state.menu_changed;
+    },
+
+    setMenuSaving: function(val) {
+        this.state.menu_saving[this.state.version] = val;
+        return this.state.menu_saving;
+    },
+
+    setMenuSaved: function(val) {
+        this.state.menu_saved[this.state.version] = val;
+        return this.state.menu_saved;
+    },
+
+    setThemeChanged: function(val) {
+        this.state.theme_changed[this.state.version] = val;
+        return this.state.theme_changed;
+    },
+
+    setThemeSaving: function(val) {
+        this.state.theme_saving[this.state.version] = val;
+        return this.state.theme_saving;
+    },
+
+    setThemeSaved: function(val) {
+        this.state.theme_saved[this.state.version] = val;
+        return this.state.theme_saved;
+    },
+
+    saveMenuOptions: function(event) {
+        this.setState({menu_saving: this.setMenuSaving(true), menu_saved: this.setMenuSaved(false)});
+        AJAX.post(
+            Link.get('updateflags'),
+            {
+                version: this.state.version,
+                flags: this.state.player[this.state.version].flags,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].flags = response.flags;
+                this.setState({
+                    player: player,
+                    menu_saving: this.setMenuSaving(false),
+                    menu_saved: this.setMenuSaved(true),
+                    menu_changed: this.setMenuChanged(false),
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveThemeOptions: function(event) {
+        this.setState({theme_saving: this.setThemeSaving(true), theme_saved: this.setThemeSaved(false)});
+        AJAX.post(
+            Link.get('updatesettings'),
+            {
+                version: this.state.version,
+                settings: this.state.player[this.state.version].settings,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].settings = response.settings;
+                this.setState({
+                    player: player,
+                    theme_saving: this.setThemeSaving(false),
+                    theme_saved: this.setThemeSaved(true),
+                    theme_changed: this.setThemeChanged(false),
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    saveDJName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    savePrefecture: function(event) {
+        AJAX.post(
+            Link.get('updateprefecture'),
+            {
+                version: this.state.version,
+                prefecture: this.state.new_prefecture,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].prefecture = response.prefecture;
+                this.setState({
+                    player: player,
+                    new_prefecture: this.state.player[response.version].prefecture,
+                    editing_prefecture: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    leaveArcade: function(event) {
+        AJAX.post(
+            Link.get('leavearcade'),
+            {
+                version: this.state.version,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].arcade = "";
+                this.setState({
+                    player: player,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderDJName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="DJ Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveDJName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="6"
+                            size="6"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var value = event.target.value.toUpperCase();
+                                var intRegex = /^[-&$#\\.\\?\\*!A-Z0-9]*$/;
+                                if (value.length <= 6 && intRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderPrefecture: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Prefecture">{
+                !this.state.editing_prefecture ?
+                    <span>
+                        <span>{Regions[player.prefecture]}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_prefecture: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.savePrefecture}>
+                        <SelectInt
+                            name="prefecture"
+                            value={this.state.new_prefecture}
+                            choices={Regions}
+                            onChange={function(choice) {
+                                this.setState({new_prefecture: choice});
+                            }.bind(this)}
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_prefecture: this.state.player[this.state.version].prefecture,
+                                    editing_prefecture: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    renderHomeArcade: function(player) {
+        if (!player.arcade || player.arcade == "") {
+            return (
+                <LabelledSection vertical={true} label="Home Arcade">
+                    <span className="placeholder">no arcade</span>
+                </LabelledSection>
+            );
+        }
+
+        return (
+            <LabelledSection vertical={true} label="Home Arcade">
+                <span>{player.arcade}</span>
+                <Delete
+                    title='leave arcade'
+                    onClick={function(event) {
+                        this.leaveArcade(event);
+                    }.bind(this)}
+                />
+            </LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    showAlert={this.state.menu_changed[version] || this.state.theme_changed[version]}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name || this.state.editing_prefecture) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                            new_prefecture: this.state.player[version].prefecture,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderDJName(player)}
+                        {this.renderPrefecture(player)}
+                        {this.renderHomeArcade(player)}
+                    </div>
+                    <div className="section">
+                        <h3>Theme</h3>
+                        {Object.keys(IIDXOptions[this.state.version]).map(function(theme_option) {
+                            return (
+                                <LabelledSection
+                                    className="iidx themeoption"
+                                    vertical={true}
+                                    label={theme_option_names[theme_option]}
+                                >
+                                    <SelectInt
+                                        name={theme_option}
+                                        value={player.settings[theme_option]}
+                                        choices={IIDXOptions[this.state.version][theme_option]}
+                                        onChange={function(choice) {
+                                            var player = this.state.player;
+                                            player[this.state.version].settings[theme_option] = choice;
+                                            this.setState({
+                                                player: player,
+                                                theme_changed: this.setThemeChanged(true),
+                                            });
+                                        }.bind(this)}
+                                    />
+                                </LabelledSection>
+                            );
+                        }.bind(this))}
+                        <input
+                            type="submit"
+                            value="save"
+                            disabled={!this.state.theme_changed[this.state.version]}
+                            onClick={function(event) {
+                                this.saveThemeOptions(event);
+                            }.bind(this)}
+                        />
+                        { this.state.theme_saving[this.state.version] ?
+                            <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                        }
+                        { this.state.theme_saved[this.state.version] ?
+                            <span>&#x2713;</span> :
+                            null
+                        }
+                    </div>
+                    <div className="section">
+                        <h3>Menu Options</h3>
+                        {valid_menu_options.map(function(menu_option) {
+                            return (
+                                <div className="iidx menuoption">
+                                    <input
+                                        name={menu_option}
+                                        id={menu_option}
+                                        type="checkbox"
+                                        checked={player.flags[menu_option]}
+                                        onChange={function(event) {
+                                            var player = this.state.player;
+                                            player[this.state.version].flags[menu_option] = event.target.checked;
+                                            this.setState({
+                                                player: player,
+                                                menu_changed: this.setMenuChanged(true),
+                                            });
+                                        }.bind(this)}
+                                    />
+                                    <label htmlFor={menu_option}>{menu_option_names[menu_option]}</label>
+                                </div>
+                            );
+                        }.bind(this))}
+                        <input
+                            type="submit"
+                            disabled={!this.state.menu_changed[this.state.version]}
+                            value="save"
+                            onClick={function(event) {
+                                this.saveMenuOptions(event);
+                            }.bind(this)}
+                        />
+                        { this.state.menu_saving[this.state.version] ?
+                            <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                            null
+                        }
+                        { this.state.menu_saved[this.state.version] ?
+                            <span>&#x2713;</span> :
+                            null
+                        }
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/iidx/topscores.react.js b/bemani/frontend/static/controllers/iidx/topscores.react.js
new file mode 100644
index 0000000..ab69f33
--- /dev/null
+++ b/bemani/frontend/static/controllers/iidx/topscores.react.js
@@ -0,0 +1,394 @@
+/*** @jsx React.DOM */
+
+var valid_charts = ['SPN', 'SPH', 'SPA', 'DPN', 'DPH', 'DPA'].filter(function(val, index) {
+    return window.difficulties[index] > 0;
+});
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialViewingState: function(topscores, chart) {
+        var index = this.convertChart(chart);
+        if (topscores[index].length > 0) {
+            var hash = null;
+            var maxpoints = 0;
+            topscores[index].map(function(topscore) {
+                if (topscore.points > maxpoints) {
+                    hash = this.hashScore(topscore);
+                    maxpoints = topscore.points;
+                }
+            }.bind(this));
+            return [hash, null, null, null, null];
+        } else {
+            return [null, null, null, null, null];
+        }
+    },
+
+    hashScore: function(topscore) {
+        if (topscore.ghost) {
+            return topscore.songid + '-' + topscore.chart + '-' + topscore.ghost.join(',');
+        } else {
+            return topscore.songid + '-' + topscore.chart;
+        }
+    },
+
+    getInitialState: function(props) {
+        var topscores = this.sortTopScores(window.topscores);
+        var chart = pagenav.getInitialState(valid_charts[0]);
+        var viewing = this.getInitialViewingState(topscores, chart);
+        return {
+            topscores: topscores,
+            players: window.players,
+            chart: chart,
+            viewing: viewing,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            var viewing = this.getInitialViewingState(this.state.topscores, chart);
+            this.setState({chart: chart, viewing: viewing});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'SPN':
+                return 0;
+            case 'SPH':
+                return 1;
+            case 'SPA':
+                return 2;
+            case 'DPN':
+                return 3;
+            case 'DPH':
+                return 4;
+            case 'DPA':
+                return 5
+            default:
+                return null;
+        }
+    },
+
+    renderGrade: function(chart, topscore) {
+        var maxscore = window.notecounts[chart] * 2;
+        var percent = topscore.points / maxscore;
+        var grade = parseInt(9.0 * percent);
+        var grades = [
+            "F",
+            "F",
+            "E",
+            "D",
+            "C",
+            "B",
+            "A",
+            "AA",
+            "AAA",
+            "MAX",
+        ];
+
+        var hash = this.hashScore(topscore);
+        var index = this.state.viewing.indexOf(hash);
+        var style = {};
+        if (index >= 0) {
+            style.color = this.getGhostColors()[index];
+        }
+
+        return (
+            <div className="score">
+                <Checkbox
+                    checked={index >= 0}
+                    onClick={function(event) {
+                        if (index >= 0) {
+                            // Remove it if it exists
+                            var viewing = this.state.viewing;
+                            viewing[index] = null;
+                            this.setState({viewing: viewing});
+                        } else {
+                            // Add it if it doesn't exist and there's room
+                            var addindex = this.state.viewing.indexOf(null);
+                            if (addindex >= 0) {
+                                var viewing = this.state.viewing;
+                                viewing[addindex] = hash;
+                                this.setState({viewing: viewing});
+                            }
+                        }
+                    }.bind(this)}
+                />
+                <span style={style}>
+                    <span className="grade">{grades[grade]}</span>
+                    <span className="percent">{(percent * 100).toFixed(2)}%</span>
+                </span>
+            </div>
+        );
+    },
+
+    calculateGhost: function(ghost) {
+        var total = 0;
+        var ghost = ghost.map(function(val) {
+            var out = val + total;
+            total = total + val;
+            return out;
+        });
+        ghost.unshift(0);
+        return ghost;
+    },
+
+    getGhostColors: function() {
+        return [
+            'rgba(255,99,132,1)',
+            'rgba(255,153,0,1)',
+            'rgba(153,204,0,1)',
+            'rgba(0,204,255,1)',
+            'rgba(153,51,255,1)',
+        ];
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+
+        // Handle rendering the chart, finding any non-null viewing indexes
+        var ghosts = Array(this.state.viewing.length).fill(null);
+        var colors = this.getGhostColors();
+        var notecounts = null;
+        var aaa = null;
+        var aa = null;
+        var a = null;
+        var zero = null;
+
+        this.state.topscores[chart].map(function(topscore) {
+            var index = this.state.viewing.indexOf(this.hashScore(topscore));
+            if (index >= 0) {
+                ghosts[index] = this.calculateGhost(topscore.ghost);
+            }
+        }.bind(this));
+
+        // Filter out to preserve colors at the time of selection
+        colors = colors.filter(function(color, index) {
+            return ghosts[index] != null;
+        });
+        ghosts = ghosts.filter(function(ghost) {
+            return ghost != null;
+        });
+        if (ghosts.length > 0) {
+            notecounts = window.notecounts[chart] * 2
+            aaa = Array(ghosts[0].length).fill(notecounts * (8/9));
+            aa = Array(ghosts[0].length).fill(notecounts * (7/9));
+            a = Array(ghosts[0].length).fill(notecounts * (6/9));
+            zero = Array(ghosts[0].length).fill(0);
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    <div className="floating right">{ ghosts.length > 0 ?
+                        <div className="section">
+                            <LineGraph
+                                data={{
+                                    labels: zero,
+                                    datasets: ghosts.map(function(ghost, index) {
+                                        return {
+                                            fill: false,
+                                            data: ghost,
+                                            borderColor: [
+                                                colors[index],
+                                            ],
+                                            borderWidth: 2,
+                                        };
+                                    }.bind(this)).concat([
+                                        {
+                                            fill: false,
+                                            data: aaa,
+                                            borderColor: [
+                                                'rgba(0,0,0,0.25)',
+                                            ],
+                                            borderWidth: 1,
+                                        },
+                                        {
+                                            fill: false,
+                                            data: aa,
+                                            borderColor: [
+                                                'rgba(0,0,0,0.25)',
+                                            ],
+                                            borderWidth: 1,
+                                        },
+                                        {
+                                            fill: false,
+                                            data: a,
+                                            borderColor: [
+                                                'rgba(0,0,0,0.25)',
+                                            ],
+                                            borderWidth: 1,
+                                        },
+                                        {
+                                            fill: false,
+                                            data: zero,
+                                            borderColor: [
+                                                'rgba(0,0,0,0.25)',
+                                            ],
+                                            borderWidth: 1,
+                                        },
+                                    ]),
+                                }}
+                                options={{
+                                    scales: {
+                                        xAxes: [{
+                                            display: false,
+                                        }],
+                                        yAxes: [{
+                                            grid: {
+                                                display: false,
+                                            },
+                                            gridLines: {
+                                                display: false,
+                                            },
+                                            ticks: {
+                                                callback: function(tick, index, ticks) {
+                                                    switch(index) {
+                                                        case 0:
+                                                            return 'MAX';
+                                                        case 1:
+                                                            return 'AAA';
+                                                        case 2:
+                                                            return 'AA';
+                                                        case 3:
+                                                            return 'A';
+                                                        default:
+                                                            return '';
+                                                    }
+                                                },
+                                                beginAtZero:true,
+                                                min: 0,
+                                                max: notecounts,
+                                                stepSize: notecounts / 9,
+                                            }
+                                        }],
+                                    },
+                                    elements: {
+                                        point: {
+                                            radius: 0,
+                                        },
+                                    },
+                                    legend: {
+                                        display: false,
+                                    },
+                                    tooltips: {
+                                        enabled: false,
+                                    },
+                                    responsive: false,
+                                    animation: false,
+                                }}
+                                width="320"
+                                height="200"
+                            />
+                        </div> : <div style={{width: '320px', height: '200px'}}></div>
+                    }</div>
+                    <div className="left">
+                        <div className="songname">{window.name}</div>
+                        <div className="songartist">{window.artist}</div>
+                        <div className="songgenre">{window.genre}</div>
+                        <div className="songdifficulty">{window.difficulties[chart]}★</div>
+                    </div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    var viewing = this.getInitialViewingState(this.state.topscores, chart);
+                                    this.setState({chart: chart, viewing: viewing});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+                    <Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'DJ Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Arcade',
+                                render: function(topscore) { return this.state.players[topscore.userid].arcade; }.bind(this),
+                            },
+                            {
+                                name: 'Status',
+                                render: function(topscore) { return topscore.status; },
+                            },
+                            {
+                                name: 'Grade',
+                                render: function(topscore) { return this.renderGrade(chart, topscore); }.bind(this),
+                            },
+                            {
+                                name: 'EX Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Miss Count',
+                                render: function(topscore) { return topscore.miss_count; },
+                                sort: function(a, b) {
+                                    return a.miss_count - b.miss_count;
+                                },
+                            },
+                        ]}
+                        defaultsort='EX Score'
+                        rows={this.state.topscores[chart]}
+                        key={chart}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/jubeat/allplayers.react.js b/bemani/frontend/static/controllers/jubeat/allplayers.react.js
new file mode 100644
index 0000000..7141e4e
--- /dev/null
+++ b/bemani/frontend/static/controllers/jubeat/allplayers.react.js
@@ -0,0 +1,85 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Jubeat ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.plays;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.plays - b.plays;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    /> 
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/jubeat/player.react.js b/bemani/frontend/static/controllers/jubeat/player.react.js
new file mode 100644
index 0000000..3cb5867
--- /dev/null
+++ b/bemani/frontend/static/controllers/jubeat/player.react.js
@@ -0,0 +1,115 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Total Plays">
+                            {player.plays}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/jubeat/records.react.js b/bemani/frontend/static/controllers/jubeat/records.react.js
new file mode 100644
index 0000000..31d0b7e
--- /dev/null
+++ b/bemani/frontend/static/controllers/jubeat/records.react.js
@@ -0,0 +1,545 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['Basic', 'Advanced', 'Extreme'];
+var valid_mixes = Object.keys(window.versions).map(function(mix) {
+    return (parseInt(mix) - 1).toString();
+});
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Score',
+    'clear': 'Clear Medal',
+};
+
+var HighScore = React.createClass({
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{this.props.score.points}</span>
+                    <span className="label">Combo</span>
+                    <span className="score">{this.props.score.combo < 0 ? '-' : this.props.score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{this.props.score.status}</span>
+                </div>
+                { this.props.score.userid && window.shownames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 4; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}★</span>;
+        }
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            return parseInt(b) - parseInt(a);
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = Math.floor(songids[i] / 10000000);
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 10000000) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[songid] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 10000000) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="subheader">{ this.state.versions[songid] }</td>
+                                            <td className="subheader">Basic</td>
+                                            <td className="subheader">Advanced</td>
+                                            <td className="subheader">Extreme</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <a href={Link.get('individual_score', songid)}>
+                                                    <div className="songname">{ this.state.songs[songid].name }</div>
+                                                    <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                </a>
+                                            <div className="songdifficulties">
+                                                {this.renderDifficulty(songid, 0)}
+                                                <span> / </span>
+                                                {this.renderDifficulty(songid, 1)}
+                                                <span> / </span>
+                                                {this.renderDifficulty(songid, 2)}
+                                            </div>
+                                            </td>
+                                            <td>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByScore: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearMedal: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { al = ac.medal; }
+            if (bc) { bl = bc.medal; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <th className="subheader">Basic</th>
+                        <th className="subheader">Advanced</th>
+                        <th className="subheader">Extreme</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var plays = this.getPlays(records);
+                        var difficulties = this.state.songs[songid].difficulties;
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={4}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByScore();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearMedal();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/jubeat/scores.react.js b/bemani/frontend/static/controllers/jubeat/scores.react.js
new file mode 100644
index 0000000..1e4d291
--- /dev/null
+++ b/bemani/frontend/static/controllers/jubeat/scores.react.js
@@ -0,0 +1,154 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            versions: window.versions,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'Basic';
+            case 1:
+                return 'Advanced';
+            case 2:
+                return 'Extreme';
+            default:
+                return 'u broke it';
+        }
+    },
+
+    renderScore: function(score) {
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{score.points}</span>
+                    <span className="label">Combo</span>
+                    <span className="score">{score.combo < 0 ? '-' : score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{score.status}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.shownames ? <th>Name</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.shownames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            <a href={Link.get('individual_score', attempt.songid, this.convertChart(attempt.chart))}>{
+                                                this.convertChart(attempt.chart)
+                                            }</a>
+                                        </div>
+                                        <div>
+                                            <span>{window.songs[attempt.songid].difficulties[attempt.chart]}★</span>
+                                        </div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={6}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/jubeat/settings.react.js b/bemani/frontend/static/controllers/jubeat/settings.react.js
new file mode 100644
index 0000000..af703dc
--- /dev/null
+++ b/bemani/frontend/static/controllers/jubeat/settings.react.js
@@ -0,0 +1,155 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: window.player[version].name,
+            editing_name: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="8"
+                            size="8"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var value = event.target.value.toUpperCase();
+                                var nameRegex = /^[-&\\.\\*A-Z0-9]*$/;
+                                if (value.length <= 8 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/jubeat/topscores.react.js b/bemani/frontend/static/controllers/jubeat/topscores.react.js
new file mode 100644
index 0000000..d07a245
--- /dev/null
+++ b/bemani/frontend/static/controllers/jubeat/topscores.react.js
@@ -0,0 +1,134 @@
+/*** @jsx React.DOM */
+
+var valid_charts = ['Basic', 'Advanced', 'Extreme'];
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialState: function(props) {
+        return {
+            topscores: this.sortTopScores(window.topscores),
+            players: window.players,
+            chart: pagenav.getInitialState(valid_charts[0]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            this.setState({chart: chart});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'Basic':
+                return 0;
+            case 'Advanced':
+                return 1;
+            case 'Extreme':
+                return 2;
+            default:
+                return null;
+        }
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+
+        return (
+            <div>
+                <div className="section">
+                    <div className="songname">{window.name}</div>
+                    <div className="songartist">{window.artist}</div>
+                    <div className="songdifficulty">{window.difficulties[chart]}★</div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    this.setState({chart: chart});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+                    <Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Status',
+                                render: function(topscore) { return topscore.status; },
+                            },
+                            {
+                                name: 'Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Combo',
+                                render: function(topscore) { return topscore.combo > 0 ? topscore.combo : '-'; },
+                            },
+                        ]}
+                        defaultsort='Score'
+                        rows={this.state.topscores[chart]}
+                        key={chart}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/museca/allplayers.react.js b/bemani/frontend/static/controllers/museca/allplayers.react.js
new file mode 100644
index 0000000..e013619
--- /dev/null
+++ b/bemani/frontend/static/controllers/museca/allplayers.react.js
@@ -0,0 +1,85 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'MÚSECA ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.plays;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.plays - b.plays;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/museca/player.react.js b/bemani/frontend/static/controllers/museca/player.react.js
new file mode 100644
index 0000000..3cb5867
--- /dev/null
+++ b/bemani/frontend/static/controllers/museca/player.react.js
@@ -0,0 +1,115 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Total Plays">
+                            {player.plays}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/museca/records.react.js b/bemani/frontend/static/controllers/museca/records.react.js
new file mode 100644
index 0000000..7ca5d88
--- /dev/null
+++ b/bemani/frontend/static/controllers/museca/records.react.js
@@ -0,0 +1,553 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['green', 'orange', 'red'];
+var chart_names = {
+    'green': 'Green (\u7FE0)',
+    'orange': 'Orange (\u6A59)',
+    'red': 'Red (\u6731)',
+};
+var valid_mixes = Object.keys(window.versions);
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Score',
+    'clear': 'Clear Type',
+};
+
+var HighScore = React.createClass({
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{this.props.score.points}</span>
+                    <span className="status">{this.props.score.grade}</span>
+                </div>
+                <div>
+                    <span className="label">Combo</span>
+                    <span className="score">{this.props.score.combo < 0 ? '-' : this.props.score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{this.props.score.clear_type}</span>
+                </div>
+                { this.props.score.userid && window.shownames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}</span>;
+        }
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 4; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ac = this.state.songs[a].category;
+            var bc = this.state.songs[b].category;
+            return parseInt(bc) - parseInt(ac);
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = parseInt(this.state.songs[songids[i]].category) + 1;
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, -curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 0) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[(-songid) - 1] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 0) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={((-songid) - 1).toString()}>
+                                            <td className="subheader">{ this.state.versions[(-songid) - 1] }</td>
+                                            <td className="subheader">{ 'Green (\u7FE0)' }</td>
+                                            <td className="subheader">{ 'Orange (\u6A59)' }</td>
+                                            <td className="subheader">{ 'Red (\u6731)' }</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <div>
+                                                    <a href={Link.get('individual_score', songid)}>
+                                                        <div className="songname">{ this.state.songs[songid].name }</div>
+                                                        <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                    </a>
+                                                </div>
+                                                <div className="songdifficulties">
+                                                    {this.renderDifficulty(songid, 0)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 1)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 2)}
+                                                </div>
+                                            </td>
+                                            <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByScore: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chart_names[chartname] }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearType: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { al = ac.medal; }
+            if (bc) { bl = bc.medal; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chart_names[chartname] }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <th className="subheader">{ 'Green (\u7FE0)' }</th>
+                        <th className="subheader">{ 'Orange (\u6A59)' }</th>
+                        <th className="subheader">{ 'Red (\u6731)' }</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var plays = this.getPlays(records);
+                        var difficulties = this.state.songs[songid].difficulties;
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={4}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByScore();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearType();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/museca/scores.react.js b/bemani/frontend/static/controllers/museca/scores.react.js
new file mode 100644
index 0000000..23bf02e
--- /dev/null
+++ b/bemani/frontend/static/controllers/museca/scores.react.js
@@ -0,0 +1,169 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'Green (\u7FE0)';
+            case 1:
+                return 'Orange (\u6A59)';
+            case 2:
+                return 'Red (\u6731)';
+            default:
+                return 'u broke it';
+        }
+    },
+
+    convertChartLink: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'green';
+            case 1:
+                return 'orange';
+            case 2:
+                return 'red';
+            default:
+                return 'nothing';
+        }
+    },
+
+    renderScore: function(score) {
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{score.points}</span>
+                    <span className="status">{score.grade}</span>
+                <div>
+                </div>
+                    <span className="label">Combo</span>
+                    <span className="score">{score.combo < 0 ? '-' : score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{score.clear_type}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.shownames ? <th>Name</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.shownames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            <a href={Link.get('individual_score', attempt.songid, this.convertChartLink(attempt.chart))}>{
+                                                this.convertChart(attempt.chart)
+                                            }</a>
+                                        </div>
+                                        <div>{
+                                            this.state.songs[attempt.songid].difficulties[attempt.chart]
+                                        }</div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={5}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/museca/settings.react.js b/bemani/frontend/static/controllers/museca/settings.react.js
new file mode 100644
index 0000000..9fadefc
--- /dev/null
+++ b/bemani/frontend/static/controllers/museca/settings.react.js
@@ -0,0 +1,161 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: window.player[version].name,
+            editing_name: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="8"
+                            size="16"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var value = event.target.value.toUpperCase();
+                                var nameRegex = new RegExp(
+                                    "^[" +
+                                    "0-9" +
+                                    "A-Z" +
+                                    "!?#$&*-. " +
+                                    "]*$"
+                                );
+                                if (value.length <= 8 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/museca/topscores.react.js b/bemani/frontend/static/controllers/museca/topscores.react.js
new file mode 100644
index 0000000..d25881c
--- /dev/null
+++ b/bemani/frontend/static/controllers/museca/topscores.react.js
@@ -0,0 +1,145 @@
+/*** @jsx React.DOM */
+
+var valid_charts = ['green', 'orange', 'red'].filter(function(val, index) {
+    return window.difficulties[index] > 0;
+});
+var chart_names = {
+    'green': 'Green (\u7FE0)',
+    'orange': 'Orange (\u6A59)',
+    'red': 'Red (\u6731)',
+};
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialState: function(props) {
+        return {
+            topscores: this.sortTopScores(window.topscores),
+            players: window.players,
+            chart: pagenav.getInitialState(valid_charts[0]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            this.setState({chart: chart});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'green':
+                return 0;
+            case 'orange':
+                return 1;
+            case 'red':
+                return 2;
+            default:
+                return null;
+        }
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+
+        return (
+            <div>
+                <div className="section">
+                    <div className="songname">{window.name}</div>
+                    <div className="songartist">{window.artist}</div>
+                    <div className="songdifficulty">{window.difficulties[chart]}</div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart_names[chart]}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    this.setState({chart: chart});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+               		<Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Grade',
+                                render: function(topscore) { return topscore.grade; },
+                            },
+                            {
+                                name: 'Clear Type',
+                                render: function(topscore) { return topscore.clear_type; },
+                            },
+                            {
+                                name: 'Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Combo',
+                                render: function(topscore) { return topscore.combo > 0 ? topscore.combo : '-'; },
+                            },
+                        ]}
+                        defaultsort='Score'
+                        rows={this.state.topscores[chart]}
+                        key={chart}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/popn/allplayers.react.js b/bemani/frontend/static/controllers/popn/allplayers.react.js
new file mode 100644
index 0000000..6af4527
--- /dev/null
+++ b/bemani/frontend/static/controllers/popn/allplayers.react.js
@@ -0,0 +1,85 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Pop\'n Music ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.plays;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.plays - b.plays;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/popn/player.react.js b/bemani/frontend/static/controllers/popn/player.react.js
new file mode 100644
index 0000000..3cb5867
--- /dev/null
+++ b/bemani/frontend/static/controllers/popn/player.react.js
@@ -0,0 +1,115 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Total Plays">
+                            {player.plays}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/popn/records.react.js b/bemani/frontend/static/controllers/popn/records.react.js
new file mode 100644
index 0000000..2647fdb
--- /dev/null
+++ b/bemani/frontend/static/controllers/popn/records.react.js
@@ -0,0 +1,569 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['Easy', 'Normal', 'Hyper', 'EX'];
+var valid_mixes = Object.keys(window.versions);
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Score',
+    'clear': 'Clear Medal',
+};
+
+var HighScore = React.createClass({
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{this.props.score.points}</span>
+                    <span className="label">Combo</span>
+                    <span className="score">{this.props.score.combo < 0 ? '-' : this.props.score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{this.props.score.status}</span>
+                </div>
+                { this.props.score.userid && window.shownames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}</span>;
+        }
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 4; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ac = this.state.songs[a].category;
+            var bc = this.state.songs[b].category;
+            return parseInt(bc) - parseInt(ac);
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = parseInt(this.state.songs[songids[i]].category) + 1;
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, -curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 0) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[(-songid) - 1] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 0) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={((-songid) - 1).toString()}>
+                                            <td className="subheader">{ this.state.versions[(-songid) - 1] }</td>
+                                            <td className="subheader">Easy</td>
+                                            <td className="subheader">Normal</td>
+                                            <td className="subheader">Hyper</td>
+                                            <td className="subheader">EX</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <div>
+                                                    <a href={Link.get('individual_score', songid)}>
+                                                        <div className="songname">{ this.state.songs[songid].name }</div>
+                                                        <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                        <div className="songgenre">{ this.state.songs[songid].genre }</div>
+                                                    </a>
+                                                </div>
+                                                <div className="songdifficulties">
+                                                    {this.renderDifficulty(songid, 0)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 1)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 2)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 3)}
+                                                </div>
+                                            </td>
+                                            <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={3}
+                                                    score={records[3]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByScore: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearMedal: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { al = ac.medal; }
+            if (bc) { bl = bc.medal; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <td className="subheader">Easy</td>
+                        <td className="subheader">Normal</td>
+                        <td className="subheader">Hyper</td>
+                        <td className="subheader">EX</td>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var plays = this.getPlays(records);
+                        var difficulties = this.state.songs[songid].difficulties;
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                            <div className="songgenre">{ this.state.songs[songid].genre }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 3)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                                <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={3}
+                                        score={records[3]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={5}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByScore();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearMedal();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/popn/scores.react.js b/bemani/frontend/static/controllers/popn/scores.react.js
new file mode 100644
index 0000000..d5442e6
--- /dev/null
+++ b/bemani/frontend/static/controllers/popn/scores.react.js
@@ -0,0 +1,156 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'Easy';
+            case 1:
+                return 'Normal';
+            case 2:
+                return 'Hyper';
+            case 3:
+                return 'EX';
+            default:
+                return 'u broke it';
+        }
+    },
+
+    renderScore: function(score) {
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{score.points}</span>
+                    <span className="label">Combo</span>
+                    <span className="score">{score.combo < 0 ? '-' : score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{score.status}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.shownames ? <th>Name</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.shownames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                            <div className="songgenre">{ this.state.songs[attempt.songid].genre }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            <a href={Link.get('individual_score', attempt.songid, this.convertChart(attempt.chart))}>{
+                                                this.convertChart(attempt.chart)
+                                            }</a>
+                                        </div>
+                                        <div>{
+                                            this.state.songs[attempt.songid].difficulties[attempt.chart]
+                                        }</div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={5}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/popn/settings.react.js b/bemani/frontend/static/controllers/popn/settings.react.js
new file mode 100644
index 0000000..d5f0ac1
--- /dev/null
+++ b/bemani/frontend/static/controllers/popn/settings.react.js
@@ -0,0 +1,185 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: window.player[version].name,
+            editing_name: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="6"
+                            size="12"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var rawvalue = event.target.value;
+                                var value = "";
+                                // Nasty conversion to change typing into wide text
+                                for (var i = 0; i < rawvalue.length; i++) {
+                                    var c = rawvalue.charCodeAt(i);
+                                    if (c >= '0'.charCodeAt(0) && c <= '9'.charCodeAt(0)) {
+                                        c = 0xFF10 + (c - '0'.charCodeAt(0));
+                                    } else if(c >= 'A'.charCodeAt(0) && c <= 'Z'.charCodeAt(0)) {
+                                        c = 0xFF21 + (c - 'A'.charCodeAt(0));
+                                    } else if(c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
+                                        c = 0xFF41 + (c - 'a'.charCodeAt(0));
+                                    } else if(c == '@'.charCodeAt(0)) {
+                                        c = 0xFF20;
+                                    } else if(c == ','.charCodeAt(0)) {
+                                        c = 0xFF0C;
+                                    } else if(c == '.'.charCodeAt(0)) {
+                                        c = 0xFF0E;
+                                    } else if(c == '_'.charCodeAt(0)) {
+                                       c = 0xFF3F;
+                                    }
+                                    value = value + String.fromCharCode(c);
+                                }
+                                var nameRegex = new RegExp(
+                                    "^[" +
+                                    "\uFF20-\uFF3A" + // widetext A-Z and @
+                                    "\uFF41-\uFF5A" + // widetext a-z
+                                    "\uFF10-\uFF19" + // widetext 0-9
+                                    "\uFF0C\uFF0E\uFF3F" + // widetext ,._
+                                    "\u3041-\u308D\u308F\u3092\u3093" + // hiragana
+                                    "\u30A1-\u30ED\u30EF\u30F2\u30F3\u30FC" + // katakana
+                                    "]*$"
+                                );
+                                if (value.length <= 6 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/popn/topscores.react.js b/bemani/frontend/static/controllers/popn/topscores.react.js
new file mode 100644
index 0000000..6568aa6
--- /dev/null
+++ b/bemani/frontend/static/controllers/popn/topscores.react.js
@@ -0,0 +1,139 @@
+/*** @jsx React.DOM */
+
+var valid_charts = ['Easy', 'Normal', 'Hyper', 'EX'].filter(function(val, index) {
+    return window.difficulties[index] > 0;
+});
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialState: function(props) {
+        return {
+            topscores: this.sortTopScores(window.topscores),
+            players: window.players,
+            chart: pagenav.getInitialState(valid_charts[0]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            this.setState({chart: chart});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'Easy':
+                return 0;
+            case 'Normal':
+                return 1;
+            case 'Hyper':
+                return 2;
+            case 'EX':
+                return 3;
+            default:
+                return null;
+        }
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+
+        return (
+            <div>
+                <div className="section">
+                    <div className="songname">{window.name}</div>
+                    <div className="songartist">{window.artist}</div>
+                    <div className="songgenre">{window.genre}</div>
+                    <div className="songdifficulty">{window.difficulties[chart]}</div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    this.setState({chart: chart});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+               		<Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Status',
+                                render: function(topscore) { return topscore.status; },
+                            },
+                            {
+                                name: 'Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Combo',
+                                render: function(topscore) { return topscore.combo > 0 ? topscore.combo : '-'; },
+                            },
+                        ]}
+                        defaultsort='Score'
+                        rows={this.state.topscores[chart]}
+                        key={chart}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/allplayers.react.js b/bemani/frontend/static/controllers/reflec/allplayers.react.js
new file mode 100644
index 0000000..f84bbcf
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/allplayers.react.js
@@ -0,0 +1,85 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Reflec Beat ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.plays;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.plays - b.plays;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/player.react.js b/bemani/frontend/static/controllers/reflec/player.react.js
new file mode 100644
index 0000000..3cb5867
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/player.react.js
@@ -0,0 +1,115 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Total Plays">
+                            {player.plays}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/records.react.js b/bemani/frontend/static/controllers/reflec/records.react.js
new file mode 100644
index 0000000..cba385d
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/records.react.js
@@ -0,0 +1,652 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['Basic', 'Medium', 'Hard', 'Special'];
+var valid_mixes = Object.keys(window.versions);
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('achievement');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Score',
+    'achievement': 'Achievement Rate',
+    'clear': 'Clear Type',
+};
+
+var HighScore = React.createClass({
+
+    renderGrade: function(score) {
+        if (score.achievement_rate < 6000) {
+            return <span>C</span>;
+        }
+        if (score.achievement_rate < 7000) {
+            return <span>B</span>;
+        }
+        if (score.achievement_rate < 8000) {
+            return <span>A</span>;
+        }
+        if (score.achievement_rate < 9000) {
+            return <span>AA</span>;
+        }
+        if (score.achievement_rate < 9500) {
+            return <span>AAA</span>;
+        }
+
+        return <span>AAA+</span>;
+    },
+
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="grade">{this.renderGrade(this.props.score)}</span>
+                    <span className="percent">{this.props.score.achievement_rate/100}%</span>
+                </div>
+                <div>
+                    <span className="label">S</span>
+                    <span className="score">{this.props.score.points}</span>
+                    <span className="label">M</span>
+                    <span className="score">{this.props.score.miss_count < 0 ? '-' : this.props.score.miss_count}</span>
+                </div>
+                <div>
+                    <span className="label">Combo</span>
+                    <span className="score">{this.props.score.combo < 0 ? '-' : this.props.score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{this.props.score.combo_type}</span>
+                    <span className="status"> </span>
+                    <span className="status">{this.props.score.clear_type}</span>
+                </div>
+                { this.props.score.userid && window.shownames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}</span>;
+        }
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 4; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ac = this.state.songs[a].category;
+            var bc = this.state.songs[b].category;
+            return parseInt(bc) - parseInt(ac);
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = parseInt(this.state.songs[songids[i]].category) + 1;
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, -curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 0) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[(-songid) - 1] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 0) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={((-songid) - 1).toString()}>
+                                            <td className="subheader">{ this.state.versions[(-songid) - 1] }</td>
+                                            <td className="subheader">Basic</td>
+                                            <td className="subheader">Medium</td>
+                                            <td className="subheader">Hard</td>
+                                            <td className="subheader">Special</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <div>
+                                                    <a href={Link.get('individual_score', songid)}>
+                                                        <div className="songname">{ this.state.songs[songid].name }</div>
+                                                        <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                    </a>
+                                                </div>
+                                                <div className="songdifficulties">
+                                                    {this.renderDifficulty(songid, 0)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 1)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 2)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 3)}
+                                                </div>
+                                            </td>
+                                            <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={3}
+                                                    score={records[3]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByScore: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByAchievementRate: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { as = ac.achievement_rate; }
+            if (bc) { bs = bc.achievement_rate; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearType: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { al = ac.medal; }
+            if (bc) { bl = bc.medal; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <th className="subheader">Basic</th>
+                        <th className="subheader">Medium</th>
+                        <th className="subheader">Hard</th>
+                        <th className="subheader">Special</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var plays = this.getPlays(records);
+                        var difficulties = this.state.songs[songid].difficulties;
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 3)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                                <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={3}
+                                        score={records[3]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={6}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByScore();
+        } else if (this.state.sort == 'achievement') {
+            data = this.renderByAchievementRate();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearType();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/rivals.react.js b/bemani/frontend/static/controllers/reflec/rivals.react.js
new file mode 100644
index 0000000..d21c0ea
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/rivals.react.js
@@ -0,0 +1,421 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.rivals);
+var pagenav = new History(valid_versions);
+
+var rivals_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.rivals);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            rivals: window.rivals,
+            players: window.players,
+            profiles: profiles,
+            version: version,
+            term_id: "",
+            term_name: "",
+            results: {},
+            searching_id: false,
+            searching_name: false,
+            offset: 0,
+            limit: 5,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version, offset: 0});
+        }.bind(this));
+        this.refreshRivals();
+    },
+
+    refreshRivals: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+				setTimeout(this.refreshRivals, 5000);
+            }.bind(this)
+        );
+    },
+
+    searchForPlayersID: function(event) {
+        this.setState({searching_id: true});
+        AJAX.post(
+            Link.get('search'),
+            {
+                version: this.state.version,
+                term: this.state.term_id,
+            },
+            function(response) {
+                this.setState({
+                    results: response.results,
+                    searching_id: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    searchForPlayersName: function(event) {
+        this.setState({searching_name: true});
+        AJAX.post(
+            Link.get('search'),
+            {
+                version: this.state.version,
+                term: this.state.term_name,
+            },
+            function(response) {
+                this.setState({
+                    results: response.results,
+                    searching_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRival: function(event, userid) {
+        AJAX.post(
+            Link.get('addrival'),
+            {
+                version: this.state.version,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    removeRival: function(event, userid) {
+        AJAX.post(
+            Link.get('removerival'),
+            {
+                version: this.state.version,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRivals: function(userid) {
+        if (userid == window.userid) {
+            return null;
+        }
+
+        var avail = true;
+        var count = 0;
+        var current_rivals = this.state.rivals[this.state.version];
+        for (var i = 0; i < current_rivals.length; i++) {
+            count++;
+            if (current_rivals[i].userid == userid) {
+                avail = false;
+            }
+        }
+
+        if (count >= 30) { avail = false; }
+
+        return (
+            <span>
+                {avail ?
+                    <Add
+                        title="Add Rival"
+                        onClick={function(event) {
+                            this.addRival(event, userid);
+                        }.bind(this)}
+                    /> :
+                    null
+                }
+            </span>
+        );
+    },
+
+    render: function() {
+        if (this.state.rivals[this.state.version]) {
+            var rivals = this.state.rivals[this.state.version];
+            var resultlength = 0;
+            Object.keys(this.state.results).map(function(userid, index) {
+                var player = this.state.results[userid][this.state.version];
+                if (player) { resultlength++; }
+            }.bind(this));
+            return (
+                <div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            offset: 0,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <form onSubmit={this.searchForPlayersName}>
+                            <label for="search">Name:</label>
+                            <br />
+                            <input
+                                type="text"
+                                className="inline"
+                                maxlength="8"
+                                value={this.state.term_name}
+                                onChange={function(event) {
+                                    var rawvalue = event.target.value;
+                                    if (this.state.version <= 3) {
+                                        // Only allow uppercase, so convert to be helpful
+                                        rawvalue = rawvalue.toUpperCase();
+                                    }
+                                    var value = "";
+                                    // Nasty conversion to change typing into wide text
+                                    for (var i = 0; i < rawvalue.length; i++) {
+                                        var c = rawvalue.charCodeAt(i);
+                                        if (c >= '0'.charCodeAt(0) && c <= '9'.charCodeAt(0)) {
+                                            c = 0xFF10 + (c - '0'.charCodeAt(0));
+                                        } else if(c >= 'A'.charCodeAt(0) && c <= 'Z'.charCodeAt(0)) {
+                                            c = 0xFF21 + (c - 'A'.charCodeAt(0));
+                                        } else if(c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
+                                            c = 0xFF41 + (c - 'a'.charCodeAt(0));
+                                        } else if(c == '.'.charCodeAt(0)) {
+                                            c = 0xFF0E;
+                                        } else if(c == '-'.charCodeAt(0)) {
+                                            c = 0x2212;
+                                        } else if(c == '_'.charCodeAt(0)) {
+                                            c = 0xFF3F;
+                                        } else if(c == '&'.charCodeAt(0)) {
+                                            c = 0xFF06;
+                                        } else if(c == '!'.charCodeAt(0)) {
+                                            c = 0xFF01;
+                                        } else if(c == '?'.charCodeAt(0)) {
+                                            c = 0xFF1F;
+                                        } else if(c == '/'.charCodeAt(0)) {
+                                            c = 0xFF0F;
+                                        } else if(c == '*'.charCodeAt(0)) {
+                                            c = 0xFF0A;
+                                        } else if(c == '#'.charCodeAt(0)) {
+                                            c = 0xFF03;
+                                        } else if(c == '@'.charCodeAt(0)) {
+                                            c = 0xFF20;
+                                        } else if(c == '('.charCodeAt(0)) {
+                                            c = 0xFF08;
+                                        } else if(c == ')'.charCodeAt(0)) {
+                                            c = 0xFF09;
+                                        } else if(c == '^'.charCodeAt(0)) {
+                                            c = 0xFF3E;
+                                        } else if(c == '%'.charCodeAt(0)) {
+                                            c = 0xFF05;
+                                        } else if(c == ' '.charCodeAt(0)) {
+                                            c = 0x3000;
+                                        }
+                                        value = value + String.fromCharCode(c);
+                                    }
+                                    var nameRegex;
+                                    if (this.state.version <= 3) {
+                                        nameRegex = new RegExp(
+                                            "^[" +
+                                            "\uFF21-\uFF3A" +
+                                            "\uFF10-\uFF19" +
+                                            "\uFF0E\u2212\uFF3F\u30FB" +
+                                            "\uFF06\uFF01\uFF1F\uFF0F" +
+                                            "\uFF0A\uFF03\u266D\u2605" +
+                                            "\uFF20\u266A\u2193\u2191" +
+                                            "\u2192\u2190\uFF08\uFF09" +
+                                            "\u221E\u25C6\u25CF\u25BC" +
+                                            "\uFFE5\uFF3E\u2200\uFF05" +
+                                            "\u3000" +
+                                            "]*$"
+                                        );
+                                    } else {
+                                        nameRegex = new RegExp(
+                                            "^[" +
+                                            "\uFF21-\uFF3A" +
+                                            "\uFF41-\uFF5A" +
+                                            "\uFF10-\uFF19" +
+                                            "\uFF0E\u2212\uFF3F\u30FB" +
+                                            "\uFF06\uFF01\uFF1F\uFF0F" +
+                                            "\uFF0A\uFF03\u266D\u2605" +
+                                            "\uFF20\u266A\u2193\u2191" +
+                                            "\u2192\u2190\uFF08\uFF09" +
+                                            "\u221E\u25C6\u25CF\u25BC" +
+                                            "\uFFE5\uFF3E\u2200\uFF05" +
+                                            "\u3000" +
+                                            "]*$"
+                                        );
+                                    }
+                                    if (value.length <= 8 && nameRegex.test(value)) {
+                                        this.setState({term_name: value});
+                                    }
+                                }.bind(this)}
+                                name="search"
+                            />
+                            <input type="submit" value="search" />
+                            { this.state.searching_name ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </form>
+                        <form onSubmit={this.searchForPlayersID}>
+                            <label for="search">Reflec Beat ID:</label>
+                            <br />
+                            <input
+                                type="text"
+                                className="inline"
+                                maxlength="9"
+                                value={this.state.term_id}
+                                onChange={function(event) {
+                                    var value = event.target.value.toUpperCase();
+                                    var intRegex = new RegExp(
+                                        "^[" +
+                                        "0-9" +
+                                        "-" +
+                                        "]*$"
+                                    );
+                                    if (value.length <= 9 && intRegex.test(value)) {
+                                        this.setState({term_id: value});
+                                    }
+                                }.bind(this)}
+                                name="search"
+                            />
+                            <input type="submit" value="search" />
+                            { this.state.searching_id ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </form>
+                        {resultlength > 0 ?
+                            <table className="list players">
+                                <thead>
+                                    <tr>
+                                        <th>Name</th>
+                                        <th>Reflec Beat ID</th>
+                                        <th className="action"></th>
+                                    </tr>
+                                </thead>
+                                <tbody>{
+                                    Object.keys(this.state.results).map(function(userid, index) {
+                                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                            return null;
+                                        }
+                                        var player = this.state.results[userid][this.state.version];
+                                        if (!player) { return null; }
+
+                                        return (
+                                            <tr>
+                                                <td><Rival userid={userid} player={player} /></td>
+                                                <td>{ player.extid }</td>
+                                                <td className="edit">{this.addRivals(userid)}</td>
+                                            </tr>
+                                        );
+                                    }.bind(this))
+                                }</tbody>
+                                <tfoot>
+                                    <tr>
+                                        <td colSpan={2}>
+                                            { this.state.offset > 0 ?
+                                                <Prev onClick={function(event) {
+                                                     var page = this.state.offset - this.state.limit;
+                                                     if (page < 0) { page = 0; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                            { (this.state.offset + this.state.limit) < resultlength ?
+                                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                                     var page = this.state.offset + this.state.limit;
+                                                     if (page >= resultlength) { return; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                        </td>
+                                    </tr>
+                                </tfoot>
+                            </table> :
+                            <div className="placeholder">No players match the specified search.</div>
+                        }
+                    </div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        <table className="list players">
+                            <thead>
+                                <tr>
+                                    <th>Name</th>
+                                    <th>Reflec Beat ID</th>
+                                    <th className="action"></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {this.state.rivals[this.state.version].map(function(rival, index) {
+                                    var player = this.state.players[rival.userid][this.state.version];
+                                    return (
+                                        <tr>
+                                            <td><Rival userid={rival.userid} player={player} /></td>
+                                            <td>{ player.extid }</td>
+                                            <td className="edit">
+                                                <Delete
+                                                    title="Remove Rival"
+                                                    onClick={function(event) {
+                                                        this.removeRival(event, rival.userid);
+                                                    }.bind(this)}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }.bind(this))}
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version, offset: 0});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(rivals_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/scores.react.js b/bemani/frontend/static/controllers/reflec/scores.react.js
new file mode 100644
index 0000000..0300a9e
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/scores.react.js
@@ -0,0 +1,183 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'Basic';
+            case 1:
+                return 'Medium';
+            case 2:
+                return 'Hard';
+            default:
+                return 'Special';
+        }
+    },
+
+    renderGrade: function(score) {
+        if (score.achievement_rate < 6000) {
+            return <span>C</span>;
+        }
+        if (score.achievement_rate < 7000) {
+            return <span>B</span>;
+        }
+        if (score.achievement_rate < 8000) {
+            return <span>A</span>;
+        }
+        if (score.achievement_rate < 9000) {
+            return <span>AA</span>;
+        }
+        if (score.achievement_rate < 9500) {
+            return <span>AAA</span>;
+        }
+
+        return <span>AAA+</span>;
+    },
+
+    renderScore: function(score) {
+        return (
+            <div className="score">
+                <div>
+                    <span className="grade">{this.renderGrade(score)}</span>
+                    <span className="percent">{score.achievement_rate/100}%</span>
+                </div>
+                <div>
+                    <span className="label">S</span>
+                    <span className="score">{score.points}</span>
+                    <span className="label">M</span>
+                    <span className="score">{score.miss_count < 0 ? '-' : score.miss_count}</span>
+                </div>
+                <div>
+                    <span className="label">Combo</span>
+                    <span className="score">{score.combo < 0 ? '-' : score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{score.combo_type}</span>
+                    <span className="status"> </span>
+                    <span className="status">{score.clear_type}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.shownames ? <th>Name</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.shownames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            <a href={Link.get('individual_score', attempt.songid, this.convertChart(attempt.chart))}>{
+                                                this.convertChart(attempt.chart)
+                                            }</a>
+                                        </div>
+                                        <div>{
+                                            this.state.songs[attempt.songid].difficulties[attempt.chart]
+                                        }</div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={5}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/settings.react.js b/bemani/frontend/static/controllers/reflec/settings.react.js
new file mode 100644
index 0000000..6862b8b
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/settings.react.js
@@ -0,0 +1,234 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: window.player[version].name,
+            editing_name: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="8"
+                            size="16"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var rawvalue = event.target.value;
+                                if (this.state.version <= 3) {
+                                    // Only allow uppercase, so convert to be helpful
+                                    rawvalue = rawvalue.toUpperCase();
+                                }
+                                var value = "";
+                                // Nasty conversion to change typing into wide text
+                                for (var i = 0; i < rawvalue.length; i++) {
+                                    var c = rawvalue.charCodeAt(i);
+                                    if (c >= '0'.charCodeAt(0) && c <= '9'.charCodeAt(0)) {
+                                        c = 0xFF10 + (c - '0'.charCodeAt(0));
+                                    } else if(c >= 'A'.charCodeAt(0) && c <= 'Z'.charCodeAt(0)) {
+                                        c = 0xFF21 + (c - 'A'.charCodeAt(0));
+                                    } else if(c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
+                                        c = 0xFF41 + (c - 'a'.charCodeAt(0));
+                                    } else if(c == '.'.charCodeAt(0)) {
+                                        c = 0xFF0E;
+                                    } else if(c == '-'.charCodeAt(0)) {
+                                        c = 0x2212;
+                                    } else if(c == '_'.charCodeAt(0)) {
+                                        c = 0xFF3F;
+                                    } else if(c == '&'.charCodeAt(0)) {
+                                        c = 0xFF06;
+                                    } else if(c == '!'.charCodeAt(0)) {
+                                        c = 0xFF01;
+                                    } else if(c == '?'.charCodeAt(0)) {
+                                        c = 0xFF1F;
+                                    } else if(c == '/'.charCodeAt(0)) {
+                                        c = 0xFF0F;
+                                    } else if(c == '*'.charCodeAt(0)) {
+                                        c = 0xFF0A;
+                                    } else if(c == '#'.charCodeAt(0)) {
+                                        c = 0xFF03;
+                                    } else if(c == '@'.charCodeAt(0)) {
+                                        c = 0xFF20;
+                                    } else if(c == '('.charCodeAt(0)) {
+                                        c = 0xFF08;
+                                    } else if(c == ')'.charCodeAt(0)) {
+                                        c = 0xFF09;
+                                    } else if(c == '^'.charCodeAt(0)) {
+                                        c = 0xFF3E;
+                                    } else if(c == '%'.charCodeAt(0)) {
+                                        c = 0xFF05;
+                                    } else if(c == ' '.charCodeAt(0)) {
+                                        c = 0x3000;
+                                    }
+                                    value = value + String.fromCharCode(c);
+                                }
+                                var nameRegex;
+                                if (this.state.version <= 3) {
+                                    nameRegex = new RegExp(
+                                        "^[" +
+                                        "\uFF21-\uFF3A" +
+                                        "\uFF10-\uFF19" +
+                                        "\uFF0E\u2212\uFF3F\u30FB" +
+                                        "\uFF06\uFF01\uFF1F\uFF0F" +
+                                        "\uFF0A\uFF03\u266D\u2605" +
+                                        "\uFF20\u266A\u2193\u2191" +
+                                        "\u2192\u2190\uFF08\uFF09" +
+                                        "\u221E\u25C6\u25CF\u25BC" +
+                                        "\uFFE5\uFF3E\u2200\uFF05" +
+                                        "\u3000" +
+                                        "]*$"
+                                    );
+                                } else {
+                                    nameRegex = new RegExp(
+                                        "^[" +
+                                        "\uFF21-\uFF3A" +
+                                        "\uFF41-\uFF5A" +
+                                        "\uFF10-\uFF19" +
+                                        "\uFF0E\u2212\uFF3F\u30FB" +
+                                        "\uFF06\uFF01\uFF1F\uFF0F" +
+                                        "\uFF0A\uFF03\u266D\u2605" +
+                                        "\uFF20\u266A\u2193\u2191" +
+                                        "\u2192\u2190\uFF08\uFF09" +
+                                        "\u221E\u25C6\u25CF\u25BC" +
+                                        "\uFFE5\uFF3E\u2200\uFF05" +
+                                        "\u3000" +
+                                        "]*$"
+                                    );
+                                }
+                                if (value.length <= 8 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/reflec/topscores.react.js b/bemani/frontend/static/controllers/reflec/topscores.react.js
new file mode 100644
index 0000000..d6b35a6
--- /dev/null
+++ b/bemani/frontend/static/controllers/reflec/topscores.react.js
@@ -0,0 +1,176 @@
+/*** @jsx React.DOM */
+
+var valid_charts = ['Basic', 'Medium', 'Hard', 'Special'].filter(function(val, index) {
+    return window.difficulties[index] > 0;
+});
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialState: function(props) {
+        return {
+            topscores: this.sortTopScores(window.topscores),
+            players: window.players,
+            chart: pagenav.getInitialState(valid_charts[0]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            this.setState({chart: chart});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'Basic':
+                return 0;
+            case 'Medium':
+                return 1;
+            case 'Hard':
+                return 2;
+            case 'Special':
+                return 3;
+            default:
+                return null;
+        }
+    },
+
+    renderGrade: function(score) {
+        if (score.achievement_rate < 6000) {
+            return <span>C</span>;
+        }
+        if (score.achievement_rate < 7000) {
+            return <span>B</span>;
+        }
+        if (score.achievement_rate < 8000) {
+            return <span>A</span>;
+        }
+        if (score.achievement_rate < 9000) {
+            return <span>AA</span>;
+        }
+        if (score.achievement_rate < 9500) {
+            return <span>AAA</span>;
+        }
+
+        return <span>AAA+</span>;
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+
+        return (
+            <div>
+                <div className="section">
+                    <div className="songname">{window.name}</div>
+                    <div className="songartist">{window.artist}</div>
+                    <div className="songdifficulty">{window.difficulties[chart]}</div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    this.setState({chart: chart});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+               		<Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Achievement Rate',
+                                render: function(topscore) {
+                                    return (
+                                        <div className="score">
+                                            <span className="grade">{this.renderGrade(topscore)}</span>
+                                            <span className="percent">{topscore.achievement_rate/100}%</span>
+                                        </div>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    return a.achievement_rate - b.achievement_rate;
+                                },
+                            },
+                            {
+                                name: 'Clear Type',
+                                render: function(topscore) { return topscore.combo_type + ' ' + topscore.clear_type; },
+                            },
+                            {
+                                name: 'Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Combo',
+                                render: function(topscore) { return topscore.combo > 0 ? topscore.combo : '-'; },
+                            },
+                            {
+                                name: 'Miss Count',
+                                render: function(topscore) { return topscore.miss_count > 0 ? topscore.miss_count : '-'; },
+                            },
+                        ]}
+                        defaultsort='Score'
+                        rows={this.state.topscores[chart]}
+                        key={chart}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/allplayers.react.js b/bemani/frontend/static/controllers/sdvx/allplayers.react.js
new file mode 100644
index 0000000..0af5d3c
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/allplayers.react.js
@@ -0,0 +1,85 @@
+/*** @jsx React.DOM */
+
+var all_players = React.createClass({
+
+    getInitialState: function(props) {
+        return {
+            players: window.players,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshPlayers();
+    },
+
+    refreshPlayers: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    players: response.players,
+                });
+                // Refresh every 30 seconds
+                setTimeout(this.refreshPlayers, 30000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <div className="section">
+                    <Table
+                        className="list players"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return <a href={Link.get('player', userid)}>{ player.name }</a>;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.name.localeCompare(b.name);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'SDVX ID',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.extid;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.extid.localeCompare(b.extid);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Play Count',
+                                render: function(userid) {
+                                    var player = this.state.players[userid];
+                                    return player.plays;
+                                }.bind(this),
+                                sort: function(aid, bid) {
+                                    var a = this.state.players[aid];
+                                    var b = this.state.players[bid];
+                                    return a.plays - b.plays;
+                                }.bind(this),
+                                reverse: true,
+                            },
+                        ]}
+                        rows={Object.keys(this.state.players)}
+                        paginate={10}
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(all_players, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/player.react.js b/bemani/frontend/static/controllers/sdvx/player.react.js
new file mode 100644
index 0000000..3cb5867
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/player.react.js
@@ -0,0 +1,115 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var profile_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: pagenav.getInitialState(profiles[profiles.length - 1]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+        this.refreshProfile();
+    },
+
+    refreshProfile: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                var profiles = Object.keys(response.player);
+
+                this.setState({
+                    player: response.player,
+                    profiles: profiles,
+                });
+                setTimeout(this.refreshProfile, 5000);
+            }.bind(this)
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        <h3>{player.name}'s profile</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <LabelledSection label="User ID">{player.extid}</LabelledSection>
+                        <LabelledSection label="Register Time">
+                            <Timestamp timestamp={player.first_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Last Play Time">
+                            <Timestamp timestamp={player.last_play_time}/>
+                        </LabelledSection>
+                        <LabelledSection label="Total Plays">
+                            {player.plays}回
+                        </LabelledSection>
+                    </div>
+                    <div className="section">
+                        <a href={Link.get('records')}>{ window.own_profile ?
+                            <span>view your records</span> :
+                            <span>view {player.name}'s records</span>
+                        }</a>
+                        <span className="separator">&middot;</span>
+                        <a href={Link.get('scores')}>{ window.own_profile ?
+                            <span>view all your scores</span> :
+                            <span>view all {player.name}'s scores</span>
+                        }</a>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        This player has no profile for {window.versions[this.state.version]}!
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(profile_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/records.react.js b/bemani/frontend/static/controllers/sdvx/records.react.js
new file mode 100644
index 0000000..2b01975
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/records.react.js
@@ -0,0 +1,592 @@
+/*** @jsx React.DOM */
+
+var valid_sorts = ['series', 'name', 'popularity'];
+var valid_charts = ['Novice', 'Advanced', 'Exhaust', 'Infinite', 'Maximum'];
+var valid_mixes = Object.keys(window.versions);
+var valid_subsorts = [valid_mixes, false, false, valid_charts, valid_charts];
+if (window.showpersonalsort) {
+    valid_sorts.push('grade');
+    valid_sorts.push('clear');
+}
+var pagenav = new History(valid_sorts, valid_subsorts);
+var sort_names = {
+    'series': 'Series',
+    'name': 'Song Name',
+    'popularity': 'Popularity',
+    'grade': 'Score',
+    'clear': 'Clear Type',
+};
+
+var HighScore = React.createClass({
+    render: function() {
+        if (!this.props.score) {
+            return null;
+        }
+
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{this.props.score.points}</span>
+                    <span className="status">{this.props.score.grade}</span>
+                </div>
+                <div>
+                    <span className="label">Combo</span>
+                    <span className="score">{this.props.score.combo < 0 ? '-' : this.props.score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{this.props.score.clear_type}</span>
+                </div>
+                { this.props.score.userid && window.shownames ?
+                    <div><a href={Link.get('player', this.props.score.userid)}>{
+                        this.props.players[this.props.score.userid].name
+                    }</a></div> : null
+                }
+            </div>
+        );
+    },
+});
+
+var network_records = React.createClass({
+
+    sortRecords: function(records) {
+        var sorted_records = {};
+
+        records.forEach(function(record) {
+            if (!(record.songid in sorted_records)) {
+                sorted_records[record.songid] = {}
+            }
+            sorted_records[record.songid][record.chart] = record;
+        });
+
+        return sorted_records;
+    },
+
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            records: this.sortRecords(window.records),
+            players: window.players,
+            versions: window.versions,
+            sort: pagenav.getInitialState('series', '0'),
+            subtab: this.getSubIndex('series', pagenav.getInitialSubState('series', '0')),
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    getSubIndex: function(sort, subsort) {
+        var subtab = 0;
+        window.valid_sorts.forEach(function(potential, index) {
+            if (window.valid_subsorts[index]) {
+                window.valid_subsorts[index].forEach(function(subpotential, subindex) {
+                    if (subpotential == subsort) {
+                        subtab = subindex;
+                    }
+                }.bind(this));
+            }
+        }.bind(this));
+        return subtab;
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(sort, subsort) {
+            var subtab = this.getSubIndex(sort, subsort);
+            this.setState({sort: sort, offset: 0, subtab: subtab});
+        }.bind(this));
+        this.refreshRecords();
+    },
+
+    refreshRecords: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    records: this.sortRecords(response.records),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshRecords, 15000);
+            }.bind(this)
+        );
+    },
+
+    renderDifficulty: function(songid, chart) {
+        if (this.state.songs[songid].difficulties[chart] == 0) {
+            return <span className="difficulty">--</span>;
+        } else {
+            return <span className="difficulty">{this.state.songs[songid].difficulties[chart]}</span>;
+        }
+    },
+
+    getPlays: function(record) {
+        if (!record) { return 0; }
+        var plays = 0;
+        for (var i = 0; i < 4; i++) {
+            if (record[i]) { plays += record[i].plays; }
+        }
+        return plays;
+    },
+
+    renderBySeries: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ac = this.state.songs[a].category;
+            var bc = this.state.songs[b].category;
+            return parseInt(bc) - parseInt(ac);
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+        var lastSeries = 0;
+        for (var i = 0; i < songids.length; i++) {
+            var curSeries = parseInt(this.state.songs[songids[i]].category) + 1;
+            if (curSeries != lastSeries) {
+                lastSeries = curSeries;
+                songids.splice(i, 0, -curSeries);
+            }
+        }
+
+        if (songids.length == 0) {
+            return (
+                <div>
+                    No records to display!
+                </div>
+            );
+        }
+
+        var paginate = false;
+        var curpage = -1;
+        var curbutton = -1;
+        if (songids.length > 99) {
+            // Arbitrary limit for perf reasons
+            paginate = true;
+        }
+
+        return (
+            <span>
+                { paginate ?
+                    <div className="section">
+                        {songids.map(function(songid) {
+                            if (songid < 0) {
+                                curbutton = curbutton + 1;
+                                var subtab = curbutton;
+                                return (
+                                    <Nav
+                                        title={ this.state.versions[(-songid) - 1] }
+                                        active={ subtab == this.state.subtab }
+                                        onClick={function(event) {
+                                            if (this.state.subtab == subtab) { return; }
+                                            this.setState({subtab: subtab, offset: 0});
+                                            pagenav.navigate(this.state.sort, window.valid_mixes[subtab]);
+                                        }.bind(this)}
+                                    />
+                                );
+                            } else {
+                                return null;
+                            }
+                        }.bind(this))}
+                    </div> :
+                    null
+                }
+                <div className="section">
+                    <table className="list records">
+                        <thead></thead>
+                        <tbody>
+                            {songids.map(function(songid) {
+                                if (songid < 0) {
+                                    // This is a series header
+                                    curpage = curpage + 1;
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    return (
+                                        <tr key={((-songid) - 1).toString()}>
+                                            <td className="subheader">{ this.state.versions[(-songid) - 1] }</td>
+                                            <td className="subheader">Novice</td>
+                                            <td className="subheader">Advanced</td>
+                                            <td className="subheader">Exhaust</td>
+                                            <td className="subheader">Infinite</td>
+                                            <td className="subheader">Maximum</td>
+                                        </tr>
+                                    );
+                                } else {
+                                    if (paginate && curpage != this.state.subtab) { return null; }
+
+                                    var records = this.state.records[songid];
+                                    if (!records) {
+                                        records = {};
+                                    }
+
+                                    var difficulties = this.state.songs[songid].difficulties;
+                                    return (
+                                        <tr key={songid.toString()}>
+                                            <td className="center">
+                                                <div>
+                                                    <a href={Link.get('individual_score', songid)}>
+                                                        <div className="songname">{ this.state.songs[songid].name }</div>
+                                                        <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                                    </a>
+                                                </div>
+                                                <div className="songdifficulties">
+                                                    {this.renderDifficulty(songid, 0)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 1)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 2)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 3)}
+                                                    <span> / </span>
+                                                    {this.renderDifficulty(songid, 4)}
+                                                </div>
+                                            </td>
+                                            <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={0}
+                                                    score={records[0]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={1}
+                                                    score={records[1]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={2}
+                                                    score={records[2]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={3}
+                                                    score={records[3]}
+                                                />
+                                            </td>
+                                            <td className={difficulties[4] > 0 ? "" : "nochart"}>
+                                                <HighScore
+                                                    players={this.state.players}
+                                                    songid={songid}
+                                                    chart={4}
+                                                    score={records[4]}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }
+                            }.bind(this))}
+                        </tbody>
+                    </table>
+                </div>
+            </span>
+        );
+    },
+
+    renderByName: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var an = this.state.songs[a].name;
+            var bn = this.state.songs[b].name;
+            var c = an.localeCompare(bn);
+            if (c == 0) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return c;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, false);
+    },
+
+    renderByPopularity: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            var ap = this.getPlays(this.state.records[a]);
+            var bp = this.getPlays(this.state.records[b]);
+            if (bp == ap) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bp - ap;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return this.renderBySongIDList(songids, true);
+    },
+
+    renderByScore: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var as = 0;
+            var bs = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { as = ac.points; }
+            if (bc) { bs = bc.points; }
+
+            if (bs == as) {
+                return parseInt(a) - parseInt(b);
+            } else {
+                return bs - as;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderByClearType: function() {
+        var songids = Object.keys(this.state.songs).sort(function(a, b) {
+            // Grab records for this song
+            var ar = this.state.records[a];
+            var br = this.state.records[b];
+            var ac = null;
+            var bc = null;
+            var al = 0;
+            var bl = 0;
+
+            // Fill in record for current chart only if it exists
+            if (ar) { ac = ar[this.state.subtab]; }
+            if (br) { bc = br[this.state.subtab]; }
+            if (ac) { al = ac.medal; }
+            if (bc) { bl = bc.medal; }
+
+            if (al == bl) {
+                return parseInt(a) - parseInt(b)
+            } else {
+                return bl - al;
+            }
+        }.bind(this));
+        if (window.filterempty) {
+            songids = songids.filter(function(songid) {
+                return this.getPlays(this.state.records[songid]) > 0;
+            }.bind(this));
+        }
+
+        return (
+            <span>
+                <div className="section">
+                    {window.valid_charts.map(function(chartname, index) {
+                        return (
+                            <Nav
+                                title={ chartname }
+                                active={ this.state.subtab == index }
+                                onClick={function(event) {
+                                    if (this.state.subtab == index) { return; }
+                                    this.setState({subtab: index, offset: 0});
+                                    pagenav.navigate(this.state.sort, window.valid_charts[index]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                { this.renderBySongIDList(songids, false) }
+            </span>
+        );
+    },
+
+    renderBySongIDList: function(songids, showplays) {
+        return (
+            <table className="list records">
+                <thead>
+                    <tr>
+                        <th className="subheader">Song</th>
+                        <th className="subheader">Novice</th>
+                        <th className="subheader">Advanced</th>
+                        <th className="subheader">Exhaust</th>
+                        <th className="subheader">Infinite</th>
+                        <th className="subheader">Maximum</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {songids.map(function(songid, index) {
+                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                            return null;
+                        }
+
+                        var records = this.state.records[songid];
+                        if (!records) {
+                            records = {};
+                        }
+
+                        var plays = this.getPlays(records);
+                        var difficulties = this.state.songs[songid].difficulties;
+                        return (
+                            <tr key={songid.toString()}>
+                                <td className="center">
+                                    <div>
+                                        <a href={Link.get('individual_score', songid)}>
+                                            <div className="songname">{ this.state.songs[songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[songid].artist }</div>
+                                        </a>
+                                    </div>
+                                    <div className="songdifficulties">
+                                        {this.renderDifficulty(songid, 0)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 1)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 2)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 3)}
+                                        <span> / </span>
+                                        {this.renderDifficulty(songid, 4)}
+                                    </div>
+                                    { showplays ? <div className="songplays">#{index + 1} - {plays}{plays == 1 ? ' play' : ' plays'}</div> : null }
+                                </td>
+                                <td className={difficulties[0] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={0}
+                                        score={records[0]}
+                                    />
+                                </td>
+                                <td className={difficulties[1] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={1}
+                                        score={records[1]}
+                                    />
+                                </td>
+                                <td className={difficulties[2] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={2}
+                                        score={records[2]}
+                                    />
+                                </td>
+                                <td className={difficulties[3] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={3}
+                                        score={records[3]}
+                                    />
+                                </td>
+                                <td className={difficulties[4] > 0 ? "" : "nochart"}>
+                                    <HighScore
+                                        players={this.state.players}
+                                        songid={songid}
+                                        chart={4}
+                                        score={records[4]}
+                                    />
+                                </td>
+                            </tr>
+                        );
+                    }.bind(this))}
+                </tbody>
+                <tfoot>
+                    <tr>
+                        <td colSpan={6}>
+                            { this.state.offset > 0 ?
+                                <Prev onClick={function(event) {
+                                     var page = this.state.offset - this.state.limit;
+                                     if (page < 0) { page = 0; }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> : null
+                            }
+                            { (this.state.offset + this.state.limit) < songids.length ?
+                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                     var page = this.state.offset + this.state.limit;
+                                     if (page >= songids.length) { return }
+                                     this.setState({offset: page});
+                                }.bind(this)}/> :
+                                null
+                            }
+                        </td>
+                    </tr>
+                </tfoot>
+            </table>
+        );
+    },
+
+    render: function() {
+        var data = null;
+        if (this.state.sort == 'series') {
+            data = this.renderBySeries();
+        } else if (this.state.sort == 'popularity') {
+            data = this.renderByPopularity();
+        } else if (this.state.sort == 'name') {
+            data = this.renderByName();
+        } else if (this.state.sort == 'grade') {
+            data = this.renderByScore();
+        } else if (this.state.sort == 'clear') {
+            data = this.renderByClearType();
+        }
+
+        return (
+            <div>
+                <div className="section">
+                    { window.valid_sorts.map(function(sort, index) {
+                        return (
+                            <Nav
+                                title={"Records Sorted by " + window.sort_names[sort]}
+                                active={this.state.sort == sort}
+                                onClick={function(event) {
+                                    if (this.state.sort == sort) { return; }
+                                    this.setState({sort: sort, offset: 0, subtab: 0});
+                                    pagenav.navigate(sort, window.valid_subsorts[index][0]);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this)) }
+                </div>
+                <div className="section">
+                    {data}
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_records, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/rivals.react.js b/bemani/frontend/static/controllers/sdvx/rivals.react.js
new file mode 100644
index 0000000..ce9b35a
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/rivals.react.js
@@ -0,0 +1,301 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.rivals);
+var pagenav = new History(valid_versions);
+
+var rivals_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.rivals);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            rivals: window.rivals,
+            players: window.players,
+            profiles: profiles,
+            version: version,
+            term: "",
+            results: {},
+            searching: false,
+            offset: 0,
+            limit: 5,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version, offset: 0});
+        }.bind(this));
+        this.refreshRivals();
+    },
+
+    refreshRivals: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+				setTimeout(this.refreshRivals, 5000);
+            }.bind(this)
+        );
+    },
+
+    searchForPlayers: function(event) {
+        this.setState({searching: true});
+        AJAX.post(
+            Link.get('search'),
+            {
+                version: this.state.version,
+                term: this.state.term,
+            },
+            function(response) {
+                this.setState({
+                    results: response.results,
+                    searching: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRival: function(event, userid) {
+        AJAX.post(
+            Link.get('addrival'),
+            {
+                version: this.state.version,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    removeRival: function(event, userid) {
+        AJAX.post(
+            Link.get('removerival'),
+            {
+                version: this.state.version,
+                userid: userid,
+            },
+            function(response) {
+                this.setState({
+                    rivals: response.rivals,
+                    players: response.players,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    addRivals: function(userid) {
+        if (userid == window.userid) {
+            return null;
+        }
+
+        var avail = true;
+        var count = 0;
+        var current_rivals = this.state.rivals[this.state.version];
+        for (var i = 0; i < current_rivals.length; i++) {
+            count++;
+            if (current_rivals[i].userid == userid) {
+                avail = false;
+            }
+        }
+
+        if (count >= 3) { avail = false; }
+
+        return (
+            <span>
+                {avail ?
+                    <Add
+                        title="Add Rival"
+                        onClick={function(event) {
+                            this.addRival(event, userid);
+                        }.bind(this)}
+                    /> :
+                    null
+                }
+            </span>
+        );
+    },
+
+    render: function() {
+        if (this.state.rivals[this.state.version]) {
+            var rivals = this.state.rivals[this.state.version];
+            var resultlength = 0;
+            Object.keys(this.state.results).map(function(userid, index) {
+                var player = this.state.results[userid][this.state.version];
+                if (player) { resultlength++; }
+            }.bind(this));
+            return (
+                <div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            offset: 0,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <form onSubmit={this.searchForPlayers}>
+                            <label for="search">Name or SDVX ID:</label>
+                            <br />
+                            <input
+                                type="text"
+                                className="inline"
+                                maxlength="9"
+                                value={this.state.term}
+                                onChange={function(event) {
+                                    var value = event.target.value.toUpperCase();
+                                    var intRegex = new RegExp(
+                                        "^[" +
+                                        "0-9" +
+                                        "A-Z" +
+                                        "!?#$&*-. " +
+                                        "]*$"
+                                    );
+                                    // Normally, names are <= 8 characters, but we allow SDVX IDs here too
+                                    if (value.length <= 9 && intRegex.test(value)) {
+                                        this.setState({term: value});
+                                    }
+                                }.bind(this)}
+                                name="search"
+                            />
+                            <input type="submit" value="search" />
+                            { this.state.searching ?
+                                <img className="loading" src={Link.get('static', 'loading-16.gif')} /> :
+                                null
+                            }
+                        </form>
+                        {resultlength > 0 ?
+                            <table className="list players">
+                                <thead>
+                                    <tr>
+                                        <th>Name</th>
+                                        <th>SDVX ID</th>
+                                        <th className="action"></th>
+                                    </tr>
+                                </thead>
+                                <tbody>{
+                                    Object.keys(this.state.results).map(function(userid, index) {
+                                        if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                            return null;
+                                        }
+                                        var player = this.state.results[userid][this.state.version];
+                                        if (!player) { return null; }
+
+                                        return (
+                                            <tr>
+                                                <td><Rival userid={userid} player={player} /></td>
+                                                <td>{ player.extid }</td>
+                                                <td className="edit">{this.addRivals(userid)}</td>
+                                            </tr>
+                                        );
+                                    }.bind(this))
+                                }</tbody>
+                                <tfoot>
+                                    <tr>
+                                        <td colSpan={2}>
+                                            { this.state.offset > 0 ?
+                                                <Prev onClick={function(event) {
+                                                     var page = this.state.offset - this.state.limit;
+                                                     if (page < 0) { page = 0; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                            { (this.state.offset + this.state.limit) < resultlength ?
+                                                <Next style={ {float: 'right'} } onClick={function(event) {
+                                                     var page = this.state.offset + this.state.limit;
+                                                     if (page >= resultlength) { return; }
+                                                     this.setState({offset: page});
+                                                }.bind(this)}/> : null
+                                            }
+                                        </td>
+                                    </tr>
+                                </tfoot>
+                            </table> :
+                            <div className="placeholder">No players match the specified search.</div>
+                        }
+                    </div>
+                    <div className="section">
+                        <h3>Rivals</h3>
+                        <table className="list players">
+                            <thead>
+                                <tr>
+                                    <th>Name</th>
+                                    <th>SDVX ID</th>
+                                    <th className="action"></th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {this.state.rivals[this.state.version].map(function(rival, index) {
+                                    var player = this.state.players[rival.userid][this.state.version];
+                                    return (
+                                        <tr>
+                                            <td><Rival userid={rival.userid} player={player} /></td>
+                                            <td>{ player.extid }</td>
+                                            <td className="edit">
+                                                <Delete
+                                                    title="Remove Rival"
+                                                    onClick={function(event) {
+                                                        this.removeRival(event, rival.userid);
+                                                    }.bind(this)}
+                                                />
+                                            </td>
+                                        </tr>
+                                    );
+                                }.bind(this))}
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({version: version, offset: 0});
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(rivals_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/scores.react.js b/bemani/frontend/static/controllers/sdvx/scores.react.js
new file mode 100644
index 0000000..18e3be0
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/scores.react.js
@@ -0,0 +1,160 @@
+/*** @jsx React.DOM */
+
+var network_scores = React.createClass({
+    getInitialState: function(props) {
+        return {
+            songs: window.songs,
+            attempts: window.attempts,
+            players: window.players,
+            loading: true,
+            offset: 0,
+            limit: 10,
+        };
+    },
+
+    componentDidMount: function() {
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    attempts: response.attempts,
+                    players: response.players,
+                    loading: false,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 0:
+                return 'Novice';
+            case 1:
+                return 'Advanced';
+            case 2:
+                return 'Exhaust';
+            case 3:
+                return 'Infinite';
+            case 4:
+                return 'Maximum';
+            default:
+                return 'u broke it';
+        }
+    },
+
+    renderScore: function(score) {
+        return (
+            <div className="score">
+                <div>
+                    <span className="label">Score</span>
+                    <span className="score">{score.points}</span>
+                    <span className="status">{score.grade}</span>
+                <div>
+                </div>
+                    <span className="label">Combo</span>
+                    <span className="score">{score.combo < 0 ? '-' : score.combo}</span>
+                </div>
+                <div>
+                    <span className="status">{score.clear_type}</span>
+                </div>
+            </div>
+        );
+    },
+
+    render: function() {
+        return (
+            <div>
+                <table className="list attempts">
+                    <thead>
+                        <tr>
+                            { window.shownames ? <th>Name</th> : null }
+                            <th>Timestamp</th>
+                            <th>Song</th>
+                            <th>Chart</th>
+                            <th>Score</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {this.state.attempts.map(function(attempt, index) {
+                            if (index < this.state.offset || index >= this.state.offset + this.state.limit) {
+                                return null;
+                            }
+
+                            return (
+                                <tr>
+                                    { window.shownames ? <td><a href={Link.get('player', attempt.userid)}>{
+                                        this.state.players[attempt.userid].name
+                                    }</a></td> : null }
+                                    <td>
+                                        <div>
+                                            <Timestamp timestamp={attempt.timestamp} />
+                                            { window.shownewrecords && attempt.raised ?
+                                                <span className="raised">new high score!</span> :
+                                                null
+                                            }
+                                        </div>
+                                    </td>
+                                    <td className="center">
+                                        <a href={Link.get('individual_score', attempt.songid)}>
+                                            <div className="songname">{ this.state.songs[attempt.songid].name }</div>
+                                            <div className="songartist">{ this.state.songs[attempt.songid].artist }</div>
+                                        </a>
+                                    </td>
+                                    <td className="center">
+                                        <div>
+                                            <a href={Link.get('individual_score', attempt.songid, this.convertChart(attempt.chart))}>{
+                                                this.convertChart(attempt.chart)
+                                            }</a>
+                                        </div>
+                                        <div>{
+                                            this.state.songs[attempt.songid].difficulties[attempt.chart]
+                                        }</div>
+                                    </td>
+                                    <td>{ this.renderScore(attempt) }</td>
+                                </tr>
+                            );
+                        }.bind(this))}
+                    </tbody>
+                    <tfoot>
+                        <tr>
+                            <td colSpan={5}>
+                                { this.state.offset > 0 ?
+                                    <Prev onClick={function(event) {
+                                         var page = this.state.offset - this.state.limit;
+                                         if (page < 0) { page = 0; }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> : null
+                                }
+                                { (this.state.offset + this.state.limit) < this.state.attempts.length ?
+                                    <Next style={ {float: 'right'} } onClick={function(event) {
+                                         var page = this.state.offset + this.state.limit;
+                                         if (page >= this.state.attempts.length) { return }
+                                         this.setState({offset: page});
+                                    }.bind(this)}/> :
+                                    this.state.loading ?
+                                        <span className="loading" style={ {float: 'right' } }>
+                                            <img
+                                                className="loading"
+                                                src={Link.get('static', 'loading-16.gif')}
+                                            /> loading more scores...
+                                        </span> : null
+                                }
+                            </td>
+                        </tr>
+                    </tfoot>
+                </table>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(network_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/settings.react.js b/bemani/frontend/static/controllers/sdvx/settings.react.js
new file mode 100644
index 0000000..9fadefc
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/settings.react.js
@@ -0,0 +1,161 @@
+/*** @jsx React.DOM */
+
+var valid_versions = Object.keys(window.versions);
+var pagenav = new History(valid_versions);
+
+var settings_view = React.createClass({
+
+    getInitialState: function(props) {
+        var profiles = Object.keys(window.player);
+        var version = pagenav.getInitialState(profiles[profiles.length - 1]);
+        return {
+            player: window.player,
+            profiles: profiles,
+            version: version,
+            new_name: window.player[version].name,
+            editing_name: false,
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(version) {
+            this.setState({version: version});
+        }.bind(this));
+    },
+
+    saveName: function(event) {
+        AJAX.post(
+            Link.get('updatename'),
+            {
+                version: this.state.version,
+                name: this.state.new_name,
+            },
+            function(response) {
+                var player = this.state.player;
+                player[response.version].name = response.name;
+                this.setState({
+                    player: player,
+                    new_name: this.state.player[response.version].name,
+                    editing_name: false,
+                });
+            }.bind(this)
+        );
+        event.preventDefault();
+    },
+
+    renderName: function(player) {
+        return (
+            <LabelledSection vertical={true} label="Name">{
+                !this.state.editing_name ?
+                    <span>
+                        <span>{player.name}</span>
+                        <Edit
+                            onClick={function(event) {
+                                this.setState({editing_name: true});
+                            }.bind(this)}
+                        />
+                    </span> :
+                    <form className="inline" onSubmit={this.saveName}>
+                        <input
+                            type="text"
+                            className="inline"
+                            maxlength="8"
+                            size="16"
+                            value={this.state.new_name}
+                            onChange={function(event) {
+                                var value = event.target.value.toUpperCase();
+                                var nameRegex = new RegExp(
+                                    "^[" +
+                                    "0-9" +
+                                    "A-Z" +
+                                    "!?#$&*-. " +
+                                    "]*$"
+                                );
+                                if (value.length <= 8 && nameRegex.test(value)) {
+                                    this.setState({new_name: value});
+                                }
+                            }.bind(this)}
+                            name="name"
+                        />
+                        <input
+                            type="submit"
+                            value="save"
+                        />
+                        <input
+                            type="button"
+                            value="cancel"
+                            onClick={function(event) {
+                                this.setState({
+                                    new_name: this.state.player[this.state.version].name,
+                                    editing_name: false,
+                                });
+                            }.bind(this)}
+                        />
+                    </form>
+            }</LabelledSection>
+        );
+    },
+
+    render: function() {
+        if (this.state.player[this.state.version]) {
+            var player = this.state.player[this.state.version];
+            return (
+                <div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.editing_name) { return; }
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                            new_name: this.state.player[version].name,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                    <div className="section">
+                        <h3>User Profile</h3>
+                        {this.renderName(player)}
+                    </div>
+                </div>
+            );
+        } else {
+            return (
+                <div>
+                    <div className="section">
+                        You have no profile for {window.versions[this.state.version]}!
+                    </div>
+                    <div className="section">
+                        {this.state.profiles.map(function(version) {
+                            return (
+                                <Nav
+                                    title={window.versions[version]}
+                                    active={this.state.version == version}
+                                    onClick={function(event) {
+                                        if (this.state.version == version) { return; }
+                                        this.setState({
+                                            version: version,
+                                        });
+                                        pagenav.navigate(version);
+                                    }.bind(this)}
+                                />
+                            );
+                        }.bind(this))}
+                    </div>
+                </div>
+            );
+        }
+    },
+});
+
+ReactDOM.render(
+    React.createElement(settings_view, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/controllers/sdvx/topscores.react.js b/bemani/frontend/static/controllers/sdvx/topscores.react.js
new file mode 100644
index 0000000..4650686
--- /dev/null
+++ b/bemani/frontend/static/controllers/sdvx/topscores.react.js
@@ -0,0 +1,144 @@
+/*** @jsx React.DOM */
+
+var valid_charts = ['Novice', 'Advanced', 'Exhaust', 'Infinite', 'Maximum'].filter(function(val, index) {
+    return window.difficulties[index] > 0;
+});
+var pagenav = new History(valid_charts);
+
+var top_scores = React.createClass({
+
+    sortTopScores: function(topscores) {
+        var newscores = [[], [], [], [], []];
+        topscores.map(function(score) {
+            newscores[score.chart].push(score);
+        }.bind(this));
+        return newscores;
+    },
+
+    getInitialState: function(props) {
+        return {
+            topscores: this.sortTopScores(window.topscores),
+            players: window.players,
+            chart: pagenav.getInitialState(valid_charts[0]),
+        };
+    },
+
+    componentDidMount: function() {
+        pagenav.onChange(function(chart) {
+            this.setState({chart: chart});
+        }.bind(this));
+        this.refreshScores();
+    },
+
+    refreshScores: function() {
+        AJAX.get(
+            Link.get('refresh'),
+            function(response) {
+                this.setState({
+                    topscores: this.sortTopScores(response.topscores),
+                    players: response.players,
+                });
+                // Refresh every 15 seconds
+                setTimeout(this.refreshScores, 15000);
+            }.bind(this)
+        );
+    },
+
+    convertChart: function(chart) {
+        switch(chart) {
+            case 'Novice':
+                return 0;
+            case 'Advanced':
+                return 1;
+            case 'Exhaust':
+                return 2;
+            case 'Infinite':
+                return 3;
+            case 'Maximum':
+                return 4;
+            default:
+                return null;
+        }
+    },
+
+    render: function() {
+        var chart = this.convertChart(this.state.chart);
+
+        return (
+            <div>
+                <div className="section">
+                    <div className="songname">{window.name}</div>
+                    <div className="songartist">{window.artist}</div>
+                    <div className="songdifficulty">{window.difficulties[chart]}</div>
+                </div>
+                <div className="section">
+                    {valid_charts.map(function(chart) {
+                        return (
+                            <Nav
+                                title={chart}
+                                active={this.state.chart == chart}
+                                onClick={function(event) {
+                                    if (this.state.chart == chart) { return; }
+                                    this.setState({chart: chart});
+                                    pagenav.navigate(chart);
+                                }.bind(this)}
+                            />
+                        );
+                    }.bind(this))}
+                </div>
+                <div className="section">
+               		<Table
+                        className="list topscores"
+                        columns={[
+                            {
+                                name: 'Name',
+                                render: function(topscore) {
+                                    return (
+                                        <a href={Link.get('player', topscore.userid)}>{
+                                            this.state.players[topscore.userid].name
+                                        }</a>
+                                    );
+                                }.bind(this),
+                                sort: function(a, b) {
+                                    var an = this.state.players[a.userid].name;
+                                    var bn = this.state.players[b.userid].name;
+                                    return an.localeCompare(bn);
+                                }.bind(this),
+                            },
+                            {
+                                name: 'Grade',
+                                render: function(topscore) { return topscore.grade; },
+                            },
+                            {
+                                name: 'Clear Type',
+                                render: function(topscore) { return topscore.clear_type; },
+                            },
+                            {
+                                name: 'Score',
+                                render: function(topscore) { return topscore.points; },
+                                sort: function(a, b) {
+                                    return a.points - b.points;
+                                },
+                                reverse: true,
+                            },
+                            {
+                                name: 'Combo',
+                                render: function(topscore) { return topscore.combo > 0 ? topscore.combo : '-'; },
+                            },
+                        ]}
+                        defaultsort='Score'
+                        rows={this.state.topscores[chart]}
+                        key={chart}
+                        paginate={10}
+                        emptymessage="There are no scores for this chart."
+                    />
+                </div>
+            </div>
+        );
+    },
+});
+
+ReactDOM.render(
+    React.createElement(top_scores, null),
+    document.getElementById('content')
+);
diff --git a/bemani/frontend/static/date.format.min.js b/bemani/frontend/static/date.format.min.js
new file mode 100644
index 0000000..edb9ceb
--- /dev/null
+++ b/bemani/frontend/static/date.format.min.js
@@ -0,0 +1 @@
+(function(){Date.shortMonths=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],Date.longMonths=["January","February","March","April","May","June","July","August","September","October","November","December"],Date.shortDays=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],Date.longDays=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];var t={d:function(){return(this.getDate()<10?"0":"")+this.getDate()},D:function(){return Date.shortDays[this.getDay()]},j:function(){return this.getDate()},l:function(){return Date.longDays[this.getDay()]},N:function(){return 0==this.getDay()?7:this.getDay()},S:function(){return this.getDate()%10==1&&11!=this.getDate()?"st":this.getDate()%10==2&&12!=this.getDate()?"nd":this.getDate()%10==3&&13!=this.getDate()?"rd":"th"},w:function(){return this.getDay()},z:function(){var t=new Date(this.getFullYear(),0,1);return Math.ceil((this-t)/864e5)},W:function(){var t=new Date(this.valueOf()),e=(this.getDay()+6)%7;t.setDate(t.getDate()-e+3);var n=t.valueOf();return t.setMonth(0,1),4!==t.getDay()&&t.setMonth(0,1+(4-t.getDay()+7)%7),1+Math.ceil((n-t)/6048e5)},F:function(){return Date.longMonths[this.getMonth()]},m:function(){return(this.getMonth()<9?"0":"")+(this.getMonth()+1)},M:function(){return Date.shortMonths[this.getMonth()]},n:function(){return this.getMonth()+1},t:function(){var t=this.getFullYear(),e=this.getMonth()+1;return 12===e&&(t=t++,e=0),new Date(t,e,0).getDate()},L:function(){var t=this.getFullYear();return t%400==0||t%100!=0&&t%4==0},o:function(){var t=new Date(this.valueOf());return t.setDate(t.getDate()-(this.getDay()+6)%7+3),t.getFullYear()},Y:function(){return this.getFullYear()},y:function(){return(""+this.getFullYear()).substr(2)},a:function(){return this.getHours()<12?"am":"pm"},A:function(){return this.getHours()<12?"AM":"PM"},B:function(){return Math.floor(1e3*((this.getUTCHours()+1)%24+this.getUTCMinutes()/60+this.getUTCSeconds()/3600)/24)},g:function(){return this.getHours()%12||12},G:function(){return this.getHours()},h:function(){return((this.getHours()%12||12)<10?"0":"")+(this.getHours()%12||12)},H:function(){return(this.getHours()<10?"0":"")+this.getHours()},i:function(){return(this.getMinutes()<10?"0":"")+this.getMinutes()},s:function(){return(this.getSeconds()<10?"0":"")+this.getSeconds()},u:function(){var t=this.getMilliseconds();return(10>t?"00":100>t?"0":"")+t},e:function(){return/\((.*)\)/.exec((new Date).toString())[1]},I:function(){for(var t=null,e=0;12>e;++e){var n=new Date(this.getFullYear(),e,1),i=n.getTimezoneOffset();if(null===t)t=i;else{if(t>i){t=i;break}if(i>t)break}}return this.getTimezoneOffset()==t|0},O:function(){return(-this.getTimezoneOffset()<0?"-":"+")+(Math.abs(this.getTimezoneOffset()/60)<10?"0":"")+Math.floor(Math.abs(this.getTimezoneOffset()/60))+(0==Math.abs(this.getTimezoneOffset()%60)?"00":(Math.abs(this.getTimezoneOffset()%60)<10?"0":"")+Math.abs(this.getTimezoneOffset()%60))},P:function(){return(-this.getTimezoneOffset()<0?"-":"+")+(Math.abs(this.getTimezoneOffset()/60)<10?"0":"")+Math.floor(Math.abs(this.getTimezoneOffset()/60))+":"+(0==Math.abs(this.getTimezoneOffset()%60)?"00":(Math.abs(this.getTimezoneOffset()%60)<10?"0":"")+Math.abs(this.getTimezoneOffset()%60))},T:function(){return this.toTimeString().replace(/^.+ \(?([^\)]+)\)?$/,"$1")},Z:function(){return 60*-this.getTimezoneOffset()},c:function(){return this.format("Y-m-d\\TH:i:sP")},r:function(){return this.toString()},U:function(){return this.getTime()/1e3}};Date.prototype.format=function(e){var n=this;return e.replace(/(\\?)(.)/g,function(e,i,r){return""===i&&t[r]?t[r].call(n):r})}}).call(this);
diff --git a/bemani/frontend/static/ddr-options.js b/bemani/frontend/static/ddr-options.js
new file mode 100644
index 0000000..4486941
--- /dev/null
+++ b/bemani/frontend/static/ddr-options.js
@@ -0,0 +1,46 @@
+var DDROptions = {
+    '16': {
+        'character': [
+            'all character random',
+            'male random',
+            'female random',
+            'Yuni',
+            'Rage',
+            'Afro',
+            'Jenny',
+            'Emi',
+            'Baby-Lon',
+            'Gus',
+            'Ruby',
+            'Alice',
+            'Julio',
+            'Bonnie',
+            'Zero',
+            'Rinon',
+            // The following need in-game unlocks
+            // 'Ryusei Emi'
+            // 'Ryusei Alice'
+            // 'Ryusei Rinon'
+        ],
+        'arrowskin': [
+            'normal',
+            'new',
+            'classic',
+            'cyber',
+            'medium',
+            'small',
+            'dot',
+        ],
+        'guidelines': [
+            'off',
+            'border',
+            'center',
+        ],
+        'filter': [
+            'off',
+            'dark',
+            'darker',
+            'darkest',
+        ],
+    },
+}
diff --git a/bemani/frontend/static/favicon.png b/bemani/frontend/static/favicon.png
new file mode 100644
index 0000000..374bfae
Binary files /dev/null and b/bemani/frontend/static/favicon.png differ
diff --git a/bemani/frontend/static/form.css b/bemani/frontend/static/form.css
new file mode 100644
index 0000000..594494d
--- /dev/null
+++ b/bemani/frontend/static/form.css
@@ -0,0 +1,107 @@
+form.inline {
+    margin: 0px;
+}
+
+form.inline label {
+    display: block;
+}
+
+form.inline label.inline {
+    display: inline-block;
+}
+
+form.inline div.row {
+    padding-bottom: 5px;
+}
+
+form.inline select {
+    vertical-align: bottom;
+    margin-right: 5px;
+}
+
+input.inline {
+    margin-right: 5px;
+}
+
+button::-moz-focus-inner, input::-moz-focus-inner {
+    border:0;
+    padding:0;
+}
+
+form div.action {
+    margin-top: 5px;
+}
+
+input[type="submit"] {
+    border: 1px solid #cddcc1;
+    background: #e7ffd4;
+    cursor: pointer;
+    border-radius: 3px;
+    padding-top: 2px;
+    padding-bottom: 2px;
+    padding-left: 6px;
+    padding-right: 6px;
+    margin-right: 5px;
+}
+
+input[type="button"], button.nav, button.toggle, button.edit, button.add, button.viewmore {
+    border: 1px solid #dadada;
+    background: #ffffff;
+    cursor: pointer;
+    border-radius: 3px;
+    padding-top: 2px;
+    padding-bottom: 2px;
+    padding-left: 6px;
+    padding-right: 6px;
+}
+
+input[type="button"] {
+    margin-right: 5px;
+}
+
+button.toggle:not(:last-child):not(:only-child), button.edit:not(:last-child):not(:only-child), button.delete:not(:last-child):not(:only-child), button.add:not(:last-child):not(:only-child) {
+    margin-right: 5px;
+}
+
+button.nav:not(:last-child) {
+    margin-right: 5px;
+}
+
+button.nav {
+    margin-bottom: 5px;
+}
+
+button.active {
+    font-weight: bold;
+}
+
+button.delete {
+    border: 1px solid #d6caca;
+    background: #ffe4e4;
+    cursor: pointer;
+    border-radius: 3px;
+    padding-top: 2px;
+    padding-bottom: 2px;
+    padding-left: 6px;
+    padding-right: 6px;
+}
+
+input[type="text"], input[type="password"], textarea {
+    border: 1px solid #dadada;
+    padding: 2px;
+    border-radius: 3px;
+}
+
+select {
+    border: 1px solid #dadada;
+    padding: 1px;
+    border-radius: 3px;
+}
+
+option.placeholder {
+    font-style: italic;
+}
+
+div.buttons {
+    padding-top:5px;
+}
diff --git a/bemani/frontend/static/history.js b/bemani/frontend/static/history.js
new file mode 100644
index 0000000..2eca5c8
--- /dev/null
+++ b/bemani/frontend/static/history.js
@@ -0,0 +1,101 @@
+function History (valid_states, valid_substates) {
+    // Handles allowing client-side react to add to/interact with browser
+    // history. This is how we can allow linking directly to a particular
+    // view while still being client-side JS.
+
+    this.valid_states = valid_states;
+    if (valid_substates) {
+        this.valid_substates = valid_substates;
+    } else {
+        // Just init to nothing for each, so we won't add commas to URIs
+        this.valid_substates = valid_states.map(function(state) {
+            return null;
+        }.bind(this));
+    }
+
+    this.__lookup = function(hash) {
+        var state = null;
+        var substate = null;
+
+        if (hash) {
+            this.valid_states.forEach(function(valid_state, index) {
+                if (this.valid_substates[index]) {
+                    var parts = hash.split(',');
+                    if (parts[0] == valid_state) {
+                        this.valid_substates[index].forEach(function(valid_substate) {
+                            if (parts[1] == valid_substate) {
+                                state = valid_state;
+                                substate = valid_substate;
+                            }
+                        }.bind(this));
+                    }
+                } else {
+                    if (hash == valid_state) {
+                        state = valid_state;
+                        substate = null;
+                    }
+                }
+            }.bind(this));
+        }
+
+        return {
+            state: state,
+            substate: substate,
+        };
+    };
+
+    this.__hash = function() {
+        return decodeURIComponent(window.location.href.split('#')[1]);
+    }
+
+    this.__construct = function(stateobj) {
+        if (stateobj.substate) {
+            return stateobj.state+','+stateobj.substate;
+        } else {
+            return stateobj.state;
+        }
+    };
+
+    this.getInitialState = function(default_state, default_substate) {
+        var state = this.__hash();
+        var actualState = this.__lookup(state);
+
+        if (actualState.state) {
+            history.replaceState({}, null, '#'+this.__construct(actualState));
+            return actualState.state;
+        } else {
+            history.replaceState({}, null, '#'+this.__construct({state: default_state, substate: default_substate}));
+            return default_state;
+        }
+    };
+
+    this.getInitialSubState = function(default_state, default_substate) {
+        var state = this.__hash();
+        var actualState = this.__lookup(state);
+
+        if (actualState.state) {
+            history.replaceState({}, null, '#'+this.__construct(actualState));
+            return actualState.substate;
+        } else {
+            history.replaceState({}, null, '#'+this.__construct({state: default_state, substate: default_substate}));
+            return default_substate;
+        }
+    };
+
+    this.onChange = function(callback) {
+        window.onpopstate = function(event) {
+            var state = this.__hash();
+            var actualState = this.__lookup(state);
+            if (actualState.state) {
+                callback(actualState.state, actualState.substate);
+            }
+        }.bind(this);
+    };
+
+    this.navigate = function(state, substate) {
+        var actualState = this.__lookup(this.__construct({state: state, substate: substate}));
+        if (actualState.state) {
+            history.pushState({}, null, '#'+this.__construct(actualState));
+        }
+    };
+};
diff --git a/bemani/frontend/static/iidx-options.js b/bemani/frontend/static/iidx-options.js
new file mode 100644
index 0000000..bb7ce49
--- /dev/null
+++ b/bemani/frontend/static/iidx-options.js
@@ -0,0 +1,1050 @@
+var IIDXOptions = {
+    "20": {
+        "frame": [
+            "DEFAULT",
+            "JAPAN TOUR",
+            "WORLD TOUR",
+            "BOSS",
+            "STORY",
+        ],
+        "turntable": [
+             "DEFAULT",
+             "TRAN",
+             "TAITYOU",
+             "DELTA",
+             "HAPPY SKY",
+             "DISTORTED",
+             "GOLD",
+             "TROOPERS",
+             "EMPRESS",
+             "SIRIUS",
+             "RESORT",
+             "LINCLE",
+             "TRICORO",
+        ],
+        "burst": [
+            "DEFAULT",
+            "1ST",
+            "9TH",
+            "RED",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+        ],
+        "towel": [
+            "DEFAULT",
+            "SIGSIG",
+            "NAIBU FRAME",
+            "SKY",
+            "KAMAITACHI",
+            "TAORU",
+            "COSMOS",
+            "DOKYO KYODAI",
+            "BLIND J",
+            "MEISAI",
+            "BLOOMIN",
+            "MARIE A",
+            "ELISHA",
+            "KUNG-FU",
+            "TUNE BEAT3",
+            "EMPRESS",
+            "PRO WORLD",
+            "3Y3S",
+            "UMEGIRI",
+            "KANZAKI",
+            "ROCK DA H",
+            "DOOR RAINBOW",
+            "AEGIS",
+            "VERMILLION",
+            "F",
+            "LUCKY DAYS",
+            "ALMACE",
+            "SESSION12",
+            "MAMONIS",
+            "ASHEMU",
+            "BULLUVEGOLA",
+            "BERIDZEBETH1",
+            "LEVASLATER",
+            "STN",
+            "RCHE1",
+            "NEULAKYUSSRA",
+            "CYBELE",
+            "CUVELIA",
+            "LIBERATION",
+            "PRALUDIUM",
+            "PORTAL",
+            "REGENERATION",
+            "20SYSTEM BG",
+        ],
+        "noteskin": [
+             "DEFAULT",
+             "6DOT",
+             "4DOT",
+             "GORGEOUS",
+             "AQUA",
+             "GAL",
+             "PHOTON",
+             "PASTEL",
+             "SIMPLE",
+             "LIGHT",
+        ],
+        "full_combo": [
+            "DEFAULT",
+            "RED",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+        ],
+        "beam": [
+            "DEFAULT",
+            "SHORT",
+            "LONG",
+            "ORANGE",
+            "PINK",
+            "MONOCHROME",
+        ],
+        "judge": [
+            "DEFAULT",
+            "DIGITAL",
+            "SMART",
+            "METALLIC",
+            "TECHNO",
+            "WIRE",
+        ],
+        "bgm": [
+            "DEFAULT",
+            "TAG",
+            "SOTA FUJIMORI",
+            "SEIYA MURAI",
+            "PON",
+            "L.E.D.",
+            "NEKOMATA MASTER",
+        ],
+        "voice": [
+            "DEFAULT",
+            "MIRIN",
+            "SUPERSTAR",
+        ],
+    },
+    "21": {
+        "turntable": [
+            "DEFAULT",
+            "TRAN",
+            "TAITYOU",
+            "DELTA",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SHAKUNETSU",
+            "SUPER STAR",
+        ],
+        "burst": [
+            "DEFAULT",
+            "1ST",
+            "9TH",
+            "RED",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+        ],
+        "towel": [
+            "DEFAULT",
+            "SIGSIG",
+            "NAIBU FRAME",
+            "SKY",
+            "KAMAITACHI",
+            "TAORU",
+            "COSMOS",
+            "DOKYO KYODAI",
+            "BLIND J",
+            "MEISAI",
+            "BLOOMIN",
+            "MARIE A",
+            "ELISHA",
+            "KUNG-FU",
+            "TUNE BEAT3",
+            "EMPRESS",
+            "PRO WORLD",
+            "3Y3S",
+            "UMEGIRI",
+            "KANZAKI",
+            "ROCK DA H",
+            "DOOR RAINBOW",
+            "AEGIS",
+            "VERMILLION",
+            "F",
+            "LUCKY DAYS",
+            "ALMACE",
+            "SESSION12",
+            "MAMONIS",
+            "ASHEMU",
+            "BULLUVEGOLA",
+            "BERIDZEBETH1",
+            "LEVASLATER",
+            "STN",
+            "RCHE1",
+            "NEULAKYUSSRA",
+            "CYBELE",
+            "CUVELIA",
+            "LIBERATION",
+            "PRALUDIUM",
+            "PORTAL",
+            "REGENERATION",
+            "20SYSTEM BG",
+            "DOGMA A",
+            "DOGMA B",
+            "ELEKTRICK U",
+            "MAGIC LOVE",
+            "SPADA",
+            "S!CK",
+            "CONCEPTUAL",
+            "ELPIS1",
+            "RUMRUM",
+            "SYNC-ANTHEM",
+            "THOR'S HAMMER",
+            "PLAN 8",
+            "KASOKUKAN",
+            "8BIT P",
+            "PLANARIAN",
+            "TP-RZ",
+            "DECOHERENCE",
+            "TORIKAGO",
+            "PROOF",
+            "BRAVE GLOW1",
+            "BRAVE GLOW2",
+            "VEGA1",
+            "VEGA2",
+            "CASINO FIRE",
+            "NEW LIGHTS",
+            "FRACTAL",
+            "NOCHOKU",
+            "KYATORARE",
+            "ONLY ONE",
+        ],
+        "noteskin": [
+            "DEFAULT",
+            "6DOT",
+            "4DOT",
+            "GORGEOUS",
+            "AQUA",
+            "GAL",
+            "PHOTON",
+            "PASTEL",
+            "SIMPLE",
+            "LIGHT",
+            "TRICORO",
+            "BUBBLE",
+        ],
+        "full_combo": [
+            "DEFAULT",
+            "RED",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+        ],
+        "beam": [
+            "DEFAULT",
+            "SHORT",
+            "LONG",
+            "ORANGE",
+            "PINK",
+            "MONOCHROME",
+            "VERY SHORT",
+            "LIGHTNING",
+            "SUPER STAR",
+        ],
+        "judge": [
+            "DEFAULT",
+            "DIGITAL",
+            "SMART",
+            "METALLIC",
+            "TECHNO",
+            "WIRE",
+            "ABYSS",
+            "SPADA",
+            "ANCIENT",
+            "SUPER STAR",
+        ],
+        "bgm": [
+            "DEFAULT",
+            "SUPER STAR",
+        ],
+        "voice": [
+            "DEFAULT",
+            "SUPER STAR",
+        ],
+    },
+    "22": {
+        "frame": [
+            "DEFAULT",
+            "FANTA",
+            "SPRITE",
+            "SOKENBICHA",
+            "GEORGIA BLK",
+            "GEORGIA",
+            "GEORGIA BTO",
+            "REALGOLD",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+        ],
+        "turntable": [
+            "DEFAULT",
+            "TRAN",
+            "TAITYOU",
+            "DELTA",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SHAKUNETSU",
+            "SUPER STAR",
+            "PENDUAL",
+        ],
+        "burst": [
+            "DEFAULT",
+            "1ST",
+            "9TH",
+            "RED",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+            "PENDUAL",
+        ],
+        "towel": [
+            "DEFAULT",
+            "SIGSIG",
+            "NAIBU FRAME",
+            "SKY",
+            "KAMAITACHI",
+            "TAORU",
+            "COSMOS",
+            "DOKYO KYODAI",
+            "BLIND J",
+            "MEISAI",
+            "BLOOMIN",
+            "MARIE A",
+            "ELISHA",
+            "KUNG-FU",
+            "TUNE BEAT3",
+            "EMPRESS",
+            "PRO WORLD",
+            "3Y3S",
+            "UMEGIRI",
+            "KANZAKI",
+            "ROCK DA H",
+            "DOOR RAINBOW",
+            "AEGIS",
+            "VERMILLION",
+            "F",
+            "LUCKY DAYS",
+            "ALMACE",
+            "SESSION12",
+            "MAMONIS",
+            "ASHEMU",
+            "BULLUVEGOLA",
+            "BERIDZEBETH1",
+            "LEVASLATER",
+            "STN",
+            "RCHE1",
+            "NEULAKYUSSRA",
+            "CYBELE",
+            "CUVELIA",
+            "LIBERATION",
+            "PRALUDIUM",
+            "PORTAL",
+            "REGENERATION",
+            "20SYSTEM BG",
+            "DOGMA A",
+            "DOGMA B",
+            "ELEKTRICK U",
+            "MAGIC LOVE",
+            "SPADA",
+            "S!CK",
+            "CONCEPTUAL",
+            "ELPIS1",
+            "RUMRUM",
+            "SYNC-ANTHEM",
+            "THOR'S HAMMER",
+            "PLAN 8",
+            "KASOKUKAN",
+            "8BIT P",
+            "PLANARIAN",
+            "TP-RZ",
+            "DECOHERENCE",
+            "TORIKAGO",
+            "PROOF",
+            "BRAVE GLOW1",
+            "BRAVE GLOW2",
+            "VEGA1",
+            "VEGA2",
+            "CASINO FIRE",
+            "NEW LIGHTS",
+            "FRACTAL",
+            "NOCHOKU",
+            "KYATORARE",
+            "ONLY ONE",
+            "FANTA",
+            "SPRITE",
+            "SOKENBICHA",
+            "GEORGIA BLK",
+            "GEORGIA",
+            "GEORGIA S",
+            "REALGOLD",
+            "RCHE2",
+            "SUMOMO",
+            "FAULA",
+            "BERIDZEBETH2",
+            "ELPIS2",
+            "FERIRA",
+            "ALL PATONA",
+            "TORINOKO",
+            "SENNEN",
+            "SCARLET MOON",
+            "AYAKASHI",
+        ],
+        "noteskin": [
+            "DEFAULT",
+            "6DOT",
+            "4DOT",
+            "GORGEOUS",
+            "AQUA",
+            "GAL",
+            "PHOTON",
+            "PASTEL",
+            "SIMPLE",
+            "LIGHT",
+            "TRICORO",
+            "BUBBLE",
+        ],
+        "full_combo": [
+            "DEFAULT",
+            "RED",
+            "HAPPY SKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+            "PENDUAL",
+        ],
+        "beam": [
+            "DEFAULT",
+            "SHORT",
+            "LONG",
+            "ORANGE",
+            "PINK",
+            "MONOCHROME",
+            "VERY SHORT",
+            "LIGHTNING",
+            "SUPER STAR",
+        ],
+        "judge": [
+             "DEFAULT",
+             "DIGITAL",
+             "SMART",
+             "METALLIC",
+             "TECHNO",
+             "WIRE",
+             "ABYSS",
+             "SPADA",
+             "ANCIENT",
+             "SUPER STAR",
+        ],
+        "bgm": [
+            "DEFAULT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+        ],
+    },
+    "23": {
+        "turntable": [
+            "DEFAULT",
+            "TRAN",
+            "TAITYOU",
+            "DELTA",
+            "HAPPYSKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SHAKUNETSU",
+            "SUPER STAR",
+            "PENDUAL",
+            "COPULA",
+        ],
+        "burst": [
+            "DEFAULT",
+            "1ST",
+            "9TH",
+            "RED",
+            "HAPPYSKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+            "PENDUAL",
+            "COPULA",
+        ],
+        "towel": [
+            "DEFAULT",
+            "SIGSIG",
+            "NAIBU FRAME",
+            "SKY",
+            "KAMAITACHI",
+            "TAORU",
+            "COSMOS",
+            "DOKYO KYODAI",
+            "BLIND J",
+            "MEISAI",
+            "BLOOMIN",
+            "MARIE A",
+            "ELISHA",
+            "KUNG-FU",
+            "TUNE BEAT3",
+            "EMPRESS",
+            "PRO WORLD",
+            "3Y3S",
+            "UMEGIRI",
+            "KANZAKI",
+            "ROCK DA H",
+            "DOOR RAINBOW",
+            "AEGIS",
+            "VERMILLION",
+            "PHOENIX",
+            "LUCKY DAYS",
+            "ALMACE",
+            "DIAMOND CROSS",
+            "MAMONIS",
+            "ASHEMU",
+            "BULLUVEGOLA",
+            "BERIDZEBETH1",
+            "LEVASLATER",
+            "STN",
+            "RCHE1",
+            "NEULAKYUSSRA",
+            "CYBELE",
+            "CUVELIA",
+            "LIBERATION",
+            "PRALUDIUM",
+            "SHOJO ALICE",
+            "REGENERATION",
+            "20SYSTEM BG",
+            "DOGMA A",
+            "DOGMA B",
+            "ELEKTRICK U",
+            "MAGIC LOVE",
+            "SPADA",
+            "S!CK",
+            "CONCEPTUAL",
+            "ELPIS1",
+            "RUMRUM",
+            "SYNC-ANTHEM",
+            "THOR'S HAM",
+            "PLAN 8",
+            "KASOKUKAN",
+            "8BIT P",
+            "PLANARIAN",
+            "DYNAMITE",
+            "DECOHERENCE",
+            "TORIKAGO",
+            "PROOF",
+            "BRAVE GLOW1",
+            "BRAVE GLOW2",
+            "VEGA1",
+            "VEGA2",
+            "CASINO FIRE",
+            "NEW LIGHTS",
+            "SHAKUNETSU2",
+            "NOCHOKU",
+            "KYATORARE",
+            "ONLY ONE",
+            "JIZAL",
+            "JACKTILLO",
+            "JACKHANS",
+            "JENS",
+            "AMDUSIAN",
+            "MAXWELLION",
+            "LAPLASIA",
+            "RCHE2",
+            "SUMOMO",
+            "FAULA",
+            "BERIDZEBETH2",
+            "ELPIS2",
+            "FERIRA",
+            "ALL PATONA",
+            "TORINOKO",
+            "SENNEN",
+            "SCARLET MOON",
+            "AYAKASHI",
+            "ACID PUMPER",
+        ],
+        "noteskin": [
+            "DEFAULT",
+            "6DOT",
+            "4DOT",
+            "GORGEOUS",
+            "AQUA",
+            "GAL",
+            "FOTON",
+            "PASTEL",
+            "SIMPLE",
+            "LIGHT",
+            "TRICORO",
+            "BUBBLE",
+        ],
+        "full_combo": [
+            "DEFAULT",
+            "RED",
+            "HAPPYSKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+            "PENDUAL",
+            "COPULA",
+        ],
+        "beam": [
+            "DEFAULT",
+            "SHORT",
+            "LONG",
+            "ORANGE",
+            "PINK",
+            "MONOCHRO",
+            "VERY SHORT",
+            "LIGHTNING",
+            "SUPER STAR",
+            "COPULIGHT",
+        ],
+        "judge": [
+            "DEFAULT",
+            "DIGITAL",
+            "SMART",
+            "METALLIC",
+            "TECHNO",
+            "WIRE",
+            "ABYSS",
+            "SPADA",
+            "ANCIENT",
+            "SUPER STAR",
+            "ELECTRONIC",
+        ],
+    },
+    "24": {
+        "turntable": [
+            "DEFAULT",
+            "TRAN",
+            "TAITYOU",
+            "DELTA",
+            "HAPPYSKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SHAKUNETSU",
+            "SUPER STAR",
+            "PENDUAL",
+            "COPULA",
+            "SINOBUZ",
+        ],
+        "burst": [
+            "DEFAULT",
+            "1ST",
+            "9TH",
+            "RED",
+            "HAPPYSKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+            "PENDUAL",
+            "COPULA",
+            "SINOBUZ",
+        ],
+        "towel": [
+            "DEFAULT",
+            "SIGSIG",
+            "NAIBU FRAME",
+            "SKY",
+            "KAMAITACHI",
+            "TAORU",
+            "COSMOS",
+            "DOKYO KYODAI",
+            "BLIND J",
+            "MEISAI",
+            "BLOOMIN",
+            "MARIE A",
+            "ELISHA",
+            "KUNG-FU",
+            "TUNE BEAT3",
+            "EMPRESS",
+            "PRO WORLD",
+            "3Y3S",
+            "UMEGIRI",
+            "KANZAKI",
+            "ROCK DA H",
+            "DOOR RAINBOW",
+            "AEGIS",
+            "VERMILLION",
+            "PHOENIX",
+            "LUCKY DAYS",
+            "ALMACE",
+            "DIAMOND CROSS",
+            "MAMONIS",
+            "ASHEMU",
+            "BULLUVEGOLA",
+            "BERIDZEBETH1",
+            "LEVASLATER",
+            "STN",
+            "RCHE1",
+            "NEULAKYUSSRA",
+            "CYBELE",
+            "CUVELIA",
+            "LIBERATION",
+            "PRALUDIUM",
+            "SHOJO ALICE",
+            "REGENERATION",
+            "20SYSTEM BG",
+            "DOGMA A",
+            "DOGMA B",
+            "ELEKTRICK U",
+            "MAGIC LOVE",
+            "SPADA",
+            "S!CK",
+            "CONCEPTUAL",
+            "ELPIS1",
+            "RUMRUM",
+            "SYNC-ANTHEM",
+            "THOR'S HAM",
+            "PLAN 8",
+            "KASOKUKAN",
+            "8BIT P",
+            "PLANARIAN",
+            "DYNAMITE",
+            "DECOHERENCE",
+            "TORIKAGO",
+            "PROOF",
+            "BRAVE GLOW1",
+            "BRAVE GLOW2",
+            "VEGA1",
+            "VEGA2",
+            "CASINO FIRE",
+            "NEW LIGHTS",
+            "SHAKUNETSU2",
+            "NOCHOKU",
+            "KYATORARE",
+            "ONLY ONE",
+            "JIZAL",
+            "JACKTILLO",
+            "JACKHANS",
+            "JENS",
+            "AMDUSIAN",
+            "MAXWELLION",
+            "LAPLASIA",
+            "RCHE2",
+            "SUMOMO",
+            "FAULA",
+            "BERIDZEBETH2",
+            "ELPIS2",
+            "FERIRA",
+            "ALL PATONA",
+            "MEISAI",
+            "NINGYO",
+            "URARA",
+            "SHELTER",
+            "ACID PUMPER",
+            "X",
+            "ON THE FM",
+            "NIGHTMARE",
+            "HIGHCHARGE",
+            "GODSPEED1",
+            "GODSPEED2",
+            "GENERATE",
+            "DYNAMITE",
+            "DEVIL'S GEAR",
+            "DPS",
+            "AZISAI",
+            "LA DOLCE",
+            "AO-1",
+            "HELL OR HELL",
+            "RYOUSHI",
+            "EKINEKO",
+            "FUYUTUBAKI",
+            "PAPAYAPA",
+            "KARASU",
+            "ASIAN DIS",
+            "TOGAKUSHI",
+            "MODULAR TEC",
+            "SHISHIKASUMU",
+            "MUSIC IS ANS",
+            "VIVA",
+            "SINOBUZ",
+        ],
+        "noteskin": [
+            "DEFAULT",
+            "6DOT",
+            "4DOT",
+            "GORGEOUS",
+            "AQUA",
+            "GAL",
+            "FOTON",
+            "PASTEL",
+            "SIMPLE",
+            "LIGHT",
+            "TRICORO",
+            "BUBBLE",
+        ],
+        "full_combo": [
+            "DEFAULT",
+            "RED",
+            "HAPPYSKY",
+            "DISTORTED",
+            "GOLD",
+            "TROOPERS",
+            "EMPRESS",
+            "SIRIUS",
+            "RESORT",
+            "LINCLE",
+            "TRICORO",
+            "SPADA",
+            "SUPER STAR",
+            "PENDUAL",
+            "COPULA",
+            "SINOBUZ",
+        ],
+        "beam": [
+            "DEFAULT",
+            "SHORT",
+            "LONG",
+            "ORANGE",
+            "PINK",
+            "MONOCHRO",
+            "VERY SHORT",
+            "LIGHTNING",
+            "SUPER STAR",
+            "COPULIGHT",
+        ],
+        "judge": [
+            "DEFAULT",
+            "DIGITAL",
+            "SMART",
+            "METALLIC",
+            "TECHNO",
+            "WIRE",
+            "ABYSS",
+            "SPADA",
+            "ANCIENT",
+            "SUPER STAR",
+            "ELECTRONIC",
+            "SINOBUZ",
+        ],
+        "pacemaker": [
+            "DEFAULT",
+            "SIGSIG",
+            "NAIBU FRAME",
+            "SKY",
+            "KAMAITACHI",
+            "TAORU",
+            "COSMOS",
+            "DOKYO KYODAI",
+            "BLIND J",
+            "MEISAI",
+            "BLOOMIN",
+            "MARIE A",
+            "ELISHA",
+            "KUNG-FU",
+            "TUNE BEAT3",
+            "EMPRESS",
+            "PRO WORLD",
+            "3Y3S",
+            "UMEGIRI",
+            "KANZAKI",
+            "ROCK DA H",
+            "DOOR RAINBOW",
+            "AEGIS",
+            "VERMILLION",
+            "PHOENIX",
+            "LUCKY DAYS",
+            "ALMACE",
+            "DIAMOND CROSS",
+            "MAMONIS",
+            "ASHEMU",
+            "BULLUVEGOLA",
+            "BERIDZEBETH1",
+            "LEVASLATER",
+            "STN",
+            "RCHE1",
+            "NEULAKYUSSRA",
+            "CYBELE",
+            "CUVELIA",
+            "LIBERATION",
+            "PRALUDIUM",
+            "SHOJO ALICE",
+            "REGENERATION",
+            "20SYSTEM BG",
+            "DOGMA A",
+            "DOGMA B",
+            "ELEKTRICK U",
+            "MAGIC LOVE",
+            "SPADA",
+            "S!CK",
+            "CONCEPTUAL",
+            "ELPIS1",
+            "RUMRUM",
+            "SYNC-ANTHEM",
+            "THOR'S HAM",
+            "PLAN 8",
+            "KASOKUKAN",
+            "8BIT P",
+            "PLANARIAN",
+            "DYNAMITE",
+            "DECOHERENCE",
+            "TORIKAGO",
+            "PROOF",
+            "BRAVE GLOW1",
+            "BRAVE GLOW2",
+            "VEGA1",
+            "VEGA2",
+            "CASINO FIRE",
+            "NEW LIGHTS",
+            "SHAKUNETSU2",
+            "NOCHOKU",
+            "KYATORARE",
+            "ONLY ONE",
+            "JIZAL",
+            "JACKTILLO",
+            "JACKHANS",
+            "JENS",
+            "AMDUSIAN",
+            "MAXWELLION",
+            "LAPLASIA",
+            "RCHE2",
+            "SUMOMO",
+            "FAULA",
+            "BERIDZEBETH2",
+            "ELPIS2",
+            "FERIRA",
+            "ALL PATONA",
+            "MEISAI",
+            "NINGYO",
+            "URARA",
+            "SHELTER",
+            "ACID PUMPER",
+            "X",
+            "ON THE FM",
+            "NIGHTMARE",
+            "HIGHCHARGE",
+            "GODSPEED1",
+            "GODSPEED2",
+            "GENERATE",
+            "DYNAMITE",
+            "DEVIL'S GEAR",
+            "DPS",
+            "AZISAI",
+            "LA DOLCE",
+            "AO-1",
+            "HELL OR HELL",
+            "RYOUSHI",
+            "EKINEKO",
+            "FUYUTUBAKI",
+            "PAPAYAPA",
+            "KARASU",
+            "ASIAN DIS",
+            "TOGAKUSHI",
+            "MODULAR TEC",
+            "SHISHIKASUMU",
+            "MUSIC IS ANS",
+            "VIVA",
+            "SINOBUZ",
+        ],
+        "effector_preset": [
+            "OFF",
+            "ECHO/REVERB",
+            "EQ ONLY",
+            "PITCH",
+        ],
+    },
+}
diff --git a/bemani/frontend/static/jquery-1.12.4.min.js b/bemani/frontend/static/jquery-1.12.4.min.js
new file mode 100644
index 0000000..e836475
--- /dev/null
+++ b/bemani/frontend/static/jquery-1.12.4.min.js
@@ -0,0 +1,5 @@
+/*! jQuery v1.12.4 | (c) jQuery Foundation | jquery.org/license */
+!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=a.document,e=c.slice,f=c.concat,g=c.push,h=c.indexOf,i={},j=i.toString,k=i.hasOwnProperty,l={},m="1.12.4",n=function(a,b){return new n.fn.init(a,b)},o=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,p=/^-ms-/,q=/-([\da-z])/gi,r=function(a,b){return b.toUpperCase()};n.fn=n.prototype={jquery:m,constructor:n,selector:"",length:0,toArray:function(){return e.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:e.call(this)},pushStack:function(a){var b=n.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a){return n.each(this,a)},map:function(a){return this.pushStack(n.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(e.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor()},push:g,sort:c.sort,splice:c.splice},n.extend=n.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||n.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(e=arguments[h]))for(d in e)a=g[d],c=e[d],g!==c&&(j&&c&&(n.isPlainObject(c)||(b=n.isArray(c)))?(b?(b=!1,f=a&&n.isArray(a)?a:[]):f=a&&n.isPlainObject(a)?a:{},g[d]=n.extend(j,f,c)):void 0!==c&&(g[d]=c));return g},n.extend({expando:"jQuery"+(m+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===n.type(a)},isArray:Array.isArray||function(a){return"array"===n.type(a)},isWindow:function(a){return null!=a&&a==a.window},isNumeric:function(a){var b=a&&a.toString();return!n.isArray(a)&&b-parseFloat(b)+1>=0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},isPlainObject:function(a){var b;if(!a||"object"!==n.type(a)||a.nodeType||n.isWindow(a))return!1;try{if(a.constructor&&!k.call(a,"constructor")&&!k.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}if(!l.ownFirst)for(b in a)return k.call(a,b);for(b in a);return void 0===b||k.call(a,b)},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?i[j.call(a)]||"object":typeof a},globalEval:function(b){b&&n.trim(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b){var c,d=0;if(s(a)){for(c=a.length;c>d;d++)if(b.call(a[d],d,a[d])===!1)break}else for(d in a)if(b.call(a[d],d,a[d])===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(o,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?n.merge(c,"string"==typeof a?[a]:a):g.call(c,a)),c},inArray:function(a,b,c){var d;if(b){if(h)return h.call(b,a,c);for(d=b.length,c=c?0>c?Math.max(0,d+c):c:0;d>c;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,b){var c=+b.length,d=0,e=a.length;while(c>d)a[e++]=b[d++];if(c!==c)while(void 0!==b[d])a[e++]=b[d++];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,e,g=0,h=[];if(s(a))for(d=a.length;d>g;g++)e=b(a[g],g,c),null!=e&&h.push(e);else for(g in a)e=b(a[g],g,c),null!=e&&h.push(e);return f.apply([],h)},guid:1,proxy:function(a,b){var c,d,f;return"string"==typeof b&&(f=a[b],b=a,a=f),n.isFunction(a)?(c=e.call(arguments,2),d=function(){return a.apply(b||this,c.concat(e.call(arguments)))},d.guid=a.guid=a.guid||n.guid++,d):void 0},now:function(){return+new Date},support:l}),"function"==typeof Symbol&&(n.fn[Symbol.iterator]=c[Symbol.iterator]),n.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(a,b){i["[object "+b+"]"]=b.toLowerCase()});function s(a){var b=!!a&&"length"in a&&a.length,c=n.type(a);return"function"===c||n.isWindow(a)?!1:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ga(),z=ga(),A=ga(),B=function(a,b){return a===b&&(l=!0),0},C=1<<31,D={}.hasOwnProperty,E=[],F=E.pop,G=E.push,H=E.push,I=E.slice,J=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},K="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",L="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",N="\\["+L+"*("+M+")(?:"+L+"*([*^$|!~]?=)"+L+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+M+"))|)"+L+"*\\]",O=":("+M+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+N+")*)|.*)\\)|)",P=new RegExp(L+"+","g"),Q=new RegExp("^"+L+"+|((?:^|[^\\\\])(?:\\\\.)*)"+L+"+$","g"),R=new RegExp("^"+L+"*,"+L+"*"),S=new RegExp("^"+L+"*([>+~]|"+L+")"+L+"*"),T=new RegExp("="+L+"*([^\\]'\"]*?)"+L+"*\\]","g"),U=new RegExp(O),V=new RegExp("^"+M+"$"),W={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),TAG:new RegExp("^("+M+"|[*])"),ATTR:new RegExp("^"+N),PSEUDO:new RegExp("^"+O),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+L+"*(even|odd|(([+-]|)(\\d*)n|)"+L+"*(?:([+-]|)"+L+"*(\\d+)|))"+L+"*\\)|)","i"),bool:new RegExp("^(?:"+K+")$","i"),needsContext:new RegExp("^"+L+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+L+"*((?:-\\d)?\\d*)"+L+"*\\)|)(?=[^-]|$)","i")},X=/^(?:input|select|textarea|button)$/i,Y=/^h\d$/i,Z=/^[^{]+\{\s*\[native \w/,$=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,_=/[+~]/,aa=/'|\\/g,ba=new RegExp("\\\\([\\da-f]{1,6}"+L+"?|("+L+")|.)","ig"),ca=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},da=function(){m()};try{H.apply(E=I.call(v.childNodes),v.childNodes),E[v.childNodes.length].nodeType}catch(ea){H={apply:E.length?function(a,b){G.apply(a,I.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function fa(a,b,d,e){var f,h,j,k,l,o,r,s,w=b&&b.ownerDocument,x=b?b.nodeType:9;if(d=d||[],"string"!=typeof a||!a||1!==x&&9!==x&&11!==x)return d;if(!e&&((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,p)){if(11!==x&&(o=$.exec(a)))if(f=o[1]){if(9===x){if(!(j=b.getElementById(f)))return d;if(j.id===f)return d.push(j),d}else if(w&&(j=w.getElementById(f))&&t(b,j)&&j.id===f)return d.push(j),d}else{if(o[2])return H.apply(d,b.getElementsByTagName(a)),d;if((f=o[3])&&c.getElementsByClassName&&b.getElementsByClassName)return H.apply(d,b.getElementsByClassName(f)),d}if(c.qsa&&!A[a+" "]&&(!q||!q.test(a))){if(1!==x)w=b,s=a;else if("object"!==b.nodeName.toLowerCase()){(k=b.getAttribute("id"))?k=k.replace(aa,"\\$&"):b.setAttribute("id",k=u),r=g(a),h=r.length,l=V.test(k)?"#"+k:"[id='"+k+"']";while(h--)r[h]=l+" "+qa(r[h]);s=r.join(","),w=_.test(a)&&oa(b.parentNode)||b}if(s)try{return H.apply(d,w.querySelectorAll(s)),d}catch(y){}finally{k===u&&b.removeAttribute("id")}}}return i(a.replace(Q,"$1"),b,d,e)}function ga(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ha(a){return a[u]=!0,a}function ia(a){var b=n.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ja(a,b){var c=a.split("|"),e=c.length;while(e--)d.attrHandle[c[e]]=b}function ka(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||C)-(~a.sourceIndex||C);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function la(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function na(a){return ha(function(b){return b=+b,ha(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function oa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=fa.support={},f=fa.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},m=fa.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=n.documentElement,p=!f(n),(e=n.defaultView)&&e.top!==e&&(e.addEventListener?e.addEventListener("unload",da,!1):e.attachEvent&&e.attachEvent("onunload",da)),c.attributes=ia(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ia(function(a){return a.appendChild(n.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Z.test(n.getElementsByClassName),c.getById=ia(function(a){return o.appendChild(a).id=u,!n.getElementsByName||!n.getElementsByName(u).length}),c.getById?(d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ba,ca);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ba,ca);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return"undefined"!=typeof b.getElementsByClassName&&p?b.getElementsByClassName(a):void 0},r=[],q=[],(c.qsa=Z.test(n.querySelectorAll))&&(ia(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\r\\' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+L+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+L+"*(?:value|"+K+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ia(function(a){var b=n.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+L+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=Z.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ia(function(a){c.disconnectedMatch=s.call(a,"div"),s.call(a,"[s!='']:x"),r.push("!=",O)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=Z.test(o.compareDocumentPosition),t=b||Z.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===n||a.ownerDocument===v&&t(v,a)?-1:b===n||b.ownerDocument===v&&t(v,b)?1:k?J(k,a)-J(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,g=[a],h=[b];if(!e||!f)return a===n?-1:b===n?1:e?-1:f?1:k?J(k,a)-J(k,b):0;if(e===f)return ka(a,b);c=a;while(c=c.parentNode)g.unshift(c);c=b;while(c=c.parentNode)h.unshift(c);while(g[d]===h[d])d++;return d?ka(g[d],h[d]):g[d]===v?-1:h[d]===v?1:0},n):n},fa.matches=function(a,b){return fa(a,null,null,b)},fa.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(T,"='$1']"),c.matchesSelector&&p&&!A[b+" "]&&(!r||!r.test(b))&&(!q||!q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return fa(b,n,null,[a]).length>0},fa.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},fa.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&D.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},fa.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},fa.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=fa.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=fa.selectors={cacheLength:50,createPseudo:ha,match:W,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ba,ca),a[3]=(a[3]||a[4]||a[5]||"").replace(ba,ca),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||fa.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&fa.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return W.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&U.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ba,ca).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+L+")"+a+"("+L+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=fa.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(P," ")+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h,t=!1;if(q){if(f){while(p){m=b;while(m=m[p])if(h?m.nodeName.toLowerCase()===r:1===m.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){m=q,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n&&j[2],m=n&&q.childNodes[n];while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if(1===m.nodeType&&++t&&m===b){k[a]=[w,n,t];break}}else if(s&&(m=b,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n),t===!1)while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if((h?m.nodeName.toLowerCase()===r:1===m.nodeType)&&++t&&(s&&(l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),k[a]=[w,t]),m===b))break;return t-=e,t===d||t%d===0&&t/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||fa.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ha(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=J(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ha(function(a){var b=[],c=[],d=h(a.replace(Q,"$1"));return d[u]?ha(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ha(function(a){return function(b){return fa(a,b).length>0}}),contains:ha(function(a){return a=a.replace(ba,ca),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ha(function(a){return V.test(a||"")||fa.error("unsupported lang: "+a),a=a.replace(ba,ca).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return Y.test(a.nodeName)},input:function(a){return X.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:na(function(){return[0]}),last:na(function(a,b){return[b-1]}),eq:na(function(a,b,c){return[0>c?c+b:c]}),even:na(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:na(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:na(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:na(function(a,b,c){for(var d=0>c?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=la(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=ma(b);function pa(){}pa.prototype=d.filters=d.pseudos,d.setFilters=new pa,g=fa.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){c&&!(e=R.exec(h))||(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=S.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(Q," ")}),h=h.slice(c.length));for(g in d.filter)!(e=W[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?fa.error(a):z(a,i).slice(0)};function qa(a){for(var b=0,c=a.length,d="";c>b;b++)d+=a[b].value;return d}function ra(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=x++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j,k=[w,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(j=b[u]||(b[u]={}),i=j[b.uniqueID]||(j[b.uniqueID]={}),(h=i[d])&&h[0]===w&&h[1]===f)return k[2]=h[2];if(i[d]=k,k[2]=a(b,c,g))return!0}}}function sa(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function ta(a,b,c){for(var d=0,e=b.length;e>d;d++)fa(a,b[d],c);return c}function ua(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(c&&!c(f,d,e)||(g.push(f),j&&b.push(h)));return g}function va(a,b,c,d,e,f){return d&&!d[u]&&(d=va(d)),e&&!e[u]&&(e=va(e,f)),ha(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||ta(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:ua(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=ua(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?J(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=ua(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):H.apply(g,r)})}function wa(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=ra(function(a){return a===b},h,!0),l=ra(function(a){return J(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];f>i;i++)if(c=d.relative[a[i].type])m=[ra(sa(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;f>e;e++)if(d.relative[a[e].type])break;return va(i>1&&sa(m),i>1&&qa(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(Q,"$1"),c,e>i&&wa(a.slice(i,e)),f>e&&wa(a=a.slice(e)),f>e&&qa(a))}m.push(c)}return sa(m)}function xa(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,o,q,r=0,s="0",t=f&&[],u=[],v=j,x=f||e&&d.find.TAG("*",k),y=w+=null==v?1:Math.random()||.1,z=x.length;for(k&&(j=g===n||g||k);s!==z&&null!=(l=x[s]);s++){if(e&&l){o=0,g||l.ownerDocument===n||(m(l),h=!p);while(q=a[o++])if(q(l,g||n,h)){i.push(l);break}k&&(w=y)}c&&((l=!q&&l)&&r--,f&&t.push(l))}if(r+=s,c&&s!==r){o=0;while(q=b[o++])q(t,u,g,h);if(f){if(r>0)while(s--)t[s]||u[s]||(u[s]=F.call(i));u=ua(u)}H.apply(i,u),k&&!f&&u.length>0&&r+b.length>1&&fa.uniqueSort(i)}return k&&(w=y,j=v),t};return c?ha(f):f}return h=fa.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=wa(b[c]),f[u]?d.push(f):e.push(f);f=A(a,xa(e,d)),f.selector=a}return f},i=fa.select=function(a,b,e,f){var i,j,k,l,m,n="function"==typeof a&&a,o=!f&&g(a=n.selector||a);if(e=e||[],1===o.length){if(j=o[0]=o[0].slice(0),j.length>2&&"ID"===(k=j[0]).type&&c.getById&&9===b.nodeType&&p&&d.relative[j[1].type]){if(b=(d.find.ID(k.matches[0].replace(ba,ca),b)||[])[0],!b)return e;n&&(b=b.parentNode),a=a.slice(j.shift().value.length)}i=W.needsContext.test(a)?0:j.length;while(i--){if(k=j[i],d.relative[l=k.type])break;if((m=d.find[l])&&(f=m(k.matches[0].replace(ba,ca),_.test(j[0].type)&&oa(b.parentNode)||b))){if(j.splice(i,1),a=f.length&&qa(j),!a)return H.apply(e,f),e;break}}}return(n||h(a,o))(f,b,!p,e,!b||_.test(a)&&oa(b.parentNode)||b),e},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ia(function(a){return 1&a.compareDocumentPosition(n.createElement("div"))}),ia(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ja("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ia(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ja("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),ia(function(a){return null==a.getAttribute("disabled")})||ja(K,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),fa}(a);n.find=t,n.expr=t.selectors,n.expr[":"]=n.expr.pseudos,n.uniqueSort=n.unique=t.uniqueSort,n.text=t.getText,n.isXMLDoc=t.isXML,n.contains=t.contains;var u=function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&n(a).is(c))break;d.push(a)}return d},v=function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c},w=n.expr.match.needsContext,x=/^<([\w-]+)\s*\/?>(?:<\/\1>|)$/,y=/^.[^:#\[\.,]*$/;function z(a,b,c){if(n.isFunction(b))return n.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return n.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(y.test(b))return n.filter(b,a,c);b=n.filter(b,a)}return n.grep(a,function(a){return n.inArray(a,b)>-1!==c})}n.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?n.find.matchesSelector(d,a)?[d]:[]:n.find.matches(a,n.grep(b,function(a){return 1===a.nodeType}))},n.fn.extend({find:function(a){var b,c=[],d=this,e=d.length;if("string"!=typeof a)return this.pushStack(n(a).filter(function(){for(b=0;e>b;b++)if(n.contains(d[b],this))return!0}));for(b=0;e>b;b++)n.find(a,d[b],c);return c=this.pushStack(e>1?n.unique(c):c),c.selector=this.selector?this.selector+" "+a:a,c},filter:function(a){return this.pushStack(z(this,a||[],!1))},not:function(a){return this.pushStack(z(this,a||[],!0))},is:function(a){return!!z(this,"string"==typeof a&&w.test(a)?n(a):a||[],!1).length}});var A,B=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,C=n.fn.init=function(a,b,c){var e,f;if(!a)return this;if(c=c||A,"string"==typeof a){if(e="<"===a.charAt(0)&&">"===a.charAt(a.length-1)&&a.length>=3?[null,a,null]:B.exec(a),!e||!e[1]&&b)return!b||b.jquery?(b||c).find(a):this.constructor(b).find(a);if(e[1]){if(b=b instanceof n?b[0]:b,n.merge(this,n.parseHTML(e[1],b&&b.nodeType?b.ownerDocument||b:d,!0)),x.test(e[1])&&n.isPlainObject(b))for(e in b)n.isFunction(this[e])?this[e](b[e]):this.attr(e,b[e]);return this}if(f=d.getElementById(e[2]),f&&f.parentNode){if(f.id!==e[2])return A.find(a);this.length=1,this[0]=f}return this.context=d,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):n.isFunction(a)?"undefined"!=typeof c.ready?c.ready(a):a(n):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),n.makeArray(a,this))};C.prototype=n.fn,A=n(d);var D=/^(?:parents|prev(?:Until|All))/,E={children:!0,contents:!0,next:!0,prev:!0};n.fn.extend({has:function(a){var b,c=n(a,this),d=c.length;return this.filter(function(){for(b=0;d>b;b++)if(n.contains(this,c[b]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=w.test(a)||"string"!=typeof a?n(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&n.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?n.uniqueSort(f):f)},index:function(a){return a?"string"==typeof a?n.inArray(this[0],n(a)):n.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(n.uniqueSort(n.merge(this.get(),n(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function F(a,b){do a=a[b];while(a&&1!==a.nodeType);return a}n.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return u(a,"parentNode")},parentsUntil:function(a,b,c){return u(a,"parentNode",c)},next:function(a){return F(a,"nextSibling")},prev:function(a){return F(a,"previousSibling")},nextAll:function(a){return u(a,"nextSibling")},prevAll:function(a){return u(a,"previousSibling")},nextUntil:function(a,b,c){return u(a,"nextSibling",c)},prevUntil:function(a,b,c){return u(a,"previousSibling",c)},siblings:function(a){return v((a.parentNode||{}).firstChild,a)},children:function(a){return v(a.firstChild)},contents:function(a){return n.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:n.merge([],a.childNodes)}},function(a,b){n.fn[a]=function(c,d){var e=n.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=n.filter(d,e)),this.length>1&&(E[a]||(e=n.uniqueSort(e)),D.test(a)&&(e=e.reverse())),this.pushStack(e)}});var G=/\S+/g;function H(a){var b={};return n.each(a.match(G)||[],function(a,c){b[c]=!0}),b}n.Callbacks=function(a){a="string"==typeof a?H(a):n.extend({},a);var b,c,d,e,f=[],g=[],h=-1,i=function(){for(e=a.once,d=b=!0;g.length;h=-1){c=g.shift();while(++h<f.length)f[h].apply(c[0],c[1])===!1&&a.stopOnFalse&&(h=f.length,c=!1)}a.memory||(c=!1),b=!1,e&&(f=c?[]:"")},j={add:function(){return f&&(c&&!b&&(h=f.length-1,g.push(c)),function d(b){n.each(b,function(b,c){n.isFunction(c)?a.unique&&j.has(c)||f.push(c):c&&c.length&&"string"!==n.type(c)&&d(c)})}(arguments),c&&!b&&i()),this},remove:function(){return n.each(arguments,function(a,b){var c;while((c=n.inArray(b,f,c))>-1)f.splice(c,1),h>=c&&h--}),this},has:function(a){return a?n.inArray(a,f)>-1:f.length>0},empty:function(){return f&&(f=[]),this},disable:function(){return e=g=[],f=c="",this},disabled:function(){return!f},lock:function(){return e=!0,c||j.disable(),this},locked:function(){return!!e},fireWith:function(a,c){return e||(c=c||[],c=[a,c.slice?c.slice():c],g.push(c),b||i()),this},fire:function(){return j.fireWith(this,arguments),this},fired:function(){return!!d}};return j},n.extend({Deferred:function(a){var b=[["resolve","done",n.Callbacks("once memory"),"resolved"],["reject","fail",n.Callbacks("once memory"),"rejected"],["notify","progress",n.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return n.Deferred(function(c){n.each(b,function(b,f){var g=n.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&n.isFunction(a.promise)?a.promise().progress(c.notify).done(c.resolve).fail(c.reject):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?n.extend(a,d):d}},e={};return d.pipe=d.then,n.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=e.call(arguments),d=c.length,f=1!==d||a&&n.isFunction(a.promise)?d:0,g=1===f?a:n.Deferred(),h=function(a,b,c){return function(d){b[a]=this,c[a]=arguments.length>1?e.call(arguments):d,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(d>1)for(i=new Array(d),j=new Array(d),k=new Array(d);d>b;b++)c[b]&&n.isFunction(c[b].promise)?c[b].promise().progress(h(b,j,i)).done(h(b,k,c)).fail(g.reject):--f;return f||g.resolveWith(k,c),g.promise()}});var I;n.fn.ready=function(a){return n.ready.promise().done(a),this},n.extend({isReady:!1,readyWait:1,holdReady:function(a){a?n.readyWait++:n.ready(!0)},ready:function(a){(a===!0?--n.readyWait:n.isReady)||(n.isReady=!0,a!==!0&&--n.readyWait>0||(I.resolveWith(d,[n]),n.fn.triggerHandler&&(n(d).triggerHandler("ready"),n(d).off("ready"))))}});function J(){d.addEventListener?(d.removeEventListener("DOMContentLoaded",K),a.removeEventListener("load",K)):(d.detachEvent("onreadystatechange",K),a.detachEvent("onload",K))}function K(){(d.addEventListener||"load"===a.event.type||"complete"===d.readyState)&&(J(),n.ready())}n.ready.promise=function(b){if(!I)if(I=n.Deferred(),"complete"===d.readyState||"loading"!==d.readyState&&!d.documentElement.doScroll)a.setTimeout(n.ready);else if(d.addEventListener)d.addEventListener("DOMContentLoaded",K),a.addEventListener("load",K);else{d.attachEvent("onreadystatechange",K),a.attachEvent("onload",K);var c=!1;try{c=null==a.frameElement&&d.documentElement}catch(e){}c&&c.doScroll&&!function f(){if(!n.isReady){try{c.doScroll("left")}catch(b){return a.setTimeout(f,50)}J(),n.ready()}}()}return I.promise(b)},n.ready.promise();var L;for(L in n(l))break;l.ownFirst="0"===L,l.inlineBlockNeedsLayout=!1,n(function(){var a,b,c,e;c=d.getElementsByTagName("body")[0],c&&c.style&&(b=d.createElement("div"),e=d.createElement("div"),e.style.cssText="position:absolute;border:0;width:0;height:0;top:0;left:-9999px",c.appendChild(e).appendChild(b),"undefined"!=typeof b.style.zoom&&(b.style.cssText="display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1",l.inlineBlockNeedsLayout=a=3===b.offsetWidth,a&&(c.style.zoom=1)),c.removeChild(e))}),function(){var a=d.createElement("div");l.deleteExpando=!0;try{delete a.test}catch(b){l.deleteExpando=!1}a=null}();var M=function(a){var b=n.noData[(a.nodeName+" ").toLowerCase()],c=+a.nodeType||1;return 1!==c&&9!==c?!1:!b||b!==!0&&a.getAttribute("classid")===b},N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){if(void 0===c&&1===a.nodeType){var d="data-"+b.replace(O,"-$1").toLowerCase();if(c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?n.parseJSON(c):c}catch(e){}n.data(a,b,c)}else c=void 0;
+}return c}function Q(a){var b;for(b in a)if(("data"!==b||!n.isEmptyObject(a[b]))&&"toJSON"!==b)return!1;return!0}function R(a,b,d,e){if(M(a)){var f,g,h=n.expando,i=a.nodeType,j=i?n.cache:a,k=i?a[h]:a[h]&&h;if(k&&j[k]&&(e||j[k].data)||void 0!==d||"string"!=typeof b)return k||(k=i?a[h]=c.pop()||n.guid++:h),j[k]||(j[k]=i?{}:{toJSON:n.noop}),"object"!=typeof b&&"function"!=typeof b||(e?j[k]=n.extend(j[k],b):j[k].data=n.extend(j[k].data,b)),g=j[k],e||(g.data||(g.data={}),g=g.data),void 0!==d&&(g[n.camelCase(b)]=d),"string"==typeof b?(f=g[b],null==f&&(f=g[n.camelCase(b)])):f=g,f}}function S(a,b,c){if(M(a)){var d,e,f=a.nodeType,g=f?n.cache:a,h=f?a[n.expando]:n.expando;if(g[h]){if(b&&(d=c?g[h]:g[h].data)){n.isArray(b)?b=b.concat(n.map(b,n.camelCase)):b in d?b=[b]:(b=n.camelCase(b),b=b in d?[b]:b.split(" ")),e=b.length;while(e--)delete d[b[e]];if(c?!Q(d):!n.isEmptyObject(d))return}(c||(delete g[h].data,Q(g[h])))&&(f?n.cleanData([a],!0):l.deleteExpando||g!=g.window?delete g[h]:g[h]=void 0)}}}n.extend({cache:{},noData:{"applet ":!0,"embed ":!0,"object ":"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"},hasData:function(a){return a=a.nodeType?n.cache[a[n.expando]]:a[n.expando],!!a&&!Q(a)},data:function(a,b,c){return R(a,b,c)},removeData:function(a,b){return S(a,b)},_data:function(a,b,c){return R(a,b,c,!0)},_removeData:function(a,b){return S(a,b,!0)}}),n.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=n.data(f),1===f.nodeType&&!n._data(f,"parsedAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=n.camelCase(d.slice(5)),P(f,d,e[d])));n._data(f,"parsedAttrs",!0)}return e}return"object"==typeof a?this.each(function(){n.data(this,a)}):arguments.length>1?this.each(function(){n.data(this,a,b)}):f?P(f,a,n.data(f,a)):void 0},removeData:function(a){return this.each(function(){n.removeData(this,a)})}}),n.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=n._data(a,b),c&&(!d||n.isArray(c)?d=n._data(a,b,n.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=n.queue(a,b),d=c.length,e=c.shift(),f=n._queueHooks(a,b),g=function(){n.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return n._data(a,c)||n._data(a,c,{empty:n.Callbacks("once memory").add(function(){n._removeData(a,b+"queue"),n._removeData(a,c)})})}}),n.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?n.queue(this[0],a):void 0===b?this:this.each(function(){var c=n.queue(this,a,b);n._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&n.dequeue(this,a)})},dequeue:function(a){return this.each(function(){n.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=n.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=n._data(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}}),function(){var a;l.shrinkWrapBlocks=function(){if(null!=a)return a;a=!1;var b,c,e;return c=d.getElementsByTagName("body")[0],c&&c.style?(b=d.createElement("div"),e=d.createElement("div"),e.style.cssText="position:absolute;border:0;width:0;height:0;top:0;left:-9999px",c.appendChild(e).appendChild(b),"undefined"!=typeof b.style.zoom&&(b.style.cssText="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:1px;width:1px;zoom:1",b.appendChild(d.createElement("div")).style.width="5px",a=3!==b.offsetWidth),c.removeChild(e),a):void 0}}();var T=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,U=new RegExp("^(?:([+-])=|)("+T+")([a-z%]*)$","i"),V=["Top","Right","Bottom","Left"],W=function(a,b){return a=b||a,"none"===n.css(a,"display")||!n.contains(a.ownerDocument,a)};function X(a,b,c,d){var e,f=1,g=20,h=d?function(){return d.cur()}:function(){return n.css(a,b,"")},i=h(),j=c&&c[3]||(n.cssNumber[b]?"":"px"),k=(n.cssNumber[b]||"px"!==j&&+i)&&U.exec(n.css(a,b));if(k&&k[3]!==j){j=j||k[3],c=c||[],k=+i||1;do f=f||".5",k/=f,n.style(a,b,k+j);while(f!==(f=h()/i)&&1!==f&&--g)}return c&&(k=+k||+i||0,e=c[1]?k+(c[1]+1)*c[2]:+c[2],d&&(d.unit=j,d.start=k,d.end=e)),e}var Y=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===n.type(c)){e=!0;for(h in c)Y(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,n.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(n(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},Z=/^(?:checkbox|radio)$/i,$=/<([\w:-]+)/,_=/^$|\/(?:java|ecma)script/i,aa=/^\s+/,ba="abbr|article|aside|audio|bdi|canvas|data|datalist|details|dialog|figcaption|figure|footer|header|hgroup|main|mark|meter|nav|output|picture|progress|section|summary|template|time|video";function ca(a){var b=ba.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}!function(){var a=d.createElement("div"),b=d.createDocumentFragment(),c=d.createElement("input");a.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",l.leadingWhitespace=3===a.firstChild.nodeType,l.tbody=!a.getElementsByTagName("tbody").length,l.htmlSerialize=!!a.getElementsByTagName("link").length,l.html5Clone="<:nav></:nav>"!==d.createElement("nav").cloneNode(!0).outerHTML,c.type="checkbox",c.checked=!0,b.appendChild(c),l.appendChecked=c.checked,a.innerHTML="<textarea>x</textarea>",l.noCloneChecked=!!a.cloneNode(!0).lastChild.defaultValue,b.appendChild(a),c=d.createElement("input"),c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),a.appendChild(c),l.checkClone=a.cloneNode(!0).cloneNode(!0).lastChild.checked,l.noCloneEvent=!!a.addEventListener,a[n.expando]=1,l.attributes=!a.getAttribute(n.expando)}();var da={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],area:[1,"<map>","</map>"],param:[1,"<object>","</object>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:l.htmlSerialize?[0,"",""]:[1,"X<div>","</div>"]};da.optgroup=da.option,da.tbody=da.tfoot=da.colgroup=da.caption=da.thead,da.th=da.td;function ea(a,b){var c,d,e=0,f="undefined"!=typeof a.getElementsByTagName?a.getElementsByTagName(b||"*"):"undefined"!=typeof a.querySelectorAll?a.querySelectorAll(b||"*"):void 0;if(!f)for(f=[],c=a.childNodes||a;null!=(d=c[e]);e++)!b||n.nodeName(d,b)?f.push(d):n.merge(f,ea(d,b));return void 0===b||b&&n.nodeName(a,b)?n.merge([a],f):f}function fa(a,b){for(var c,d=0;null!=(c=a[d]);d++)n._data(c,"globalEval",!b||n._data(b[d],"globalEval"))}var ga=/<|&#?\w+;/,ha=/<tbody/i;function ia(a){Z.test(a.type)&&(a.defaultChecked=a.checked)}function ja(a,b,c,d,e){for(var f,g,h,i,j,k,m,o=a.length,p=ca(b),q=[],r=0;o>r;r++)if(g=a[r],g||0===g)if("object"===n.type(g))n.merge(q,g.nodeType?[g]:g);else if(ga.test(g)){i=i||p.appendChild(b.createElement("div")),j=($.exec(g)||["",""])[1].toLowerCase(),m=da[j]||da._default,i.innerHTML=m[1]+n.htmlPrefilter(g)+m[2],f=m[0];while(f--)i=i.lastChild;if(!l.leadingWhitespace&&aa.test(g)&&q.push(b.createTextNode(aa.exec(g)[0])),!l.tbody){g="table"!==j||ha.test(g)?"<table>"!==m[1]||ha.test(g)?0:i:i.firstChild,f=g&&g.childNodes.length;while(f--)n.nodeName(k=g.childNodes[f],"tbody")&&!k.childNodes.length&&g.removeChild(k)}n.merge(q,i.childNodes),i.textContent="";while(i.firstChild)i.removeChild(i.firstChild);i=p.lastChild}else q.push(b.createTextNode(g));i&&p.removeChild(i),l.appendChecked||n.grep(ea(q,"input"),ia),r=0;while(g=q[r++])if(d&&n.inArray(g,d)>-1)e&&e.push(g);else if(h=n.contains(g.ownerDocument,g),i=ea(p.appendChild(g),"script"),h&&fa(i),c){f=0;while(g=i[f++])_.test(g.type||"")&&c.push(g)}return i=null,p}!function(){var b,c,e=d.createElement("div");for(b in{submit:!0,change:!0,focusin:!0})c="on"+b,(l[b]=c in a)||(e.setAttribute(c,"t"),l[b]=e.attributes[c].expando===!1);e=null}();var ka=/^(?:input|select|textarea)$/i,la=/^key/,ma=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,na=/^(?:focusinfocus|focusoutblur)$/,oa=/^([^.]*)(?:\.(.+)|)/;function pa(){return!0}function qa(){return!1}function ra(){try{return d.activeElement}catch(a){}}function sa(a,b,c,d,e,f){var g,h;if("object"==typeof b){"string"!=typeof c&&(d=d||c,c=void 0);for(h in b)sa(a,h,c,d,b[h],f);return a}if(null==d&&null==e?(e=c,d=c=void 0):null==e&&("string"==typeof c?(e=d,d=void 0):(e=d,d=c,c=void 0)),e===!1)e=qa;else if(!e)return a;return 1===f&&(g=e,e=function(a){return n().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=n.guid++)),a.each(function(){n.event.add(this,b,e,d,c)})}n.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n._data(a);if(r){c.handler&&(i=c,c=i.handler,e=i.selector),c.guid||(c.guid=n.guid++),(g=r.events)||(g=r.events={}),(k=r.handle)||(k=r.handle=function(a){return"undefined"==typeof n||a&&n.event.triggered===a.type?void 0:n.event.dispatch.apply(k.elem,arguments)},k.elem=a),b=(b||"").match(G)||[""],h=b.length;while(h--)f=oa.exec(b[h])||[],o=q=f[1],p=(f[2]||"").split(".").sort(),o&&(j=n.event.special[o]||{},o=(e?j.delegateType:j.bindType)||o,j=n.event.special[o]||{},l=n.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&n.expr.match.needsContext.test(e),namespace:p.join(".")},i),(m=g[o])||(m=g[o]=[],m.delegateCount=0,j.setup&&j.setup.call(a,d,p,k)!==!1||(a.addEventListener?a.addEventListener(o,k,!1):a.attachEvent&&a.attachEvent("on"+o,k))),j.add&&(j.add.call(a,l),l.handler.guid||(l.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,l):m.push(l),n.event.global[o]=!0);a=null}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n.hasData(a)&&n._data(a);if(r&&(k=r.events)){b=(b||"").match(G)||[""],j=b.length;while(j--)if(h=oa.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=n.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,m=k[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),i=f=m.length;while(f--)g=m[f],!e&&q!==g.origType||c&&c.guid!==g.guid||h&&!h.test(g.namespace)||d&&d!==g.selector&&("**"!==d||!g.selector)||(m.splice(f,1),g.selector&&m.delegateCount--,l.remove&&l.remove.call(a,g));i&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||n.removeEvent(a,o,r.handle),delete k[o])}else for(o in k)n.event.remove(a,o+b[j],c,d,!0);n.isEmptyObject(k)&&(delete r.handle,n._removeData(a,"events"))}},trigger:function(b,c,e,f){var g,h,i,j,l,m,o,p=[e||d],q=k.call(b,"type")?b.type:b,r=k.call(b,"namespace")?b.namespace.split("."):[];if(i=m=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!na.test(q+n.event.triggered)&&(q.indexOf(".")>-1&&(r=q.split("."),q=r.shift(),r.sort()),h=q.indexOf(":")<0&&"on"+q,b=b[n.expando]?b:new n.Event(q,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=r.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+r.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?[b]:n.makeArray(c,[b]),l=n.event.special[q]||{},f||!l.trigger||l.trigger.apply(e,c)!==!1)){if(!f&&!l.noBubble&&!n.isWindow(e)){for(j=l.delegateType||q,na.test(j+q)||(i=i.parentNode);i;i=i.parentNode)p.push(i),m=i;m===(e.ownerDocument||d)&&p.push(m.defaultView||m.parentWindow||a)}o=0;while((i=p[o++])&&!b.isPropagationStopped())b.type=o>1?j:l.bindType||q,g=(n._data(i,"events")||{})[b.type]&&n._data(i,"handle"),g&&g.apply(i,c),g=h&&i[h],g&&g.apply&&M(i)&&(b.result=g.apply(i,c),b.result===!1&&b.preventDefault());if(b.type=q,!f&&!b.isDefaultPrevented()&&(!l._default||l._default.apply(p.pop(),c)===!1)&&M(e)&&h&&e[q]&&!n.isWindow(e)){m=e[h],m&&(e[h]=null),n.event.triggered=q;try{e[q]()}catch(s){}n.event.triggered=void 0,m&&(e[h]=m)}return b.result}},dispatch:function(a){a=n.event.fix(a);var b,c,d,f,g,h=[],i=e.call(arguments),j=(n._data(this,"events")||{})[a.type]||[],k=n.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=n.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,c=0;while((g=f.handlers[c++])&&!a.isImmediatePropagationStopped())a.rnamespace&&!a.rnamespace.test(g.namespace)||(a.handleObj=g,a.data=g.data,d=((n.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==d&&(a.result=d)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&("click"!==a.type||isNaN(a.button)||a.button<1))for(;i!=this;i=i.parentNode||this)if(1===i.nodeType&&(i.disabled!==!0||"click"!==a.type)){for(d=[],c=0;h>c;c++)f=b[c],e=f.selector+" ",void 0===d[e]&&(d[e]=f.needsContext?n(e,this).index(i)>-1:n.find(e,this,null,[i]).length),d[e]&&d.push(f);d.length&&g.push({elem:i,handlers:d})}return h<b.length&&g.push({elem:this,handlers:b.slice(h)}),g},fix:function(a){if(a[n.expando])return a;var b,c,e,f=a.type,g=a,h=this.fixHooks[f];h||(this.fixHooks[f]=h=ma.test(f)?this.mouseHooks:la.test(f)?this.keyHooks:{}),e=h.props?this.props.concat(h.props):this.props,a=new n.Event(g),b=e.length;while(b--)c=e[b],a[c]=g[c];return a.target||(a.target=g.srcElement||d),3===a.target.nodeType&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,h.filter?h.filter(a,g):a},props:"altKey bubbles cancelable ctrlKey currentTarget detail eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return null==a.which&&(a.which=null!=b.charCode?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,b){var c,e,f,g=b.button,h=b.fromElement;return null==a.pageX&&null!=b.clientX&&(e=a.target.ownerDocument||d,f=e.documentElement,c=e.body,a.pageX=b.clientX+(f&&f.scrollLeft||c&&c.scrollLeft||0)-(f&&f.clientLeft||c&&c.clientLeft||0),a.pageY=b.clientY+(f&&f.scrollTop||c&&c.scrollTop||0)-(f&&f.clientTop||c&&c.clientTop||0)),!a.relatedTarget&&h&&(a.relatedTarget=h===a.target?b.toElement:h),a.which||void 0===g||(a.which=1&g?1:2&g?3:4&g?2:0),a}},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==ra()&&this.focus)try{return this.focus(),!1}catch(a){}},delegateType:"focusin"},blur:{trigger:function(){return this===ra()&&this.blur?(this.blur(),!1):void 0},delegateType:"focusout"},click:{trigger:function(){return n.nodeName(this,"input")&&"checkbox"===this.type&&this.click?(this.click(),!1):void 0},_default:function(a){return n.nodeName(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}},simulate:function(a,b,c){var d=n.extend(new n.Event,c,{type:a,isSimulated:!0});n.event.trigger(d,null,b),d.isDefaultPrevented()&&c.preventDefault()}},n.removeEvent=d.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c)}:function(a,b,c){var d="on"+b;a.detachEvent&&("undefined"==typeof a[d]&&(a[d]=null),a.detachEvent(d,c))},n.Event=function(a,b){return this instanceof n.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?pa:qa):this.type=a,b&&n.extend(this,b),this.timeStamp=a&&a.timeStamp||n.now(),void(this[n.expando]=!0)):new n.Event(a,b)},n.Event.prototype={constructor:n.Event,isDefaultPrevented:qa,isPropagationStopped:qa,isImmediatePropagationStopped:qa,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=pa,a&&(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=pa,a&&!this.isSimulated&&(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=pa,a&&a.stopImmediatePropagation&&a.stopImmediatePropagation(),this.stopPropagation()}},n.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){n.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return e&&(e===d||n.contains(d,e))||(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),l.submit||(n.event.special.submit={setup:function(){return n.nodeName(this,"form")?!1:void n.event.add(this,"click._submit keypress._submit",function(a){var b=a.target,c=n.nodeName(b,"input")||n.nodeName(b,"button")?n.prop(b,"form"):void 0;c&&!n._data(c,"submit")&&(n.event.add(c,"submit._submit",function(a){a._submitBubble=!0}),n._data(c,"submit",!0))})},postDispatch:function(a){a._submitBubble&&(delete a._submitBubble,this.parentNode&&!a.isTrigger&&n.event.simulate("submit",this.parentNode,a))},teardown:function(){return n.nodeName(this,"form")?!1:void n.event.remove(this,"._submit")}}),l.change||(n.event.special.change={setup:function(){return ka.test(this.nodeName)?("checkbox"!==this.type&&"radio"!==this.type||(n.event.add(this,"propertychange._change",function(a){"checked"===a.originalEvent.propertyName&&(this._justChanged=!0)}),n.event.add(this,"click._change",function(a){this._justChanged&&!a.isTrigger&&(this._justChanged=!1),n.event.simulate("change",this,a)})),!1):void n.event.add(this,"beforeactivate._change",function(a){var b=a.target;ka.test(b.nodeName)&&!n._data(b,"change")&&(n.event.add(b,"change._change",function(a){!this.parentNode||a.isSimulated||a.isTrigger||n.event.simulate("change",this.parentNode,a)}),n._data(b,"change",!0))})},handle:function(a){var b=a.target;return this!==b||a.isSimulated||a.isTrigger||"radio"!==b.type&&"checkbox"!==b.type?a.handleObj.handler.apply(this,arguments):void 0},teardown:function(){return n.event.remove(this,"._change"),!ka.test(this.nodeName)}}),l.focusin||n.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){n.event.simulate(b,a.target,n.event.fix(a))};n.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=n._data(d,b);e||d.addEventListener(a,c,!0),n._data(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=n._data(d,b)-1;e?n._data(d,b,e):(d.removeEventListener(a,c,!0),n._removeData(d,b))}}}),n.fn.extend({on:function(a,b,c,d){return sa(this,a,b,c,d)},one:function(a,b,c,d){return sa(this,a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,n(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return b!==!1&&"function"!=typeof b||(c=b,b=void 0),c===!1&&(c=qa),this.each(function(){n.event.remove(this,a,c,b)})},trigger:function(a,b){return this.each(function(){n.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];return c?n.event.trigger(a,b,c,!0):void 0}});var ta=/ jQuery\d+="(?:null|\d+)"/g,ua=new RegExp("<(?:"+ba+")[\\s/>]","i"),va=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,wa=/<script|<style|<link/i,xa=/checked\s*(?:[^=]|=\s*.checked.)/i,ya=/^true\/(.*)/,za=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,Aa=ca(d),Ba=Aa.appendChild(d.createElement("div"));function Ca(a,b){return n.nodeName(a,"table")&&n.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function Da(a){return a.type=(null!==n.find.attr(a,"type"))+"/"+a.type,a}function Ea(a){var b=ya.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Fa(a,b){if(1===b.nodeType&&n.hasData(a)){var c,d,e,f=n._data(a),g=n._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;e>d;d++)n.event.add(b,c,h[c][d])}g.data&&(g.data=n.extend({},g.data))}}function Ga(a,b){var c,d,e;if(1===b.nodeType){if(c=b.nodeName.toLowerCase(),!l.noCloneEvent&&b[n.expando]){e=n._data(b);for(d in e.events)n.removeEvent(b,d,e.handle);b.removeAttribute(n.expando)}"script"===c&&b.text!==a.text?(Da(b).text=a.text,Ea(b)):"object"===c?(b.parentNode&&(b.outerHTML=a.outerHTML),l.html5Clone&&a.innerHTML&&!n.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):"input"===c&&Z.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):"option"===c?b.defaultSelected=b.selected=a.defaultSelected:"input"!==c&&"textarea"!==c||(b.defaultValue=a.defaultValue)}}function Ha(a,b,c,d){b=f.apply([],b);var e,g,h,i,j,k,m=0,o=a.length,p=o-1,q=b[0],r=n.isFunction(q);if(r||o>1&&"string"==typeof q&&!l.checkClone&&xa.test(q))return a.each(function(e){var f=a.eq(e);r&&(b[0]=q.call(this,e,f.html())),Ha(f,b,c,d)});if(o&&(k=ja(b,a[0].ownerDocument,!1,a,d),e=k.firstChild,1===k.childNodes.length&&(k=e),e||d)){for(i=n.map(ea(k,"script"),Da),h=i.length;o>m;m++)g=k,m!==p&&(g=n.clone(g,!0,!0),h&&n.merge(i,ea(g,"script"))),c.call(a[m],g,m);if(h)for(j=i[i.length-1].ownerDocument,n.map(i,Ea),m=0;h>m;m++)g=i[m],_.test(g.type||"")&&!n._data(g,"globalEval")&&n.contains(j,g)&&(g.src?n._evalUrl&&n._evalUrl(g.src):n.globalEval((g.text||g.textContent||g.innerHTML||"").replace(za,"")));k=e=null}return a}function Ia(a,b,c){for(var d,e=b?n.filter(b,a):a,f=0;null!=(d=e[f]);f++)c||1!==d.nodeType||n.cleanData(ea(d)),d.parentNode&&(c&&n.contains(d.ownerDocument,d)&&fa(ea(d,"script")),d.parentNode.removeChild(d));return a}n.extend({htmlPrefilter:function(a){return a.replace(va,"<$1></$2>")},clone:function(a,b,c){var d,e,f,g,h,i=n.contains(a.ownerDocument,a);if(l.html5Clone||n.isXMLDoc(a)||!ua.test("<"+a.nodeName+">")?f=a.cloneNode(!0):(Ba.innerHTML=a.outerHTML,Ba.removeChild(f=Ba.firstChild)),!(l.noCloneEvent&&l.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||n.isXMLDoc(a)))for(d=ea(f),h=ea(a),g=0;null!=(e=h[g]);++g)d[g]&&Ga(e,d[g]);if(b)if(c)for(h=h||ea(a),d=d||ea(f),g=0;null!=(e=h[g]);g++)Fa(e,d[g]);else Fa(a,f);return d=ea(f,"script"),d.length>0&&fa(d,!i&&ea(a,"script")),d=h=e=null,f},cleanData:function(a,b){for(var d,e,f,g,h=0,i=n.expando,j=n.cache,k=l.attributes,m=n.event.special;null!=(d=a[h]);h++)if((b||M(d))&&(f=d[i],g=f&&j[f])){if(g.events)for(e in g.events)m[e]?n.event.remove(d,e):n.removeEvent(d,e,g.handle);j[f]&&(delete j[f],k||"undefined"==typeof d.removeAttribute?d[i]=void 0:d.removeAttribute(i),c.push(f))}}}),n.fn.extend({domManip:Ha,detach:function(a){return Ia(this,a,!0)},remove:function(a){return Ia(this,a)},text:function(a){return Y(this,function(a){return void 0===a?n.text(this):this.empty().append((this[0]&&this[0].ownerDocument||d).createTextNode(a))},null,a,arguments.length)},append:function(){return Ha(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ca(this,a);b.appendChild(a)}})},prepend:function(){return Ha(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ca(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return Ha(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return Ha(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},empty:function(){for(var a,b=0;null!=(a=this[b]);b++){1===a.nodeType&&n.cleanData(ea(a,!1));while(a.firstChild)a.removeChild(a.firstChild);a.options&&n.nodeName(a,"select")&&(a.options.length=0)}return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return n.clone(this,a,b)})},html:function(a){return Y(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a)return 1===b.nodeType?b.innerHTML.replace(ta,""):void 0;if("string"==typeof a&&!wa.test(a)&&(l.htmlSerialize||!ua.test(a))&&(l.leadingWhitespace||!aa.test(a))&&!da[($.exec(a)||["",""])[1].toLowerCase()]){a=n.htmlPrefilter(a);try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(n.cleanData(ea(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=[];return Ha(this,arguments,function(b){var c=this.parentNode;n.inArray(this,a)<0&&(n.cleanData(ea(this)),c&&c.replaceChild(b,this))},a)}}),n.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){n.fn[a]=function(a){for(var c,d=0,e=[],f=n(a),h=f.length-1;h>=d;d++)c=d===h?this:this.clone(!0),n(f[d])[b](c),g.apply(e,c.get());return this.pushStack(e)}});var Ja,Ka={HTML:"block",BODY:"block"};function La(a,b){var c=n(b.createElement(a)).appendTo(b.body),d=n.css(c[0],"display");return c.detach(),d}function Ma(a){var b=d,c=Ka[a];return c||(c=La(a,b),"none"!==c&&c||(Ja=(Ja||n("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement),b=(Ja[0].contentWindow||Ja[0].contentDocument).document,b.write(),b.close(),c=La(a,b),Ja.detach()),Ka[a]=c),c}var Na=/^margin/,Oa=new RegExp("^("+T+")(?!px)[a-z%]+$","i"),Pa=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e},Qa=d.documentElement;!function(){var b,c,e,f,g,h,i=d.createElement("div"),j=d.createElement("div");if(j.style){j.style.cssText="float:left;opacity:.5",l.opacity="0.5"===j.style.opacity,l.cssFloat=!!j.style.cssFloat,j.style.backgroundClip="content-box",j.cloneNode(!0).style.backgroundClip="",l.clearCloneStyle="content-box"===j.style.backgroundClip,i=d.createElement("div"),i.style.cssText="border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute",j.innerHTML="",i.appendChild(j),l.boxSizing=""===j.style.boxSizing||""===j.style.MozBoxSizing||""===j.style.WebkitBoxSizing,n.extend(l,{reliableHiddenOffsets:function(){return null==b&&k(),f},boxSizingReliable:function(){return null==b&&k(),e},pixelMarginRight:function(){return null==b&&k(),c},pixelPosition:function(){return null==b&&k(),b},reliableMarginRight:function(){return null==b&&k(),g},reliableMarginLeft:function(){return null==b&&k(),h}});function k(){var k,l,m=d.documentElement;m.appendChild(i),j.style.cssText="-webkit-box-sizing:border-box;box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%",b=e=h=!1,c=g=!0,a.getComputedStyle&&(l=a.getComputedStyle(j),b="1%"!==(l||{}).top,h="2px"===(l||{}).marginLeft,e="4px"===(l||{width:"4px"}).width,j.style.marginRight="50%",c="4px"===(l||{marginRight:"4px"}).marginRight,k=j.appendChild(d.createElement("div")),k.style.cssText=j.style.cssText="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:0",k.style.marginRight=k.style.width="0",j.style.width="1px",g=!parseFloat((a.getComputedStyle(k)||{}).marginRight),j.removeChild(k)),j.style.display="none",f=0===j.getClientRects().length,f&&(j.style.display="",j.innerHTML="<table><tr><td></td><td>t</td></tr></table>",j.childNodes[0].style.borderCollapse="separate",k=j.getElementsByTagName("td"),k[0].style.cssText="margin:0;border:0;padding:0;display:none",f=0===k[0].offsetHeight,f&&(k[0].style.display="",k[1].style.display="none",f=0===k[0].offsetHeight)),m.removeChild(i)}}}();var Ra,Sa,Ta=/^(top|right|bottom|left)$/;a.getComputedStyle?(Ra=function(b){var c=b.ownerDocument.defaultView;return c&&c.opener||(c=a),c.getComputedStyle(b)},Sa=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Ra(a),g=c?c.getPropertyValue(b)||c[b]:void 0,""!==g&&void 0!==g||n.contains(a.ownerDocument,a)||(g=n.style(a,b)),c&&!l.pixelMarginRight()&&Oa.test(g)&&Na.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f),void 0===g?g:g+""}):Qa.currentStyle&&(Ra=function(a){return a.currentStyle},Sa=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Ra(a),g=c?c[b]:void 0,null==g&&h&&h[b]&&(g=h[b]),Oa.test(g)&&!Ta.test(b)&&(d=h.left,e=a.runtimeStyle,f=e&&e.left,f&&(e.left=a.currentStyle.left),h.left="fontSize"===b?"1em":g,g=h.pixelLeft+"px",h.left=d,f&&(e.left=f)),void 0===g?g:g+""||"auto"});function Ua(a,b){return{get:function(){return a()?void delete this.get:(this.get=b).apply(this,arguments)}}}var Va=/alpha\([^)]*\)/i,Wa=/opacity\s*=\s*([^)]*)/i,Xa=/^(none|table(?!-c[ea]).+)/,Ya=new RegExp("^("+T+")(.*)$","i"),Za={position:"absolute",visibility:"hidden",display:"block"},$a={letterSpacing:"0",fontWeight:"400"},_a=["Webkit","O","Moz","ms"],ab=d.createElement("div").style;function bb(a){if(a in ab)return a;var b=a.charAt(0).toUpperCase()+a.slice(1),c=_a.length;while(c--)if(a=_a[c]+b,a in ab)return a}function cb(a,b){for(var c,d,e,f=[],g=0,h=a.length;h>g;g++)d=a[g],d.style&&(f[g]=n._data(d,"olddisplay"),c=d.style.display,b?(f[g]||"none"!==c||(d.style.display=""),""===d.style.display&&W(d)&&(f[g]=n._data(d,"olddisplay",Ma(d.nodeName)))):(e=W(d),(c&&"none"!==c||!e)&&n._data(d,"olddisplay",e?c:n.css(d,"display"))));for(g=0;h>g;g++)d=a[g],d.style&&(b&&"none"!==d.style.display&&""!==d.style.display||(d.style.display=b?f[g]||"":"none"));return a}function db(a,b,c){var d=Ya.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function eb(a,b,c,d,e){for(var f=c===(d?"border":"content")?4:"width"===b?1:0,g=0;4>f;f+=2)"margin"===c&&(g+=n.css(a,c+V[f],!0,e)),d?("content"===c&&(g-=n.css(a,"padding"+V[f],!0,e)),"margin"!==c&&(g-=n.css(a,"border"+V[f]+"Width",!0,e))):(g+=n.css(a,"padding"+V[f],!0,e),"padding"!==c&&(g+=n.css(a,"border"+V[f]+"Width",!0,e)));return g}function fb(a,b,c){var d=!0,e="width"===b?a.offsetWidth:a.offsetHeight,f=Ra(a),g=l.boxSizing&&"border-box"===n.css(a,"boxSizing",!1,f);if(0>=e||null==e){if(e=Sa(a,b,f),(0>e||null==e)&&(e=a.style[b]),Oa.test(e))return e;d=g&&(l.boxSizingReliable()||e===a.style[b]),e=parseFloat(e)||0}return e+eb(a,b,c||(g?"border":"content"),d,f)+"px"}n.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Sa(a,"opacity");return""===c?"1":c}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":l.cssFloat?"cssFloat":"styleFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=n.camelCase(b),i=a.style;if(b=n.cssProps[h]||(n.cssProps[h]=bb(h)||h),g=n.cssHooks[b]||n.cssHooks[h],void 0===c)return g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:i[b];if(f=typeof c,"string"===f&&(e=U.exec(c))&&e[1]&&(c=X(a,b,e),f="number"),null!=c&&c===c&&("number"===f&&(c+=e&&e[3]||(n.cssNumber[h]?"":"px")),l.clearCloneStyle||""!==c||0!==b.indexOf("background")||(i[b]="inherit"),!(g&&"set"in g&&void 0===(c=g.set(a,c,d)))))try{i[b]=c}catch(j){}}},css:function(a,b,c,d){var e,f,g,h=n.camelCase(b);return b=n.cssProps[h]||(n.cssProps[h]=bb(h)||h),g=n.cssHooks[b]||n.cssHooks[h],g&&"get"in g&&(f=g.get(a,!0,c)),void 0===f&&(f=Sa(a,b,d)),"normal"===f&&b in $a&&(f=$a[b]),""===c||c?(e=parseFloat(f),c===!0||isFinite(e)?e||0:f):f}}),n.each(["height","width"],function(a,b){n.cssHooks[b]={get:function(a,c,d){return c?Xa.test(n.css(a,"display"))&&0===a.offsetWidth?Pa(a,Za,function(){return fb(a,b,d)}):fb(a,b,d):void 0},set:function(a,c,d){var e=d&&Ra(a);return db(a,c,d?eb(a,b,d,l.boxSizing&&"border-box"===n.css(a,"boxSizing",!1,e),e):0)}}}),l.opacity||(n.cssHooks.opacity={get:function(a,b){return Wa.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=n.isNumeric(b)?"alpha(opacity="+100*b+")":"",f=d&&d.filter||c.filter||"";c.zoom=1,(b>=1||""===b)&&""===n.trim(f.replace(Va,""))&&c.removeAttribute&&(c.removeAttribute("filter"),""===b||d&&!d.filter)||(c.filter=Va.test(f)?f.replace(Va,e):f+" "+e)}}),n.cssHooks.marginRight=Ua(l.reliableMarginRight,function(a,b){return b?Pa(a,{display:"inline-block"},Sa,[a,"marginRight"]):void 0}),n.cssHooks.marginLeft=Ua(l.reliableMarginLeft,function(a,b){return b?(parseFloat(Sa(a,"marginLeft"))||(n.contains(a.ownerDocument,a)?a.getBoundingClientRect().left-Pa(a,{
+marginLeft:0},function(){return a.getBoundingClientRect().left}):0))+"px":void 0}),n.each({margin:"",padding:"",border:"Width"},function(a,b){n.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];4>d;d++)e[a+V[d]+b]=f[d]||f[d-2]||f[0];return e}},Na.test(a)||(n.cssHooks[a+b].set=db)}),n.fn.extend({css:function(a,b){return Y(this,function(a,b,c){var d,e,f={},g=0;if(n.isArray(b)){for(d=Ra(a),e=b.length;e>g;g++)f[b[g]]=n.css(a,b[g],!1,d);return f}return void 0!==c?n.style(a,b,c):n.css(a,b)},a,b,arguments.length>1)},show:function(){return cb(this,!0)},hide:function(){return cb(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){W(this)?n(this).show():n(this).hide()})}});function gb(a,b,c,d,e){return new gb.prototype.init(a,b,c,d,e)}n.Tween=gb,gb.prototype={constructor:gb,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||n.easing._default,this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(n.cssNumber[c]?"":"px")},cur:function(){var a=gb.propHooks[this.prop];return a&&a.get?a.get(this):gb.propHooks._default.get(this)},run:function(a){var b,c=gb.propHooks[this.prop];return this.options.duration?this.pos=b=n.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):gb.propHooks._default.set(this),this}},gb.prototype.init.prototype=gb.prototype,gb.propHooks={_default:{get:function(a){var b;return 1!==a.elem.nodeType||null!=a.elem[a.prop]&&null==a.elem.style[a.prop]?a.elem[a.prop]:(b=n.css(a.elem,a.prop,""),b&&"auto"!==b?b:0)},set:function(a){n.fx.step[a.prop]?n.fx.step[a.prop](a):1!==a.elem.nodeType||null==a.elem.style[n.cssProps[a.prop]]&&!n.cssHooks[a.prop]?a.elem[a.prop]=a.now:n.style(a.elem,a.prop,a.now+a.unit)}}},gb.propHooks.scrollTop=gb.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},n.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2},_default:"swing"},n.fx=gb.prototype.init,n.fx.step={};var hb,ib,jb=/^(?:toggle|show|hide)$/,kb=/queueHooks$/;function lb(){return a.setTimeout(function(){hb=void 0}),hb=n.now()}function mb(a,b){var c,d={height:a},e=0;for(b=b?1:0;4>e;e+=2-b)c=V[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function nb(a,b,c){for(var d,e=(qb.tweeners[b]||[]).concat(qb.tweeners["*"]),f=0,g=e.length;g>f;f++)if(d=e[f].call(c,b,a))return d}function ob(a,b,c){var d,e,f,g,h,i,j,k,m=this,o={},p=a.style,q=a.nodeType&&W(a),r=n._data(a,"fxshow");c.queue||(h=n._queueHooks(a,"fx"),null==h.unqueued&&(h.unqueued=0,i=h.empty.fire,h.empty.fire=function(){h.unqueued||i()}),h.unqueued++,m.always(function(){m.always(function(){h.unqueued--,n.queue(a,"fx").length||h.empty.fire()})})),1===a.nodeType&&("height"in b||"width"in b)&&(c.overflow=[p.overflow,p.overflowX,p.overflowY],j=n.css(a,"display"),k="none"===j?n._data(a,"olddisplay")||Ma(a.nodeName):j,"inline"===k&&"none"===n.css(a,"float")&&(l.inlineBlockNeedsLayout&&"inline"!==Ma(a.nodeName)?p.zoom=1:p.display="inline-block")),c.overflow&&(p.overflow="hidden",l.shrinkWrapBlocks()||m.always(function(){p.overflow=c.overflow[0],p.overflowX=c.overflow[1],p.overflowY=c.overflow[2]}));for(d in b)if(e=b[d],jb.exec(e)){if(delete b[d],f=f||"toggle"===e,e===(q?"hide":"show")){if("show"!==e||!r||void 0===r[d])continue;q=!0}o[d]=r&&r[d]||n.style(a,d)}else j=void 0;if(n.isEmptyObject(o))"inline"===("none"===j?Ma(a.nodeName):j)&&(p.display=j);else{r?"hidden"in r&&(q=r.hidden):r=n._data(a,"fxshow",{}),f&&(r.hidden=!q),q?n(a).show():m.done(function(){n(a).hide()}),m.done(function(){var b;n._removeData(a,"fxshow");for(b in o)n.style(a,b,o[b])});for(d in o)g=nb(q?r[d]:0,d,m),d in r||(r[d]=g.start,q&&(g.end=g.start,g.start="width"===d||"height"===d?1:0))}}function pb(a,b){var c,d,e,f,g;for(c in a)if(d=n.camelCase(c),e=b[d],f=a[c],n.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=n.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function qb(a,b,c){var d,e,f=0,g=qb.prefilters.length,h=n.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=hb||lb(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;i>g;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),1>f&&i?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:n.extend({},b),opts:n.extend(!0,{specialEasing:{},easing:n.easing._default},c),originalProperties:b,originalOptions:c,startTime:hb||lb(),duration:c.duration,tweens:[],createTween:function(b,c){var d=n.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;d>c;c++)j.tweens[c].run(1);return b?(h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j,b])):h.rejectWith(a,[j,b]),this}}),k=j.props;for(pb(k,j.opts.specialEasing);g>f;f++)if(d=qb.prefilters[f].call(j,a,k,j.opts))return n.isFunction(d.stop)&&(n._queueHooks(j.elem,j.opts.queue).stop=n.proxy(d.stop,d)),d;return n.map(k,nb,j),n.isFunction(j.opts.start)&&j.opts.start.call(a,j),n.fx.timer(n.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}n.Animation=n.extend(qb,{tweeners:{"*":[function(a,b){var c=this.createTween(a,b);return X(c.elem,a,U.exec(b),c),c}]},tweener:function(a,b){n.isFunction(a)?(b=a,a=["*"]):a=a.match(G);for(var c,d=0,e=a.length;e>d;d++)c=a[d],qb.tweeners[c]=qb.tweeners[c]||[],qb.tweeners[c].unshift(b)},prefilters:[ob],prefilter:function(a,b){b?qb.prefilters.unshift(a):qb.prefilters.push(a)}}),n.speed=function(a,b,c){var d=a&&"object"==typeof a?n.extend({},a):{complete:c||!c&&b||n.isFunction(a)&&a,duration:a,easing:c&&b||b&&!n.isFunction(b)&&b};return d.duration=n.fx.off?0:"number"==typeof d.duration?d.duration:d.duration in n.fx.speeds?n.fx.speeds[d.duration]:n.fx.speeds._default,null!=d.queue&&d.queue!==!0||(d.queue="fx"),d.old=d.complete,d.complete=function(){n.isFunction(d.old)&&d.old.call(this),d.queue&&n.dequeue(this,d.queue)},d},n.fn.extend({fadeTo:function(a,b,c,d){return this.filter(W).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=n.isEmptyObject(a),f=n.speed(b,c,d),g=function(){var b=qb(this,n.extend({},a),f);(e||n._data(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=n.timers,g=n._data(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&kb.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));!b&&c||n.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=n._data(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=n.timers,g=d?d.length:0;for(c.finish=!0,n.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;g>b;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),n.each(["toggle","show","hide"],function(a,b){var c=n.fn[b];n.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(mb(b,!0),a,d,e)}}),n.each({slideDown:mb("show"),slideUp:mb("hide"),slideToggle:mb("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){n.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),n.timers=[],n.fx.tick=function(){var a,b=n.timers,c=0;for(hb=n.now();c<b.length;c++)a=b[c],a()||b[c]!==a||b.splice(c--,1);b.length||n.fx.stop(),hb=void 0},n.fx.timer=function(a){n.timers.push(a),a()?n.fx.start():n.timers.pop()},n.fx.interval=13,n.fx.start=function(){ib||(ib=a.setInterval(n.fx.tick,n.fx.interval))},n.fx.stop=function(){a.clearInterval(ib),ib=null},n.fx.speeds={slow:600,fast:200,_default:400},n.fn.delay=function(b,c){return b=n.fx?n.fx.speeds[b]||b:b,c=c||"fx",this.queue(c,function(c,d){var e=a.setTimeout(c,b);d.stop=function(){a.clearTimeout(e)}})},function(){var a,b=d.createElement("input"),c=d.createElement("div"),e=d.createElement("select"),f=e.appendChild(d.createElement("option"));c=d.createElement("div"),c.setAttribute("className","t"),c.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=c.getElementsByTagName("a")[0],b.setAttribute("type","checkbox"),c.appendChild(b),a=c.getElementsByTagName("a")[0],a.style.cssText="top:1px",l.getSetAttribute="t"!==c.className,l.style=/top/.test(a.getAttribute("style")),l.hrefNormalized="/a"===a.getAttribute("href"),l.checkOn=!!b.value,l.optSelected=f.selected,l.enctype=!!d.createElement("form").enctype,e.disabled=!0,l.optDisabled=!f.disabled,b=d.createElement("input"),b.setAttribute("value",""),l.input=""===b.getAttribute("value"),b.value="t",b.setAttribute("type","radio"),l.radioValue="t"===b.value}();var rb=/\r/g,sb=/[\x20\t\r\n\f]+/g;n.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=n.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,n(this).val()):a,null==e?e="":"number"==typeof e?e+="":n.isArray(e)&&(e=n.map(e,function(a){return null==a?"":a+""})),b=n.valHooks[this.type]||n.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=n.valHooks[e.type]||n.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(rb,""):null==c?"":c)}}}),n.extend({valHooks:{option:{get:function(a){var b=n.find.attr(a,"value");return null!=b?b:n.trim(n.text(a)).replace(sb," ")}},select:{get:function(a){for(var b,c,d=a.options,e=a.selectedIndex,f="select-one"===a.type||0>e,g=f?null:[],h=f?e+1:d.length,i=0>e?h:f?e:0;h>i;i++)if(c=d[i],(c.selected||i===e)&&(l.optDisabled?!c.disabled:null===c.getAttribute("disabled"))&&(!c.parentNode.disabled||!n.nodeName(c.parentNode,"optgroup"))){if(b=n(c).val(),f)return b;g.push(b)}return g},set:function(a,b){var c,d,e=a.options,f=n.makeArray(b),g=e.length;while(g--)if(d=e[g],n.inArray(n.valHooks.option.get(d),f)>-1)try{d.selected=c=!0}catch(h){d.scrollHeight}else d.selected=!1;return c||(a.selectedIndex=-1),e}}}}),n.each(["radio","checkbox"],function(){n.valHooks[this]={set:function(a,b){return n.isArray(b)?a.checked=n.inArray(n(a).val(),b)>-1:void 0}},l.checkOn||(n.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var tb,ub,vb=n.expr.attrHandle,wb=/^(?:checked|selected)$/i,xb=l.getSetAttribute,yb=l.input;n.fn.extend({attr:function(a,b){return Y(this,n.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){n.removeAttr(this,a)})}}),n.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return"undefined"==typeof a.getAttribute?n.prop(a,b,c):(1===f&&n.isXMLDoc(a)||(b=b.toLowerCase(),e=n.attrHooks[b]||(n.expr.match.bool.test(b)?ub:tb)),void 0!==c?null===c?void n.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d:(d=n.find.attr(a,b),null==d?void 0:d))},attrHooks:{type:{set:function(a,b){if(!l.radioValue&&"radio"===b&&n.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}},removeAttr:function(a,b){var c,d,e=0,f=b&&b.match(G);if(f&&1===a.nodeType)while(c=f[e++])d=n.propFix[c]||c,n.expr.match.bool.test(c)?yb&&xb||!wb.test(c)?a[d]=!1:a[n.camelCase("default-"+c)]=a[d]=!1:n.attr(a,c,""),a.removeAttribute(xb?c:d)}}),ub={set:function(a,b,c){return b===!1?n.removeAttr(a,c):yb&&xb||!wb.test(c)?a.setAttribute(!xb&&n.propFix[c]||c,c):a[n.camelCase("default-"+c)]=a[c]=!0,c}},n.each(n.expr.match.bool.source.match(/\w+/g),function(a,b){var c=vb[b]||n.find.attr;yb&&xb||!wb.test(b)?vb[b]=function(a,b,d){var e,f;return d||(f=vb[b],vb[b]=e,e=null!=c(a,b,d)?b.toLowerCase():null,vb[b]=f),e}:vb[b]=function(a,b,c){return c?void 0:a[n.camelCase("default-"+b)]?b.toLowerCase():null}}),yb&&xb||(n.attrHooks.value={set:function(a,b,c){return n.nodeName(a,"input")?void(a.defaultValue=b):tb&&tb.set(a,b,c)}}),xb||(tb={set:function(a,b,c){var d=a.getAttributeNode(c);return d||a.setAttributeNode(d=a.ownerDocument.createAttribute(c)),d.value=b+="","value"===c||b===a.getAttribute(c)?b:void 0}},vb.id=vb.name=vb.coords=function(a,b,c){var d;return c?void 0:(d=a.getAttributeNode(b))&&""!==d.value?d.value:null},n.valHooks.button={get:function(a,b){var c=a.getAttributeNode(b);return c&&c.specified?c.value:void 0},set:tb.set},n.attrHooks.contenteditable={set:function(a,b,c){tb.set(a,""===b?!1:b,c)}},n.each(["width","height"],function(a,b){n.attrHooks[b]={set:function(a,c){return""===c?(a.setAttribute(b,"auto"),c):void 0}}})),l.style||(n.attrHooks.style={get:function(a){return a.style.cssText||void 0},set:function(a,b){return a.style.cssText=b+""}});var zb=/^(?:input|select|textarea|button|object)$/i,Ab=/^(?:a|area)$/i;n.fn.extend({prop:function(a,b){return Y(this,n.prop,a,b,arguments.length>1)},removeProp:function(a){return a=n.propFix[a]||a,this.each(function(){try{this[a]=void 0,delete this[a]}catch(b){}})}}),n.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&n.isXMLDoc(a)||(b=n.propFix[b]||b,e=n.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=n.find.attr(a,"tabindex");return b?parseInt(b,10):zb.test(a.nodeName)||Ab.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),l.hrefNormalized||n.each(["href","src"],function(a,b){n.propHooks[b]={get:function(a){return a.getAttribute(b,4)}}}),l.optSelected||(n.propHooks.selected={get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),n.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){n.propFix[this.toLowerCase()]=this}),l.enctype||(n.propFix.enctype="encoding");var Bb=/[\t\r\n\f]/g;function Cb(a){return n.attr(a,"class")||""}n.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(n.isFunction(a))return this.each(function(b){n(this).addClass(a.call(this,b,Cb(this)))});if("string"==typeof a&&a){b=a.match(G)||[];while(c=this[i++])if(e=Cb(c),d=1===c.nodeType&&(" "+e+" ").replace(Bb," ")){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=n.trim(d),e!==h&&n.attr(c,"class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(n.isFunction(a))return this.each(function(b){n(this).removeClass(a.call(this,b,Cb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(G)||[];while(c=this[i++])if(e=Cb(c),d=1===c.nodeType&&(" "+e+" ").replace(Bb," ")){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=n.trim(d),e!==h&&n.attr(c,"class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):n.isFunction(a)?this.each(function(c){n(this).toggleClass(a.call(this,c,Cb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=n(this),f=a.match(G)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=Cb(this),b&&n._data(this,"__className__",b),n.attr(this,"class",b||a===!1?"":n._data(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+Cb(c)+" ").replace(Bb," ").indexOf(b)>-1)return!0;return!1}}),n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){n.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),n.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}});var Db=a.location,Eb=n.now(),Fb=/\?/,Gb=/(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;n.parseJSON=function(b){if(a.JSON&&a.JSON.parse)return a.JSON.parse(b+"");var c,d=null,e=n.trim(b+"");return e&&!n.trim(e.replace(Gb,function(a,b,e,f){return c&&b&&(d=0),0===d?a:(c=e||b,d+=!f-!e,"")}))?Function("return "+e)():n.error("Invalid JSON: "+b)},n.parseXML=function(b){var c,d;if(!b||"string"!=typeof b)return null;try{a.DOMParser?(d=new a.DOMParser,c=d.parseFromString(b,"text/xml")):(c=new a.ActiveXObject("Microsoft.XMLDOM"),c.async="false",c.loadXML(b))}catch(e){c=void 0}return c&&c.documentElement&&!c.getElementsByTagName("parsererror").length||n.error("Invalid XML: "+b),c};var Hb=/#.*$/,Ib=/([?&])_=[^&]*/,Jb=/^(.*?):[ \t]*([^\r\n]*)\r?$/gm,Kb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Lb=/^(?:GET|HEAD)$/,Mb=/^\/\//,Nb=/^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,Ob={},Pb={},Qb="*/".concat("*"),Rb=Db.href,Sb=Nb.exec(Rb.toLowerCase())||[];function Tb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(G)||[];if(n.isFunction(c))while(d=f[e++])"+"===d.charAt(0)?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Ub(a,b,c,d){var e={},f=a===Pb;function g(h){var i;return e[h]=!0,n.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Vb(a,b){var c,d,e=n.ajaxSettings.flatOptions||{};for(d in b)void 0!==b[d]&&((e[d]?a:c||(c={}))[d]=b[d]);return c&&n.extend(!0,a,c),a}function Wb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===e&&(e=a.mimeType||b.getResponseHeader("Content-Type"));if(e)for(g in h)if(h[g]&&h[g].test(e)){i.unshift(g);break}if(i[0]in c)f=i[0];else{for(g in c){if(!i[0]||a.converters[g+" "+i[0]]){f=g;break}d||(d=g)}f=f||d}return f?(f!==i[0]&&i.unshift(f),c[f]):void 0}function Xb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}n.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Rb,type:"GET",isLocal:Kb.test(Sb[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Qb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":n.parseJSON,"text xml":n.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Vb(Vb(a,n.ajaxSettings),b):Vb(n.ajaxSettings,a)},ajaxPrefilter:Tb(Ob),ajaxTransport:Tb(Pb),ajax:function(b,c){"object"==typeof b&&(c=b,b=void 0),c=c||{};var d,e,f,g,h,i,j,k,l=n.ajaxSetup({},c),m=l.context||l,o=l.context&&(m.nodeType||m.jquery)?n(m):n.event,p=n.Deferred(),q=n.Callbacks("once memory"),r=l.statusCode||{},s={},t={},u=0,v="canceled",w={readyState:0,getResponseHeader:function(a){var b;if(2===u){if(!k){k={};while(b=Jb.exec(g))k[b[1].toLowerCase()]=b[2]}b=k[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return 2===u?g:null},setRequestHeader:function(a,b){var c=a.toLowerCase();return u||(a=t[c]=t[c]||a,s[a]=b),this},overrideMimeType:function(a){return u||(l.mimeType=a),this},statusCode:function(a){var b;if(a)if(2>u)for(b in a)r[b]=[r[b],a[b]];else w.always(a[w.status]);return this},abort:function(a){var b=a||v;return j&&j.abort(b),y(0,b),this}};if(p.promise(w).complete=q.add,w.success=w.done,w.error=w.fail,l.url=((b||l.url||Rb)+"").replace(Hb,"").replace(Mb,Sb[1]+"//"),l.type=c.method||c.type||l.method||l.type,l.dataTypes=n.trim(l.dataType||"*").toLowerCase().match(G)||[""],null==l.crossDomain&&(d=Nb.exec(l.url.toLowerCase()),l.crossDomain=!(!d||d[1]===Sb[1]&&d[2]===Sb[2]&&(d[3]||("http:"===d[1]?"80":"443"))===(Sb[3]||("http:"===Sb[1]?"80":"443")))),l.data&&l.processData&&"string"!=typeof l.data&&(l.data=n.param(l.data,l.traditional)),Ub(Ob,l,c,w),2===u)return w;i=n.event&&l.global,i&&0===n.active++&&n.event.trigger("ajaxStart"),l.type=l.type.toUpperCase(),l.hasContent=!Lb.test(l.type),f=l.url,l.hasContent||(l.data&&(f=l.url+=(Fb.test(f)?"&":"?")+l.data,delete l.data),l.cache===!1&&(l.url=Ib.test(f)?f.replace(Ib,"$1_="+Eb++):f+(Fb.test(f)?"&":"?")+"_="+Eb++)),l.ifModified&&(n.lastModified[f]&&w.setRequestHeader("If-Modified-Since",n.lastModified[f]),n.etag[f]&&w.setRequestHeader("If-None-Match",n.etag[f])),(l.data&&l.hasContent&&l.contentType!==!1||c.contentType)&&w.setRequestHeader("Content-Type",l.contentType),w.setRequestHeader("Accept",l.dataTypes[0]&&l.accepts[l.dataTypes[0]]?l.accepts[l.dataTypes[0]]+("*"!==l.dataTypes[0]?", "+Qb+"; q=0.01":""):l.accepts["*"]);for(e in l.headers)w.setRequestHeader(e,l.headers[e]);if(l.beforeSend&&(l.beforeSend.call(m,w,l)===!1||2===u))return w.abort();v="abort";for(e in{success:1,error:1,complete:1})w[e](l[e]);if(j=Ub(Pb,l,c,w)){if(w.readyState=1,i&&o.trigger("ajaxSend",[w,l]),2===u)return w;l.async&&l.timeout>0&&(h=a.setTimeout(function(){w.abort("timeout")},l.timeout));try{u=1,j.send(s,y)}catch(x){if(!(2>u))throw x;y(-1,x)}}else y(-1,"No Transport");function y(b,c,d,e){var k,s,t,v,x,y=c;2!==u&&(u=2,h&&a.clearTimeout(h),j=void 0,g=e||"",w.readyState=b>0?4:0,k=b>=200&&300>b||304===b,d&&(v=Wb(l,w,d)),v=Xb(l,v,w,k),k?(l.ifModified&&(x=w.getResponseHeader("Last-Modified"),x&&(n.lastModified[f]=x),x=w.getResponseHeader("etag"),x&&(n.etag[f]=x)),204===b||"HEAD"===l.type?y="nocontent":304===b?y="notmodified":(y=v.state,s=v.data,t=v.error,k=!t)):(t=y,!b&&y||(y="error",0>b&&(b=0))),w.status=b,w.statusText=(c||y)+"",k?p.resolveWith(m,[s,y,w]):p.rejectWith(m,[w,y,t]),w.statusCode(r),r=void 0,i&&o.trigger(k?"ajaxSuccess":"ajaxError",[w,l,k?s:t]),q.fireWith(m,[w,y]),i&&(o.trigger("ajaxComplete",[w,l]),--n.active||n.event.trigger("ajaxStop")))}return w},getJSON:function(a,b,c){return n.get(a,b,c,"json")},getScript:function(a,b){return n.get(a,void 0,b,"script")}}),n.each(["get","post"],function(a,b){n[b]=function(a,c,d,e){return n.isFunction(c)&&(e=e||d,d=c,c=void 0),n.ajax(n.extend({url:a,type:b,dataType:e,data:c,success:d},n.isPlainObject(a)&&a))}}),n._evalUrl=function(a){return n.ajax({url:a,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,"throws":!0})},n.fn.extend({wrapAll:function(a){if(n.isFunction(a))return this.each(function(b){n(this).wrapAll(a.call(this,b))});if(this[0]){var b=n(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&1===a.firstChild.nodeType)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return n.isFunction(a)?this.each(function(b){n(this).wrapInner(a.call(this,b))}):this.each(function(){var b=n(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=n.isFunction(a);return this.each(function(c){n(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){n.nodeName(this,"body")||n(this).replaceWith(this.childNodes)}).end()}});function Yb(a){return a.style&&a.style.display||n.css(a,"display")}function Zb(a){if(!n.contains(a.ownerDocument||d,a))return!0;while(a&&1===a.nodeType){if("none"===Yb(a)||"hidden"===a.type)return!0;a=a.parentNode}return!1}n.expr.filters.hidden=function(a){return l.reliableHiddenOffsets()?a.offsetWidth<=0&&a.offsetHeight<=0&&!a.getClientRects().length:Zb(a)},n.expr.filters.visible=function(a){return!n.expr.filters.hidden(a)};var $b=/%20/g,_b=/\[\]$/,ac=/\r?\n/g,bc=/^(?:submit|button|image|reset|file)$/i,cc=/^(?:input|select|textarea|keygen)/i;function dc(a,b,c,d){var e;if(n.isArray(b))n.each(b,function(b,e){c||_b.test(a)?d(a,e):dc(a+"["+("object"==typeof e&&null!=e?b:"")+"]",e,c,d)});else if(c||"object"!==n.type(b))d(a,b);else for(e in b)dc(a+"["+e+"]",b[e],c,d)}n.param=function(a,b){var c,d=[],e=function(a,b){b=n.isFunction(b)?b():null==b?"":b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};if(void 0===b&&(b=n.ajaxSettings&&n.ajaxSettings.traditional),n.isArray(a)||a.jquery&&!n.isPlainObject(a))n.each(a,function(){e(this.name,this.value)});else for(c in a)dc(c,a[c],b,e);return d.join("&").replace($b,"+")},n.fn.extend({serialize:function(){return n.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=n.prop(this,"elements");return a?n.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!n(this).is(":disabled")&&cc.test(this.nodeName)&&!bc.test(a)&&(this.checked||!Z.test(a))}).map(function(a,b){var c=n(this).val();return null==c?null:n.isArray(c)?n.map(c,function(a){return{name:b.name,value:a.replace(ac,"\r\n")}}):{name:b.name,value:c.replace(ac,"\r\n")}}).get()}}),n.ajaxSettings.xhr=void 0!==a.ActiveXObject?function(){return this.isLocal?ic():d.documentMode>8?hc():/^(get|post|head|put|delete|options)$/i.test(this.type)&&hc()||ic()}:hc;var ec=0,fc={},gc=n.ajaxSettings.xhr();a.attachEvent&&a.attachEvent("onunload",function(){for(var a in fc)fc[a](void 0,!0)}),l.cors=!!gc&&"withCredentials"in gc,gc=l.ajax=!!gc,gc&&n.ajaxTransport(function(b){if(!b.crossDomain||l.cors){var c;return{send:function(d,e){var f,g=b.xhr(),h=++ec;if(g.open(b.type,b.url,b.async,b.username,b.password),b.xhrFields)for(f in b.xhrFields)g[f]=b.xhrFields[f];b.mimeType&&g.overrideMimeType&&g.overrideMimeType(b.mimeType),b.crossDomain||d["X-Requested-With"]||(d["X-Requested-With"]="XMLHttpRequest");for(f in d)void 0!==d[f]&&g.setRequestHeader(f,d[f]+"");g.send(b.hasContent&&b.data||null),c=function(a,d){var f,i,j;if(c&&(d||4===g.readyState))if(delete fc[h],c=void 0,g.onreadystatechange=n.noop,d)4!==g.readyState&&g.abort();else{j={},f=g.status,"string"==typeof g.responseText&&(j.text=g.responseText);try{i=g.statusText}catch(k){i=""}f||!b.isLocal||b.crossDomain?1223===f&&(f=204):f=j.text?200:404}j&&e(f,i,j,g.getAllResponseHeaders())},b.async?4===g.readyState?a.setTimeout(c):g.onreadystatechange=fc[h]=c:c()},abort:function(){c&&c(void 0,!0)}}}});function hc(){try{return new a.XMLHttpRequest}catch(b){}}function ic(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}n.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(a){return n.globalEval(a),a}}}),n.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),n.ajaxTransport("script",function(a){if(a.crossDomain){var b,c=d.head||n("head")[0]||d.documentElement;return{send:function(e,f){b=d.createElement("script"),b.async=!0,a.scriptCharset&&(b.charset=a.scriptCharset),b.src=a.url,b.onload=b.onreadystatechange=function(a,c){(c||!b.readyState||/loaded|complete/.test(b.readyState))&&(b.onload=b.onreadystatechange=null,b.parentNode&&b.parentNode.removeChild(b),b=null,c||f(200,"success"))},c.insertBefore(b,c.firstChild)},abort:function(){b&&b.onload(void 0,!0)}}}});var jc=[],kc=/(=)\?(?=&|$)|\?\?/;n.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=jc.pop()||n.expando+"_"+Eb++;return this[a]=!0,a}}),n.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(kc.test(b.url)?"url":"string"==typeof b.data&&0===(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&kc.test(b.data)&&"data");return h||"jsonp"===b.dataTypes[0]?(e=b.jsonpCallback=n.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(kc,"$1"+e):b.jsonp!==!1&&(b.url+=(Fb.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||n.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){void 0===f?n(a).removeProp(e):a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,jc.push(e)),g&&n.isFunction(f)&&f(g[0]),g=f=void 0}),"script"):void 0}),n.parseHTML=function(a,b,c){if(!a||"string"!=typeof a)return null;"boolean"==typeof b&&(c=b,b=!1),b=b||d;var e=x.exec(a),f=!c&&[];return e?[b.createElement(e[1])]:(e=ja([a],b,f),f&&f.length&&n(f).remove(),n.merge([],e.childNodes))};var lc=n.fn.load;n.fn.load=function(a,b,c){if("string"!=typeof a&&lc)return lc.apply(this,arguments);var d,e,f,g=this,h=a.indexOf(" ");return h>-1&&(d=n.trim(a.slice(h,a.length)),a=a.slice(0,h)),n.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(e="POST"),g.length>0&&n.ajax({url:a,type:e||"GET",dataType:"html",data:b}).done(function(a){f=arguments,g.html(d?n("<div>").append(n.parseHTML(a)).find(d):a)}).always(c&&function(a,b){g.each(function(){c.apply(this,f||[a.responseText,b,a])})}),this},n.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){n.fn[b]=function(a){return this.on(b,a)}}),n.expr.filters.animated=function(a){return n.grep(n.timers,function(b){return a===b.elem}).length};function mc(a){return n.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}n.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=n.css(a,"position"),l=n(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=n.css(a,"top"),i=n.css(a,"left"),j=("absolute"===k||"fixed"===k)&&n.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),n.isFunction(b)&&(b=b.call(a,c,n.extend({},h))),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},n.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){n.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,n.contains(b,e)?("undefined"!=typeof e.getBoundingClientRect&&(d=e.getBoundingClientRect()),c=mc(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===n.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),n.nodeName(a[0],"html")||(c=a.offset()),c.top+=n.css(a[0],"borderTopWidth",!0),c.left+=n.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-n.css(d,"marginTop",!0),left:b.left-c.left-n.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent;while(a&&!n.nodeName(a,"html")&&"static"===n.css(a,"position"))a=a.offsetParent;return a||Qa})}}),n.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);n.fn[a]=function(d){return Y(this,function(a,d,e){var f=mc(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?n(f).scrollLeft():e,c?e:n(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),n.each(["top","left"],function(a,b){n.cssHooks[b]=Ua(l.pixelPosition,function(a,c){return c?(c=Sa(a,b),Oa.test(c)?n(a).position()[b]+"px":c):void 0})}),n.each({Height:"height",Width:"width"},function(a,b){n.each({
+padding:"inner"+a,content:b,"":"outer"+a},function(c,d){n.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return Y(this,function(b,c,d){var e;return n.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?n.css(b,c,g):n.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),n.fn.extend({bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}}),n.fn.size=function(){return this.length},n.fn.andSelf=n.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return n});var nc=a.jQuery,oc=a.$;return n.noConflict=function(b){return a.$===n&&(a.$=oc),b&&a.jQuery===n&&(a.jQuery=nc),n},b||(a.jQuery=a.$=n),n});
diff --git a/bemani/frontend/static/jquery-confirm.css b/bemani/frontend/static/jquery-confirm.css
new file mode 100755
index 0000000..b66d205
--- /dev/null
+++ b/bemani/frontend/static/jquery-confirm.css
@@ -0,0 +1,9 @@
+/*!
+ * jquery-confirm v3.3.4 (http://craftpip.github.io/jquery-confirm/)
+ * Author: boniface pereira
+ * Website: www.craftpip.com
+ * Contact: hey@craftpip.com
+ *
+ * Copyright 2013-2019 jquery-confirm
+ * Licensed under MIT (https://github.com/craftpip/jquery-confirm/blob/master/LICENSE)
+ */@-webkit-keyframes jconfirm-spin{from{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}@keyframes jconfirm-spin{from{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}body[class*=jconfirm-no-scroll-]{overflow:hidden!important}.jconfirm{position:fixed;top:0;left:0;right:0;bottom:0;z-index:99999999;font-family:inherit;overflow:hidden}.jconfirm .jconfirm-bg{position:fixed;top:0;left:0;right:0;bottom:0;-webkit-transition:opacity .4s;transition:opacity .4s}.jconfirm .jconfirm-bg.jconfirm-bg-h{opacity:0!important}.jconfirm .jconfirm-scrollpane{-webkit-perspective:500px;perspective:500px;-webkit-perspective-origin:center;perspective-origin:center;display:table;width:100%;height:100%}.jconfirm .jconfirm-row{display:table-row;width:100%}.jconfirm .jconfirm-cell{display:table-cell;vertical-align:middle}.jconfirm .jconfirm-holder{max-height:100%;padding:50px 0}.jconfirm .jconfirm-box-container{-webkit-transition:-webkit-transform;transition:-webkit-transform;transition:transform;transition:transform,-webkit-transform}.jconfirm .jconfirm-box-container.jconfirm-no-transition{-webkit-transition:none!important;transition:none!important}.jconfirm .jconfirm-box{background:white;border-radius:4px;position:relative;outline:0;padding:15px 15px 0;overflow:hidden;margin-left:auto;margin-right:auto}@-webkit-keyframes type-blue{1%,100%{border-color:#3498db}50%{border-color:#5faee3}}@keyframes type-blue{1%,100%{border-color:#3498db}50%{border-color:#5faee3}}@-webkit-keyframes type-green{1%,100%{border-color:#2ecc71}50%{border-color:#54d98c}}@keyframes type-green{1%,100%{border-color:#2ecc71}50%{border-color:#54d98c}}@-webkit-keyframes type-red{1%,100%{border-color:#e74c3c}50%{border-color:#ed7669}}@keyframes type-red{1%,100%{border-color:#e74c3c}50%{border-color:#ed7669}}@-webkit-keyframes type-orange{1%,100%{border-color:#f1c40f}50%{border-color:#f4d03f}}@keyframes type-orange{1%,100%{border-color:#f1c40f}50%{border-color:#f4d03f}}@-webkit-keyframes type-purple{1%,100%{border-color:#9b59b6}50%{border-color:#b07cc6}}@keyframes type-purple{1%,100%{border-color:#9b59b6}50%{border-color:#b07cc6}}@-webkit-keyframes type-dark{1%,100%{border-color:#34495e}50%{border-color:#46627f}}@keyframes type-dark{1%,100%{border-color:#34495e}50%{border-color:#46627f}}.jconfirm .jconfirm-box.jconfirm-type-animated{-webkit-animation-duration:2s;animation-duration:2s;-webkit-animation-iteration-count:infinite;animation-iteration-count:infinite}.jconfirm .jconfirm-box.jconfirm-type-blue{border-top:solid 7px #3498db;-webkit-animation-name:type-blue;animation-name:type-blue}.jconfirm .jconfirm-box.jconfirm-type-green{border-top:solid 7px #2ecc71;-webkit-animation-name:type-green;animation-name:type-green}.jconfirm .jconfirm-box.jconfirm-type-red{border-top:solid 7px #e74c3c;-webkit-animation-name:type-red;animation-name:type-red}.jconfirm .jconfirm-box.jconfirm-type-orange{border-top:solid 7px #f1c40f;-webkit-animation-name:type-orange;animation-name:type-orange}.jconfirm .jconfirm-box.jconfirm-type-purple{border-top:solid 7px #9b59b6;-webkit-animation-name:type-purple;animation-name:type-purple}.jconfirm .jconfirm-box.jconfirm-type-dark{border-top:solid 7px #34495e;-webkit-animation-name:type-dark;animation-name:type-dark}.jconfirm .jconfirm-box.loading{height:120px}.jconfirm .jconfirm-box.loading:before{content:'';position:absolute;left:0;background:white;right:0;top:0;bottom:0;border-radius:10px;z-index:1}.jconfirm .jconfirm-box.loading:after{opacity:.6;content:'';height:30px;width:30px;border:solid 3px transparent;position:absolute;left:50%;margin-left:-15px;border-radius:50%;-webkit-animation:jconfirm-spin 1s infinite linear;animation:jconfirm-spin 1s infinite linear;border-bottom-color:dodgerblue;top:50%;margin-top:-15px;z-index:2}.jconfirm .jconfirm-box div.jconfirm-closeIcon{height:20px;width:20px;position:absolute;top:10px;right:10px;cursor:pointer;opacity:.6;text-align:center;font-size:27px!important;line-height:14px!important;display:none;z-index:1}.jconfirm .jconfirm-box div.jconfirm-closeIcon:empty{display:none}.jconfirm .jconfirm-box div.jconfirm-closeIcon .fa{font-size:16px}.jconfirm .jconfirm-box div.jconfirm-closeIcon .glyphicon{font-size:16px}.jconfirm .jconfirm-box div.jconfirm-closeIcon .zmdi{font-size:16px}.jconfirm .jconfirm-box div.jconfirm-closeIcon:hover{opacity:1}.jconfirm .jconfirm-box div.jconfirm-title-c{display:block;font-size:22px;line-height:20px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default;padding-bottom:15px}.jconfirm .jconfirm-box div.jconfirm-title-c.jconfirm-hand{cursor:move}.jconfirm .jconfirm-box div.jconfirm-title-c .jconfirm-icon-c{font-size:inherit;display:inline-block;vertical-align:middle}.jconfirm .jconfirm-box div.jconfirm-title-c .jconfirm-icon-c i{vertical-align:middle}.jconfirm .jconfirm-box div.jconfirm-title-c .jconfirm-icon-c:empty{display:none}.jconfirm .jconfirm-box div.jconfirm-title-c .jconfirm-title{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;font-size:inherit;font-family:inherit;display:inline-block;vertical-align:middle}.jconfirm .jconfirm-box div.jconfirm-title-c .jconfirm-title:empty{display:none}.jconfirm .jconfirm-box div.jconfirm-content-pane{margin-bottom:15px;height:auto;-webkit-transition:height .4s ease-in;transition:height .4s ease-in;display:inline-block;width:100%;position:relative;overflow-x:hidden;overflow-y:auto}.jconfirm .jconfirm-box div.jconfirm-content-pane.no-scroll{overflow-y:hidden}.jconfirm .jconfirm-box div.jconfirm-content-pane::-webkit-scrollbar{width:3px}.jconfirm .jconfirm-box div.jconfirm-content-pane::-webkit-scrollbar-track{background:rgba(0,0,0,0.1)}.jconfirm .jconfirm-box div.jconfirm-content-pane::-webkit-scrollbar-thumb{background:#666;border-radius:3px}.jconfirm .jconfirm-box div.jconfirm-content-pane .jconfirm-content{overflow:auto}.jconfirm .jconfirm-box div.jconfirm-content-pane .jconfirm-content img{max-width:100%;height:auto}.jconfirm .jconfirm-box div.jconfirm-content-pane .jconfirm-content:empty{display:none}.jconfirm .jconfirm-box .jconfirm-buttons{padding-bottom:11px}.jconfirm .jconfirm-box .jconfirm-buttons>button{margin-bottom:4px;margin-left:2px;margin-right:2px}.jconfirm .jconfirm-box .jconfirm-buttons button{display:inline-block;padding:6px 12px;font-size:14px;font-weight:400;line-height:1.42857143;text-align:center;white-space:nowrap;vertical-align:middle;-ms-touch-action:manipulation;touch-action:manipulation;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;border-radius:4px;min-height:1em;-webkit-transition:opacity .1s ease,background-color .1s ease,color .1s ease,background .1s ease,-webkit-box-shadow .1s ease;transition:opacity .1s ease,background-color .1s ease,color .1s ease,background .1s ease,-webkit-box-shadow .1s ease;transition:opacity .1s ease,background-color .1s ease,color .1s ease,box-shadow .1s ease,background .1s ease;transition:opacity .1s ease,background-color .1s ease,color .1s ease,box-shadow .1s ease,background .1s ease,-webkit-box-shadow .1s ease;-webkit-tap-highlight-color:transparent;border:0;background-image:none}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-blue{background-color:#3498db;color:#FFF;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-blue:hover{background-color:#2980b9;color:#FFF}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-green{background-color:#2ecc71;color:#FFF;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-green:hover{background-color:#27ae60;color:#FFF}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-red{background-color:#e74c3c;color:#FFF;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-red:hover{background-color:#c0392b;color:#FFF}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-orange{background-color:#f1c40f;color:#FFF;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-orange:hover{background-color:#f39c12;color:#FFF}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-default{background-color:#ecf0f1;color:#000;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-default:hover{background-color:#bdc3c7;color:#000}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-purple{background-color:#9b59b6;color:#FFF;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-purple:hover{background-color:#8e44ad;color:#FFF}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-dark{background-color:#34495e;color:#FFF;text-shadow:none;-webkit-transition:background .2s;transition:background .2s}.jconfirm .jconfirm-box .jconfirm-buttons button.btn-dark:hover{background-color:#2c3e50;color:#FFF}.jconfirm .jconfirm-box.jconfirm-type-red .jconfirm-title-c .jconfirm-icon-c{color:#e74c3c!important}.jconfirm .jconfirm-box.jconfirm-type-blue .jconfirm-title-c .jconfirm-icon-c{color:#3498db!important}.jconfirm .jconfirm-box.jconfirm-type-green .jconfirm-title-c .jconfirm-icon-c{color:#2ecc71!important}.jconfirm .jconfirm-box.jconfirm-type-purple .jconfirm-title-c .jconfirm-icon-c{color:#9b59b6!important}.jconfirm .jconfirm-box.jconfirm-type-orange .jconfirm-title-c .jconfirm-icon-c{color:#f1c40f!important}.jconfirm .jconfirm-box.jconfirm-type-dark .jconfirm-title-c .jconfirm-icon-c{color:#34495e!important}.jconfirm .jconfirm-clear{clear:both}.jconfirm.jconfirm-rtl{direction:rtl}.jconfirm.jconfirm-rtl div.jconfirm-closeIcon{left:5px;right:auto}.jconfirm.jconfirm-white .jconfirm-bg,.jconfirm.jconfirm-light .jconfirm-bg{background-color:#444;opacity:.2}.jconfirm.jconfirm-white .jconfirm-box,.jconfirm.jconfirm-light .jconfirm-box{-webkit-box-shadow:0 2px 6px rgba(0,0,0,0.2);box-shadow:0 2px 6px rgba(0,0,0,0.2);border-radius:5px}.jconfirm.jconfirm-white .jconfirm-box .jconfirm-title-c .jconfirm-icon-c,.jconfirm.jconfirm-light .jconfirm-box .jconfirm-title-c .jconfirm-icon-c{margin-right:8px;margin-left:0}.jconfirm.jconfirm-white .jconfirm-box .jconfirm-buttons,.jconfirm.jconfirm-light .jconfirm-box .jconfirm-buttons{float:right}.jconfirm.jconfirm-white .jconfirm-box .jconfirm-buttons button,.jconfirm.jconfirm-light .jconfirm-box .jconfirm-buttons button{text-transform:uppercase;font-size:14px;font-weight:bold;text-shadow:none}.jconfirm.jconfirm-white .jconfirm-box .jconfirm-buttons button.btn-default,.jconfirm.jconfirm-light .jconfirm-box .jconfirm-buttons button.btn-default{-webkit-box-shadow:none;box-shadow:none;color:#333}.jconfirm.jconfirm-white .jconfirm-box .jconfirm-buttons button.btn-default:hover,.jconfirm.jconfirm-light .jconfirm-box .jconfirm-buttons button.btn-default:hover{background:#ddd}.jconfirm.jconfirm-white.jconfirm-rtl .jconfirm-title-c .jconfirm-icon-c,.jconfirm.jconfirm-light.jconfirm-rtl .jconfirm-title-c .jconfirm-icon-c{margin-left:8px;margin-right:0}.jconfirm.jconfirm-black .jconfirm-bg,.jconfirm.jconfirm-dark .jconfirm-bg{background-color:darkslategray;opacity:.4}.jconfirm.jconfirm-black .jconfirm-box,.jconfirm.jconfirm-dark .jconfirm-box{-webkit-box-shadow:0 2px 6px rgba(0,0,0,0.2);box-shadow:0 2px 6px rgba(0,0,0,0.2);background:#444;border-radius:5px;color:white}.jconfirm.jconfirm-black .jconfirm-box .jconfirm-title-c .jconfirm-icon-c,.jconfirm.jconfirm-dark .jconfirm-box .jconfirm-title-c .jconfirm-icon-c{margin-right:8px;margin-left:0}.jconfirm.jconfirm-black .jconfirm-box .jconfirm-buttons,.jconfirm.jconfirm-dark .jconfirm-box .jconfirm-buttons{float:right}.jconfirm.jconfirm-black .jconfirm-box .jconfirm-buttons button,.jconfirm.jconfirm-dark .jconfirm-box .jconfirm-buttons button{border:0;background-image:none;text-transform:uppercase;font-size:14px;font-weight:bold;text-shadow:none;-webkit-transition:background .1s;transition:background .1s;color:white}.jconfirm.jconfirm-black .jconfirm-box .jconfirm-buttons button.btn-default,.jconfirm.jconfirm-dark .jconfirm-box .jconfirm-buttons button.btn-default{-webkit-box-shadow:none;box-shadow:none;color:#fff;background:0}.jconfirm.jconfirm-black .jconfirm-box .jconfirm-buttons button.btn-default:hover,.jconfirm.jconfirm-dark .jconfirm-box .jconfirm-buttons button.btn-default:hover{background:#666}.jconfirm.jconfirm-black.jconfirm-rtl .jconfirm-title-c .jconfirm-icon-c,.jconfirm.jconfirm-dark.jconfirm-rtl .jconfirm-title-c .jconfirm-icon-c{margin-left:8px;margin-right:0}.jconfirm .jconfirm-box.hilight.jconfirm-hilight-shake{-webkit-animation:shake .82s cubic-bezier(0.36,0.07,0.19,0.97) both;animation:shake .82s cubic-bezier(0.36,0.07,0.19,0.97) both;-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0)}.jconfirm .jconfirm-box.hilight.jconfirm-hilight-glow{-webkit-animation:glow .82s cubic-bezier(0.36,0.07,0.19,0.97) both;animation:glow .82s cubic-bezier(0.36,0.07,0.19,0.97) both;-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0)}@-webkit-keyframes shake{10%,90%{-webkit-transform:translate3d(-2px,0,0);transform:translate3d(-2px,0,0)}20%,80%{-webkit-transform:translate3d(4px,0,0);transform:translate3d(4px,0,0)}30%,50%,70%{-webkit-transform:translate3d(-8px,0,0);transform:translate3d(-8px,0,0)}40%,60%{-webkit-transform:translate3d(8px,0,0);transform:translate3d(8px,0,0)}}@keyframes shake{10%,90%{-webkit-transform:translate3d(-2px,0,0);transform:translate3d(-2px,0,0)}20%,80%{-webkit-transform:translate3d(4px,0,0);transform:translate3d(4px,0,0)}30%,50%,70%{-webkit-transform:translate3d(-8px,0,0);transform:translate3d(-8px,0,0)}40%,60%{-webkit-transform:translate3d(8px,0,0);transform:translate3d(8px,0,0)}}@-webkit-keyframes glow{0%,100%{-webkit-box-shadow:0 0 0 red;box-shadow:0 0 0 red}50%{-webkit-box-shadow:0 0 30px red;box-shadow:0 0 30px red}}@keyframes glow{0%,100%{-webkit-box-shadow:0 0 0 red;box-shadow:0 0 0 red}50%{-webkit-box-shadow:0 0 30px red;box-shadow:0 0 30px red}}.jconfirm{-webkit-perspective:400px;perspective:400px}.jconfirm .jconfirm-box{opacity:1;-webkit-transition-property:all;transition-property:all}.jconfirm .jconfirm-box.jconfirm-animation-top,.jconfirm .jconfirm-box.jconfirm-animation-left,.jconfirm .jconfirm-box.jconfirm-animation-right,.jconfirm .jconfirm-box.jconfirm-animation-bottom,.jconfirm .jconfirm-box.jconfirm-animation-opacity,.jconfirm .jconfirm-box.jconfirm-animation-zoom,.jconfirm .jconfirm-box.jconfirm-animation-scale,.jconfirm .jconfirm-box.jconfirm-animation-none,.jconfirm .jconfirm-box.jconfirm-animation-rotate,.jconfirm .jconfirm-box.jconfirm-animation-rotatex,.jconfirm .jconfirm-box.jconfirm-animation-rotatey,.jconfirm .jconfirm-box.jconfirm-animation-scaley,.jconfirm .jconfirm-box.jconfirm-animation-scalex{opacity:0}.jconfirm .jconfirm-box.jconfirm-animation-rotate{-webkit-transform:rotate(90deg);transform:rotate(90deg)}.jconfirm .jconfirm-box.jconfirm-animation-rotatex{-webkit-transform:rotateX(90deg);transform:rotateX(90deg);-webkit-transform-origin:center;transform-origin:center}.jconfirm .jconfirm-box.jconfirm-animation-rotatexr{-webkit-transform:rotateX(-90deg);transform:rotateX(-90deg);-webkit-transform-origin:center;transform-origin:center}.jconfirm .jconfirm-box.jconfirm-animation-rotatey{-webkit-transform:rotatey(90deg);transform:rotatey(90deg);-webkit-transform-origin:center;transform-origin:center}.jconfirm .jconfirm-box.jconfirm-animation-rotateyr{-webkit-transform:rotatey(-90deg);transform:rotatey(-90deg);-webkit-transform-origin:center;transform-origin:center}.jconfirm .jconfirm-box.jconfirm-animation-scaley{-webkit-transform:scaley(1.5);transform:scaley(1.5);-webkit-transform-origin:center;transform-origin:center}.jconfirm .jconfirm-box.jconfirm-animation-scalex{-webkit-transform:scalex(1.5);transform:scalex(1.5);-webkit-transform-origin:center;transform-origin:center}.jconfirm .jconfirm-box.jconfirm-animation-top{-webkit-transform:translate(0px,-100px);transform:translate(0px,-100px)}.jconfirm .jconfirm-box.jconfirm-animation-left{-webkit-transform:translate(-100px,0px);transform:translate(-100px,0px)}.jconfirm .jconfirm-box.jconfirm-animation-right{-webkit-transform:translate(100px,0px);transform:translate(100px,0px)}.jconfirm .jconfirm-box.jconfirm-animation-bottom{-webkit-transform:translate(0px,100px);transform:translate(0px,100px)}.jconfirm .jconfirm-box.jconfirm-animation-zoom{-webkit-transform:scale(1.2);transform:scale(1.2)}.jconfirm .jconfirm-box.jconfirm-animation-scale{-webkit-transform:scale(0.5);transform:scale(0.5)}.jconfirm .jconfirm-box.jconfirm-animation-none{visibility:hidden}.jconfirm.jconfirm-supervan .jconfirm-bg{background-color:rgba(54,70,93,0.95)}.jconfirm.jconfirm-supervan .jconfirm-box{background-color:transparent}.jconfirm.jconfirm-supervan .jconfirm-box.jconfirm-type-blue{border:0}.jconfirm.jconfirm-supervan .jconfirm-box.jconfirm-type-green{border:0}.jconfirm.jconfirm-supervan .jconfirm-box.jconfirm-type-red{border:0}.jconfirm.jconfirm-supervan .jconfirm-box.jconfirm-type-orange{border:0}.jconfirm.jconfirm-supervan .jconfirm-box.jconfirm-type-purple{border:0}.jconfirm.jconfirm-supervan .jconfirm-box.jconfirm-type-dark{border:0}.jconfirm.jconfirm-supervan .jconfirm-box div.jconfirm-closeIcon{color:white}.jconfirm.jconfirm-supervan .jconfirm-box div.jconfirm-title-c{text-align:center;color:white;font-size:28px;font-weight:normal}.jconfirm.jconfirm-supervan .jconfirm-box div.jconfirm-title-c>*{padding-bottom:25px}.jconfirm.jconfirm-supervan .jconfirm-box div.jconfirm-title-c .jconfirm-icon-c{margin-right:8px;margin-left:0}.jconfirm.jconfirm-supervan .jconfirm-box div.jconfirm-content-pane{margin-bottom:25px}.jconfirm.jconfirm-supervan .jconfirm-box div.jconfirm-content{text-align:center;color:white}.jconfirm.jconfirm-supervan .jconfirm-box .jconfirm-buttons{text-align:center}.jconfirm.jconfirm-supervan .jconfirm-box .jconfirm-buttons button{font-size:16px;border-radius:2px;background:#303f53;text-shadow:none;border:0;color:white;padding:10px;min-width:100px}.jconfirm.jconfirm-supervan.jconfirm-rtl .jconfirm-box div.jconfirm-title-c .jconfirm-icon-c{margin-left:8px;margin-right:0}.jconfirm.jconfirm-material .jconfirm-bg{background-color:rgba(0,0,0,0.67)}.jconfirm.jconfirm-material .jconfirm-box{background-color:white;-webkit-box-shadow:0 7px 8px -4px rgba(0,0,0,0.2),0 13px 19px 2px rgba(0,0,0,0.14),0 5px 24px 4px rgba(0,0,0,0.12);box-shadow:0 7px 8px -4px rgba(0,0,0,0.2),0 13px 19px 2px rgba(0,0,0,0.14),0 5px 24px 4px rgba(0,0,0,0.12);padding:30px 25px 10px 25px}.jconfirm.jconfirm-material .jconfirm-box .jconfirm-title-c .jconfirm-icon-c{margin-right:8px;margin-left:0}.jconfirm.jconfirm-material .jconfirm-box div.jconfirm-closeIcon{color:rgba(0,0,0,0.87)}.jconfirm.jconfirm-material .jconfirm-box div.jconfirm-title-c{color:rgba(0,0,0,0.87);font-size:22px;font-weight:bold}.jconfirm.jconfirm-material .jconfirm-box div.jconfirm-content{color:rgba(0,0,0,0.87)}.jconfirm.jconfirm-material .jconfirm-box .jconfirm-buttons{text-align:right}.jconfirm.jconfirm-material .jconfirm-box .jconfirm-buttons button{text-transform:uppercase;font-weight:500}.jconfirm.jconfirm-material.jconfirm-rtl .jconfirm-title-c .jconfirm-icon-c{margin-left:8px;margin-right:0}.jconfirm.jconfirm-bootstrap .jconfirm-bg{background-color:rgba(0,0,0,0.21)}.jconfirm.jconfirm-bootstrap .jconfirm-box{background-color:white;-webkit-box-shadow:0 3px 8px 0 rgba(0,0,0,0.2);box-shadow:0 3px 8px 0 rgba(0,0,0,0.2);border:solid 1px rgba(0,0,0,0.4);padding:15px 0 0}.jconfirm.jconfirm-bootstrap .jconfirm-box .jconfirm-title-c .jconfirm-icon-c{margin-right:8px;margin-left:0}.jconfirm.jconfirm-bootstrap .jconfirm-box div.jconfirm-closeIcon{color:rgba(0,0,0,0.87)}.jconfirm.jconfirm-bootstrap .jconfirm-box div.jconfirm-title-c{color:rgba(0,0,0,0.87);font-size:22px;font-weight:bold;padding-left:15px;padding-right:15px}.jconfirm.jconfirm-bootstrap .jconfirm-box div.jconfirm-content{color:rgba(0,0,0,0.87);padding:0 15px}.jconfirm.jconfirm-bootstrap .jconfirm-box .jconfirm-buttons{text-align:right;padding:10px;margin:-5px 0 0;border-top:solid 1px #ddd;overflow:hidden;border-radius:0 0 4px 4px}.jconfirm.jconfirm-bootstrap .jconfirm-box .jconfirm-buttons button{font-weight:500}.jconfirm.jconfirm-bootstrap.jconfirm-rtl .jconfirm-title-c .jconfirm-icon-c{margin-left:8px;margin-right:0}.jconfirm.jconfirm-modern .jconfirm-bg{background-color:slategray;opacity:.6}.jconfirm.jconfirm-modern .jconfirm-box{background-color:white;-webkit-box-shadow:0 7px 8px -4px rgba(0,0,0,0.2),0 13px 19px 2px rgba(0,0,0,0.14),0 5px 24px 4px rgba(0,0,0,0.12);box-shadow:0 7px 8px -4px rgba(0,0,0,0.2),0 13px 19px 2px rgba(0,0,0,0.14),0 5px 24px 4px rgba(0,0,0,0.12);padding:30px 30px 15px}.jconfirm.jconfirm-modern .jconfirm-box div.jconfirm-closeIcon{color:rgba(0,0,0,0.87);top:15px;right:15px}.jconfirm.jconfirm-modern .jconfirm-box div.jconfirm-title-c{color:rgba(0,0,0,0.87);font-size:24px;font-weight:bold;text-align:center;margin-bottom:10px}.jconfirm.jconfirm-modern .jconfirm-box div.jconfirm-title-c .jconfirm-icon-c{-webkit-transition:-webkit-transform .5s;transition:-webkit-transform .5s;transition:transform .5s;transition:transform .5s,-webkit-transform .5s;-webkit-transform:scale(0);transform:scale(0);display:block;margin-right:0;margin-left:0;margin-bottom:10px;font-size:69px;color:#aaa}.jconfirm.jconfirm-modern .jconfirm-box div.jconfirm-content{text-align:center;font-size:15px;color:#777;margin-bottom:25px}.jconfirm.jconfirm-modern .jconfirm-box .jconfirm-buttons{text-align:center}.jconfirm.jconfirm-modern .jconfirm-box .jconfirm-buttons button{font-weight:bold;text-transform:uppercase;-webkit-transition:background .1s;transition:background .1s;padding:10px 20px}.jconfirm.jconfirm-modern .jconfirm-box .jconfirm-buttons button+button{margin-left:4px}.jconfirm.jconfirm-modern.jconfirm-open .jconfirm-box .jconfirm-title-c .jconfirm-icon-c{-webkit-transform:scale(1);transform:scale(1)}
\ No newline at end of file
diff --git a/bemani/frontend/static/jquery-confirm.js b/bemani/frontend/static/jquery-confirm.js
new file mode 100755
index 0000000..2939dc6
--- /dev/null
+++ b/bemani/frontend/static/jquery-confirm.js
@@ -0,0 +1,10 @@
+/*!
+ * jquery-confirm v3.3.4 (http://craftpip.github.io/jquery-confirm/)
+ * Author: Boniface Pereira
+ * Website: www.craftpip.com
+ * Contact: hey@craftpip.com
+ *
+ * Copyright 2013-2019 jquery-confirm
+ * Licensed under MIT (https://github.com/craftpip/jquery-confirm/blob/master/LICENSE)
+ */
+(function(factory){if(typeof define==="function"&&define.amd){define(["jquery"],factory);}else{if(typeof module==="object"&&module.exports){module.exports=function(root,jQuery){if(jQuery===undefined){if(typeof window!=="undefined"){jQuery=require("jquery");}else{jQuery=require("jquery")(root);}}factory(jQuery);return jQuery;};}else{factory(jQuery);}}}(function($){var w=window;$.fn.confirm=function(options,option2){if(typeof options==="undefined"){options={};}if(typeof options==="string"){options={content:options,title:(option2)?option2:false};}$(this).each(function(){var $this=$(this);if($this.attr("jc-attached")){console.warn("jConfirm has already been attached to this element ",$this[0]);return;}$this.on("click",function(e){e.preventDefault();var jcOption=$.extend({},options);if($this.attr("data-title")){jcOption.title=$this.attr("data-title");}if($this.attr("data-content")){jcOption.content=$this.attr("data-content");}if(typeof jcOption.buttons==="undefined"){jcOption.buttons={};}jcOption["$target"]=$this;if($this.attr("href")&&Object.keys(jcOption.buttons).length===0){var buttons=$.extend(true,{},w.jconfirm.pluginDefaults.defaultButtons,(w.jconfirm.defaults||{}).defaultButtons||{});var firstBtn=Object.keys(buttons)[0];jcOption.buttons=buttons;jcOption.buttons[firstBtn].action=function(){location.href=$this.attr("href");};}jcOption.closeIcon=false;var instance=$.confirm(jcOption);});$this.attr("jc-attached",true);});return $(this);};$.confirm=function(options,option2){if(typeof options==="undefined"){options={};}if(typeof options==="string"){options={content:options,title:(option2)?option2:false};}var putDefaultButtons=!(options.buttons===false);if(typeof options.buttons!=="object"){options.buttons={};}if(Object.keys(options.buttons).length===0&&putDefaultButtons){var buttons=$.extend(true,{},w.jconfirm.pluginDefaults.defaultButtons,(w.jconfirm.defaults||{}).defaultButtons||{});options.buttons=buttons;}return w.jconfirm(options);};$.alert=function(options,option2){if(typeof options==="undefined"){options={};}if(typeof options==="string"){options={content:options,title:(option2)?option2:false};}var putDefaultButtons=!(options.buttons===false);if(typeof options.buttons!=="object"){options.buttons={};}if(Object.keys(options.buttons).length===0&&putDefaultButtons){var buttons=$.extend(true,{},w.jconfirm.pluginDefaults.defaultButtons,(w.jconfirm.defaults||{}).defaultButtons||{});var firstBtn=Object.keys(buttons)[0];options.buttons[firstBtn]=buttons[firstBtn];}return w.jconfirm(options);};$.dialog=function(options,option2){if(typeof options==="undefined"){options={};}if(typeof options==="string"){options={content:options,title:(option2)?option2:false,closeIcon:function(){}};}options.buttons={};if(typeof options.closeIcon==="undefined"){options.closeIcon=function(){};}options.confirmKeys=[13];return w.jconfirm(options);};w.jconfirm=function(options){if(typeof options==="undefined"){options={};}var pluginOptions=$.extend(true,{},w.jconfirm.pluginDefaults);if(w.jconfirm.defaults){pluginOptions=$.extend(true,pluginOptions,w.jconfirm.defaults);}pluginOptions=$.extend(true,{},pluginOptions,options);var instance=new w.Jconfirm(pluginOptions);w.jconfirm.instances.push(instance);return instance;};w.Jconfirm=function(options){$.extend(this,options);this._init();};w.Jconfirm.prototype={_init:function(){var that=this;if(!w.jconfirm.instances.length){w.jconfirm.lastFocused=$("body").find(":focus");}this._id=Math.round(Math.random()*99999);this.contentParsed=$(document.createElement("div"));if(!this.lazyOpen){setTimeout(function(){that.open();},0);}},_buildHTML:function(){var that=this;this._parseAnimation(this.animation,"o");this._parseAnimation(this.closeAnimation,"c");this._parseBgDismissAnimation(this.backgroundDismissAnimation);this._parseColumnClass(this.columnClass);this._parseTheme(this.theme);this._parseType(this.type);var template=$(this.template);template.find(".jconfirm-box").addClass(this.animationParsed).addClass(this.backgroundDismissAnimationParsed).addClass(this.typeParsed);if(this.typeAnimated){template.find(".jconfirm-box").addClass("jconfirm-type-animated");}if(this.useBootstrap){template.find(".jc-bs3-row").addClass(this.bootstrapClasses.row);template.find(".jc-bs3-row").addClass("justify-content-md-center justify-content-sm-center justify-content-xs-center justify-content-lg-center");template.find(".jconfirm-box-container").addClass(this.columnClassParsed);if(this.containerFluid){template.find(".jc-bs3-container").addClass(this.bootstrapClasses.containerFluid);}else{template.find(".jc-bs3-container").addClass(this.bootstrapClasses.container);}}else{template.find(".jconfirm-box").css("width",this.boxWidth);}if(this.titleClass){template.find(".jconfirm-title-c").addClass(this.titleClass);}template.addClass(this.themeParsed);var ariaLabel="jconfirm-box"+this._id;template.find(".jconfirm-box").attr("aria-labelledby",ariaLabel).attr("tabindex",-1);template.find(".jconfirm-content").attr("id",ariaLabel);if(this.bgOpacity!==null){template.find(".jconfirm-bg").css("opacity",this.bgOpacity);}if(this.rtl){template.addClass("jconfirm-rtl");}this.$el=template.appendTo(this.container);this.$jconfirmBoxContainer=this.$el.find(".jconfirm-box-container");this.$jconfirmBox=this.$body=this.$el.find(".jconfirm-box");this.$jconfirmBg=this.$el.find(".jconfirm-bg");this.$title=this.$el.find(".jconfirm-title");this.$titleContainer=this.$el.find(".jconfirm-title-c");this.$content=this.$el.find("div.jconfirm-content");this.$contentPane=this.$el.find(".jconfirm-content-pane");this.$icon=this.$el.find(".jconfirm-icon-c");this.$closeIcon=this.$el.find(".jconfirm-closeIcon");this.$holder=this.$el.find(".jconfirm-holder");this.$btnc=this.$el.find(".jconfirm-buttons");this.$scrollPane=this.$el.find(".jconfirm-scrollpane");that.setStartingPoint();this._contentReady=$.Deferred();this._modalReady=$.Deferred();this.$holder.css({"padding-top":this.offsetTop,"padding-bottom":this.offsetBottom,});this.setTitle();this.setIcon();this._setButtons();this._parseContent();this.initDraggable();if(this.isAjax){this.showLoading(false);}$.when(this._contentReady,this._modalReady).then(function(){if(that.isAjaxLoading){setTimeout(function(){that.isAjaxLoading=false;that.setContent();that.setTitle();that.setIcon();setTimeout(function(){that.hideLoading(false);that._updateContentMaxHeight();},100);if(typeof that.onContentReady==="function"){that.onContentReady();}},50);}else{that._updateContentMaxHeight();that.setTitle();that.setIcon();if(typeof that.onContentReady==="function"){that.onContentReady();}}if(that.autoClose){that._startCountDown();}}).then(function(){that._watchContent();});if(this.animation==="none"){this.animationSpeed=1;this.animationBounce=1;}this.$body.css(this._getCSS(this.animationSpeed,this.animationBounce));this.$contentPane.css(this._getCSS(this.animationSpeed,1));this.$jconfirmBg.css(this._getCSS(this.animationSpeed,1));this.$jconfirmBoxContainer.css(this._getCSS(this.animationSpeed,1));},_typePrefix:"jconfirm-type-",typeParsed:"",_parseType:function(type){this.typeParsed=this._typePrefix+type;},setType:function(type){var oldClass=this.typeParsed;this._parseType(type);this.$jconfirmBox.removeClass(oldClass).addClass(this.typeParsed);},themeParsed:"",_themePrefix:"jconfirm-",setTheme:function(theme){var previous=this.theme;this.theme=theme||this.theme;this._parseTheme(this.theme);if(previous){this.$el.removeClass(previous);}this.$el.addClass(this.themeParsed);this.theme=theme;},_parseTheme:function(theme){var that=this;theme=theme.split(",");$.each(theme,function(k,a){if(a.indexOf(that._themePrefix)===-1){theme[k]=that._themePrefix+$.trim(a);}});this.themeParsed=theme.join(" ").toLowerCase();},backgroundDismissAnimationParsed:"",_bgDismissPrefix:"jconfirm-hilight-",_parseBgDismissAnimation:function(bgDismissAnimation){var animation=bgDismissAnimation.split(",");var that=this;$.each(animation,function(k,a){if(a.indexOf(that._bgDismissPrefix)===-1){animation[k]=that._bgDismissPrefix+$.trim(a);}});this.backgroundDismissAnimationParsed=animation.join(" ").toLowerCase();},animationParsed:"",closeAnimationParsed:"",_animationPrefix:"jconfirm-animation-",setAnimation:function(animation){this.animation=animation||this.animation;this._parseAnimation(this.animation,"o");},_parseAnimation:function(animation,which){which=which||"o";var animations=animation.split(",");var that=this;$.each(animations,function(k,a){if(a.indexOf(that._animationPrefix)===-1){animations[k]=that._animationPrefix+$.trim(a);}});var a_string=animations.join(" ").toLowerCase();if(which==="o"){this.animationParsed=a_string;}else{this.closeAnimationParsed=a_string;}return a_string;},setCloseAnimation:function(closeAnimation){this.closeAnimation=closeAnimation||this.closeAnimation;this._parseAnimation(this.closeAnimation,"c");},setAnimationSpeed:function(speed){this.animationSpeed=speed||this.animationSpeed;},columnClassParsed:"",setColumnClass:function(colClass){if(!this.useBootstrap){console.warn("cannot set columnClass, useBootstrap is set to false");return;}this.columnClass=colClass||this.columnClass;this._parseColumnClass(this.columnClass);this.$jconfirmBoxContainer.addClass(this.columnClassParsed);},_updateContentMaxHeight:function(){var height=$(window).height()-(this.$jconfirmBox.outerHeight()-this.$contentPane.outerHeight())-(this.offsetTop+this.offsetBottom);this.$contentPane.css({"max-height":height+"px"});},setBoxWidth:function(width){if(this.useBootstrap){console.warn("cannot set boxWidth, useBootstrap is set to true");return;}this.boxWidth=width;this.$jconfirmBox.css("width",width);},_parseColumnClass:function(colClass){colClass=colClass.toLowerCase();var p;switch(colClass){case"xl":case"xlarge":p="col-md-12";break;case"l":case"large":p="col-md-8 col-md-offset-2";break;case"m":case"medium":p="col-md-6 col-md-offset-3";break;case"s":case"small":p="col-md-4 col-md-offset-4";break;case"xs":case"xsmall":p="col-md-2 col-md-offset-5";break;default:p=colClass;}this.columnClassParsed=p;},initDraggable:function(){var that=this;var $t=this.$titleContainer;this.resetDrag();if(this.draggable){$t.on("mousedown",function(e){$t.addClass("jconfirm-hand");that.mouseX=e.clientX;that.mouseY=e.clientY;that.isDrag=true;});$(window).on("mousemove."+this._id,function(e){if(that.isDrag){that.movingX=e.clientX-that.mouseX+that.initialX;that.movingY=e.clientY-that.mouseY+that.initialY;that.setDrag();}});$(window).on("mouseup."+this._id,function(){$t.removeClass("jconfirm-hand");if(that.isDrag){that.isDrag=false;that.initialX=that.movingX;that.initialY=that.movingY;}});}},resetDrag:function(){this.isDrag=false;this.initialX=0;this.initialY=0;this.movingX=0;this.movingY=0;this.mouseX=0;this.mouseY=0;this.$jconfirmBoxContainer.css("transform","translate("+0+"px, "+0+"px)");},setDrag:function(){if(!this.draggable){return;}this.alignMiddle=false;var boxWidth=this.$jconfirmBox.outerWidth();var boxHeight=this.$jconfirmBox.outerHeight();var windowWidth=$(window).width();var windowHeight=$(window).height();var that=this;var dragUpdate=1;if(that.movingX%dragUpdate===0||that.movingY%dragUpdate===0){if(that.dragWindowBorder){var leftDistance=(windowWidth/2)-boxWidth/2;var topDistance=(windowHeight/2)-boxHeight/2;topDistance-=that.dragWindowGap;leftDistance-=that.dragWindowGap;if(leftDistance+that.movingX<0){that.movingX=-leftDistance;}else{if(leftDistance-that.movingX<0){that.movingX=leftDistance;}}if(topDistance+that.movingY<0){that.movingY=-topDistance;}else{if(topDistance-that.movingY<0){that.movingY=topDistance;}}}that.$jconfirmBoxContainer.css("transform","translate("+that.movingX+"px, "+that.movingY+"px)");}},_scrollTop:function(){if(typeof pageYOffset!=="undefined"){return pageYOffset;}else{var B=document.body;var D=document.documentElement;D=(D.clientHeight)?D:B;return D.scrollTop;}},_watchContent:function(){var that=this;if(this._timer){clearInterval(this._timer);}var prevContentHeight=0;this._timer=setInterval(function(){if(that.smoothContent){var contentHeight=that.$content.outerHeight()||0;if(contentHeight!==prevContentHeight){prevContentHeight=contentHeight;}var wh=$(window).height();var total=that.offsetTop+that.offsetBottom+that.$jconfirmBox.height()-that.$contentPane.height()+that.$content.height();if(total<wh){that.$contentPane.addClass("no-scroll");}else{that.$contentPane.removeClass("no-scroll");}}},this.watchInterval);},_overflowClass:"jconfirm-overflow",_hilightAnimating:false,highlight:function(){this.hiLightModal();},hiLightModal:function(){var that=this;if(this._hilightAnimating){return;}that.$body.addClass("hilight");var duration=parseFloat(that.$body.css("animation-duration"))||2;this._hilightAnimating=true;setTimeout(function(){that._hilightAnimating=false;that.$body.removeClass("hilight");},duration*1000);},_bindEvents:function(){var that=this;this.boxClicked=false;this.$scrollPane.click(function(e){if(!that.boxClicked){var buttonName=false;var shouldClose=false;var str;if(typeof that.backgroundDismiss==="function"){str=that.backgroundDismiss();}else{str=that.backgroundDismiss;}if(typeof str==="string"&&typeof that.buttons[str]!=="undefined"){buttonName=str;shouldClose=false;}else{if(typeof str==="undefined"||!!(str)===true){shouldClose=true;}else{shouldClose=false;}}if(buttonName){var btnResponse=that.buttons[buttonName].action.apply(that);shouldClose=(typeof btnResponse==="undefined")||!!(btnResponse);}if(shouldClose){that.close();}else{that.hiLightModal();}}that.boxClicked=false;});this.$jconfirmBox.click(function(e){that.boxClicked=true;});var isKeyDown=false;$(window).on("jcKeyDown."+that._id,function(e){if(!isKeyDown){isKeyDown=true;}});$(window).on("keyup."+that._id,function(e){if(isKeyDown){that.reactOnKey(e);isKeyDown=false;}});$(window).on("resize."+this._id,function(){that._updateContentMaxHeight();setTimeout(function(){that.resetDrag();},100);});},_cubic_bezier:"0.36, 0.55, 0.19",_getCSS:function(speed,bounce){return{"-webkit-transition-duration":speed/1000+"s","transition-duration":speed/1000+"s","-webkit-transition-timing-function":"cubic-bezier("+this._cubic_bezier+", "+bounce+")","transition-timing-function":"cubic-bezier("+this._cubic_bezier+", "+bounce+")"};},_setButtons:function(){var that=this;var total_buttons=0;if(typeof this.buttons!=="object"){this.buttons={};}$.each(this.buttons,function(key,button){total_buttons+=1;if(typeof button==="function"){that.buttons[key]=button={action:button};}that.buttons[key].text=button.text||key;that.buttons[key].btnClass=button.btnClass||"btn-default";that.buttons[key].action=button.action||function(){};that.buttons[key].keys=button.keys||[];that.buttons[key].isHidden=button.isHidden||false;that.buttons[key].isDisabled=button.isDisabled||false;$.each(that.buttons[key].keys,function(i,a){that.buttons[key].keys[i]=a.toLowerCase();});var button_element=$('<button type="button" class="btn"></button>').html(that.buttons[key].text).addClass(that.buttons[key].btnClass).prop("disabled",that.buttons[key].isDisabled).css("display",that.buttons[key].isHidden?"none":"").click(function(e){e.preventDefault();var res=that.buttons[key].action.apply(that,[that.buttons[key]]);that.onAction.apply(that,[key,that.buttons[key]]);that._stopCountDown();if(typeof res==="undefined"||res){that.close();}});that.buttons[key].el=button_element;that.buttons[key].setText=function(text){button_element.html(text);};that.buttons[key].addClass=function(className){button_element.addClass(className);};that.buttons[key].removeClass=function(className){button_element.removeClass(className);};that.buttons[key].disable=function(){that.buttons[key].isDisabled=true;button_element.prop("disabled",true);};that.buttons[key].enable=function(){that.buttons[key].isDisabled=false;button_element.prop("disabled",false);};that.buttons[key].show=function(){that.buttons[key].isHidden=false;button_element.css("display","");};that.buttons[key].hide=function(){that.buttons[key].isHidden=true;button_element.css("display","none");};that["$_"+key]=that["$$"+key]=button_element;that.$btnc.append(button_element);});if(total_buttons===0){this.$btnc.hide();}if(this.closeIcon===null&&total_buttons===0){this.closeIcon=true;}if(this.closeIcon){if(this.closeIconClass){var closeHtml='<i class="'+this.closeIconClass+'"></i>';this.$closeIcon.html(closeHtml);}this.$closeIcon.click(function(e){e.preventDefault();var buttonName=false;var shouldClose=false;var str;if(typeof that.closeIcon==="function"){str=that.closeIcon();}else{str=that.closeIcon;}if(typeof str==="string"&&typeof that.buttons[str]!=="undefined"){buttonName=str;shouldClose=false;}else{if(typeof str==="undefined"||!!(str)===true){shouldClose=true;}else{shouldClose=false;}}if(buttonName){var btnResponse=that.buttons[buttonName].action.apply(that);shouldClose=(typeof btnResponse==="undefined")||!!(btnResponse);}if(shouldClose){that.close();}});this.$closeIcon.show();}else{this.$closeIcon.hide();}},setTitle:function(string,force){force=force||false;if(typeof string!=="undefined"){if(typeof string==="string"){this.title=string;}else{if(typeof string==="function"){if(typeof string.promise==="function"){console.error("Promise was returned from title function, this is not supported.");}var response=string();if(typeof response==="string"){this.title=response;}else{this.title=false;}}else{this.title=false;}}}if(this.isAjaxLoading&&!force){return;}this.$title.html(this.title||"");this.updateTitleContainer();},setIcon:function(iconClass,force){force=force||false;if(typeof iconClass!=="undefined"){if(typeof iconClass==="string"){this.icon=iconClass;}else{if(typeof iconClass==="function"){var response=iconClass();if(typeof response==="string"){this.icon=response;}else{this.icon=false;}}else{this.icon=false;}}}if(this.isAjaxLoading&&!force){return;}this.$icon.html(this.icon?'<i class="'+this.icon+'"></i>':"");this.updateTitleContainer();},updateTitleContainer:function(){if(!this.title&&!this.icon){this.$titleContainer.hide();}else{this.$titleContainer.show();}},setContentPrepend:function(content,force){if(!content){return;}this.contentParsed.prepend(content);},setContentAppend:function(content){if(!content){return;}this.contentParsed.append(content);},setContent:function(content,force){force=!!force;var that=this;if(content){this.contentParsed.html("").append(content);}if(this.isAjaxLoading&&!force){return;}this.$content.html("");this.$content.append(this.contentParsed);setTimeout(function(){that.$body.find("input[autofocus]:visible:first").focus();},100);},loadingSpinner:false,showLoading:function(disableButtons){this.loadingSpinner=true;this.$jconfirmBox.addClass("loading");if(disableButtons){this.$btnc.find("button").prop("disabled",true);}},hideLoading:function(enableButtons){this.loadingSpinner=false;this.$jconfirmBox.removeClass("loading");if(enableButtons){this.$btnc.find("button").prop("disabled",false);}},ajaxResponse:false,contentParsed:"",isAjax:false,isAjaxLoading:false,_parseContent:function(){var that=this;var e="&nbsp;";if(typeof this.content==="function"){var res=this.content.apply(this);if(typeof res==="string"){this.content=res;}else{if(typeof res==="object"&&typeof res.always==="function"){this.isAjax=true;this.isAjaxLoading=true;res.always(function(data,status,xhr){that.ajaxResponse={data:data,status:status,xhr:xhr};that._contentReady.resolve(data,status,xhr);if(typeof that.contentLoaded==="function"){that.contentLoaded(data,status,xhr);}});this.content=e;}else{this.content=e;}}}if(typeof this.content==="string"&&this.content.substr(0,4).toLowerCase()==="url:"){this.isAjax=true;this.isAjaxLoading=true;var u=this.content.substring(4,this.content.length);$.get(u).done(function(html){that.contentParsed.html(html);}).always(function(data,status,xhr){that.ajaxResponse={data:data,status:status,xhr:xhr};that._contentReady.resolve(data,status,xhr);if(typeof that.contentLoaded==="function"){that.contentLoaded(data,status,xhr);}});}if(!this.content){this.content=e;}if(!this.isAjax){this.contentParsed.html(this.content);this.setContent();that._contentReady.resolve();}},_stopCountDown:function(){clearInterval(this.autoCloseInterval);if(this.$cd){this.$cd.remove();}},_startCountDown:function(){var that=this;var opt=this.autoClose.split("|");if(opt.length!==2){console.error("Invalid option for autoClose. example 'close|10000'");return false;}var button_key=opt[0];var time=parseInt(opt[1]);if(typeof this.buttons[button_key]==="undefined"){console.error("Invalid button key '"+button_key+"' for autoClose");return false;}var seconds=Math.ceil(time/1000);this.$cd=$('<span class="countdown"> ('+seconds+")</span>").appendTo(this["$_"+button_key]);this.autoCloseInterval=setInterval(function(){that.$cd.html(" ("+(seconds-=1)+") ");if(seconds<=0){that["$$"+button_key].trigger("click");that._stopCountDown();}},1000);},_getKey:function(key){switch(key){case 192:return"tilde";case 13:return"enter";case 16:return"shift";case 9:return"tab";case 20:return"capslock";case 17:return"ctrl";case 91:return"win";case 18:return"alt";case 27:return"esc";case 32:return"space";}var initial=String.fromCharCode(key);if(/^[A-z0-9]+$/.test(initial)){return initial.toLowerCase();}else{return false;}},reactOnKey:function(e){var that=this;var a=$(".jconfirm");if(a.eq(a.length-1)[0]!==this.$el[0]){return false;}var key=e.which;if(this.$content.find(":input").is(":focus")&&/13|32/.test(key)){return false;}var keyChar=this._getKey(key);if(keyChar==="esc"&&this.escapeKey){if(this.escapeKey===true){this.$scrollPane.trigger("click");}else{if(typeof this.escapeKey==="string"||typeof this.escapeKey==="function"){var buttonKey;if(typeof this.escapeKey==="function"){buttonKey=this.escapeKey();}else{buttonKey=this.escapeKey;}if(buttonKey){if(typeof this.buttons[buttonKey]==="undefined"){console.warn("Invalid escapeKey, no buttons found with key "+buttonKey);}else{this["$_"+buttonKey].trigger("click");}}}}}$.each(this.buttons,function(key,button){if(button.keys.indexOf(keyChar)!==-1){that["$_"+key].trigger("click");}});},setDialogCenter:function(){console.info("setDialogCenter is deprecated, dialogs are centered with CSS3 tables");},_unwatchContent:function(){clearInterval(this._timer);},close:function(onClosePayload){var that=this;if(typeof this.onClose==="function"){this.onClose(onClosePayload);}this._unwatchContent();$(window).unbind("resize."+this._id);$(window).unbind("keyup."+this._id);$(window).unbind("jcKeyDown."+this._id);if(this.draggable){$(window).unbind("mousemove."+this._id);$(window).unbind("mouseup."+this._id);this.$titleContainer.unbind("mousedown");}that.$el.removeClass(that.loadedClass);$("body").removeClass("jconfirm-no-scroll-"+that._id);that.$jconfirmBoxContainer.removeClass("jconfirm-no-transition");setTimeout(function(){that.$body.addClass(that.closeAnimationParsed);that.$jconfirmBg.addClass("jconfirm-bg-h");var closeTimer=(that.closeAnimation==="none")?1:that.animationSpeed;setTimeout(function(){that.$el.remove();var l=w.jconfirm.instances;var i=w.jconfirm.instances.length-1;for(i;i>=0;i--){if(w.jconfirm.instances[i]._id===that._id){w.jconfirm.instances.splice(i,1);}}if(!w.jconfirm.instances.length){if(that.scrollToPreviousElement&&w.jconfirm.lastFocused&&w.jconfirm.lastFocused.length&&$.contains(document,w.jconfirm.lastFocused[0])){var $lf=w.jconfirm.lastFocused;if(that.scrollToPreviousElementAnimate){var st=$(window).scrollTop();var ot=w.jconfirm.lastFocused.offset().top;var wh=$(window).height();if(!(ot>st&&ot<(st+wh))){var scrollTo=(ot-Math.round((wh/3)));$("html, body").animate({scrollTop:scrollTo},that.animationSpeed,"swing",function(){$lf.focus();});}else{$lf.focus();}}else{$lf.focus();}w.jconfirm.lastFocused=false;}}if(typeof that.onDestroy==="function"){that.onDestroy();}},closeTimer*0.4);},50);return true;},open:function(){if(this.isOpen()){return false;}this._buildHTML();this._bindEvents();this._open();return true;},setStartingPoint:function(){var el=false;if(this.animateFromElement!==true&&this.animateFromElement){el=this.animateFromElement;w.jconfirm.lastClicked=false;}else{if(w.jconfirm.lastClicked&&this.animateFromElement===true){el=w.jconfirm.lastClicked;w.jconfirm.lastClicked=false;}else{return false;}}if(!el){return false;}var offset=el.offset();var iTop=el.outerHeight()/2;var iLeft=el.outerWidth()/2;iTop-=this.$jconfirmBox.outerHeight()/2;iLeft-=this.$jconfirmBox.outerWidth()/2;var sourceTop=offset.top+iTop;sourceTop=sourceTop-this._scrollTop();var sourceLeft=offset.left+iLeft;var wh=$(window).height()/2;var ww=$(window).width()/2;var targetH=wh-this.$jconfirmBox.outerHeight()/2;var targetW=ww-this.$jconfirmBox.outerWidth()/2;sourceTop-=targetH;sourceLeft-=targetW;if(Math.abs(sourceTop)>wh||Math.abs(sourceLeft)>ww){return false;}this.$jconfirmBoxContainer.css("transform","translate("+sourceLeft+"px, "+sourceTop+"px)");},_open:function(){var that=this;if(typeof that.onOpenBefore==="function"){that.onOpenBefore();}this.$body.removeClass(this.animationParsed);this.$jconfirmBg.removeClass("jconfirm-bg-h");this.$body.focus();that.$jconfirmBoxContainer.css("transform","translate("+0+"px, "+0+"px)");setTimeout(function(){that.$body.css(that._getCSS(that.animationSpeed,1));that.$body.css({"transition-property":that.$body.css("transition-property")+", margin"});that.$jconfirmBoxContainer.addClass("jconfirm-no-transition");that._modalReady.resolve();if(typeof that.onOpen==="function"){that.onOpen();}that.$el.addClass(that.loadedClass);},this.animationSpeed);},loadedClass:"jconfirm-open",isClosed:function(){return !this.$el||this.$el.parent().length===0;},isOpen:function(){return !this.isClosed();},toggle:function(){if(!this.isOpen()){this.open();}else{this.close();}}};w.jconfirm.instances=[];w.jconfirm.lastFocused=false;w.jconfirm.pluginDefaults={template:'<div class="jconfirm"><div class="jconfirm-bg jconfirm-bg-h"></div><div class="jconfirm-scrollpane"><div class="jconfirm-row"><div class="jconfirm-cell"><div class="jconfirm-holder"><div class="jc-bs3-container"><div class="jc-bs3-row"><div class="jconfirm-box-container jconfirm-animated"><div class="jconfirm-box" role="dialog" aria-labelledby="labelled" tabindex="-1"><div class="jconfirm-closeIcon">&times;</div><div class="jconfirm-title-c"><span class="jconfirm-icon-c"></span><span class="jconfirm-title"></span></div><div class="jconfirm-content-pane"><div class="jconfirm-content"></div></div><div class="jconfirm-buttons"></div><div class="jconfirm-clear"></div></div></div></div></div></div></div></div></div></div>',title:"Hello",titleClass:"",type:"default",typeAnimated:true,draggable:true,dragWindowGap:15,dragWindowBorder:true,animateFromElement:true,alignMiddle:true,smoothContent:true,content:"Are you sure to continue?",buttons:{},defaultButtons:{ok:{action:function(){}},close:{action:function(){}}},contentLoaded:function(){},icon:"",lazyOpen:false,bgOpacity:null,theme:"light",animation:"scale",closeAnimation:"scale",animationSpeed:400,animationBounce:1,escapeKey:true,rtl:false,container:"body",containerFluid:false,backgroundDismiss:false,backgroundDismissAnimation:"shake",autoClose:false,closeIcon:null,closeIconClass:false,watchInterval:100,columnClass:"col-md-4 col-md-offset-4 col-sm-6 col-sm-offset-3 col-xs-10 col-xs-offset-1",boxWidth:"50%",scrollToPreviousElement:true,scrollToPreviousElementAnimate:true,useBootstrap:true,offsetTop:40,offsetBottom:40,bootstrapClasses:{container:"container",containerFluid:"container-fluid",row:"row"},onContentReady:function(){},onOpenBefore:function(){},onOpen:function(){},onClose:function(){},onDestroy:function(){},onAction:function(){}};var keyDown=false;$(window).on("keydown",function(e){if(!keyDown){var $target=$(e.target);var pass=false;if($target.closest(".jconfirm-box").length){pass=true;}if(pass){$(window).trigger("jcKeyDown");}keyDown=true;}});$(window).on("keyup",function(){keyDown=false;});w.jconfirm.lastClicked=false;$(document).on("mousedown","button, a, [jc-source]",function(){w.jconfirm.lastClicked=$(this);});}));
\ No newline at end of file
diff --git a/bemani/frontend/static/jquery.touchSwipe.min.js b/bemani/frontend/static/jquery.touchSwipe.min.js
new file mode 100644
index 0000000..8ba8494
--- /dev/null
+++ b/bemani/frontend/static/jquery.touchSwipe.min.js
@@ -0,0 +1,16 @@
+/*!
+ * @fileOverview TouchSwipe - jQuery Plugin
+ * @version 1.6.18
+ *
+ * @author Matt Bryson http://www.github.com/mattbryson
+ * @see https://github.com/mattbryson/TouchSwipe-Jquery-Plugin
+ * @see http://labs.rampinteractive.co.uk/touchSwipe/
+ * @see http://plugins.jquery.com/project/touchSwipe
+ * @license
+ * Copyright (c) 2010-2015 Matt Bryson
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ */
+
+!function(factory){"function"==typeof define&&define.amd&&define.amd.jQuery?define(["jquery"],factory):factory("undefined"!=typeof module&&module.exports?require("jquery"):jQuery)}(function($){"use strict";function init(options){return!options||void 0!==options.allowPageScroll||void 0===options.swipe&&void 0===options.swipeStatus||(options.allowPageScroll=NONE),void 0!==options.click&&void 0===options.tap&&(options.tap=options.click),options||(options={}),options=$.extend({},$.fn.swipe.defaults,options),this.each(function(){var $this=$(this),plugin=$this.data(PLUGIN_NS);plugin||(plugin=new TouchSwipe(this,options),$this.data(PLUGIN_NS,plugin))})}function TouchSwipe(element,options){function touchStart(jqEvent){if(!(getTouchInProgress()||$(jqEvent.target).closest(options.excludedElements,$element).length>0)){var event=jqEvent.originalEvent?jqEvent.originalEvent:jqEvent;if(!event.pointerType||"mouse"!=event.pointerType||0!=options.fallbackToMouseEvents){var ret,touches=event.touches,evt=touches?touches[0]:event;return phase=PHASE_START,touches?fingerCount=touches.length:options.preventDefaultEvents!==!1&&jqEvent.preventDefault(),distance=0,direction=null,currentDirection=null,pinchDirection=null,duration=0,startTouchesDistance=0,endTouchesDistance=0,pinchZoom=1,pinchDistance=0,maximumsMap=createMaximumsData(),cancelMultiFingerRelease(),createFingerData(0,evt),!touches||fingerCount===options.fingers||options.fingers===ALL_FINGERS||hasPinches()?(startTime=getTimeStamp(),2==fingerCount&&(createFingerData(1,touches[1]),startTouchesDistance=endTouchesDistance=calculateTouchesDistance(fingerData[0].start,fingerData[1].start)),(options.swipeStatus||options.pinchStatus)&&(ret=triggerHandler(event,phase))):ret=!1,ret===!1?(phase=PHASE_CANCEL,triggerHandler(event,phase),ret):(options.hold&&(holdTimeout=setTimeout($.proxy(function(){$element.trigger("hold",[event.target]),options.hold&&(ret=options.hold.call($element,event,event.target))},this),options.longTapThreshold)),setTouchInProgress(!0),null)}}}function touchMove(jqEvent){var event=jqEvent.originalEvent?jqEvent.originalEvent:jqEvent;if(phase!==PHASE_END&&phase!==PHASE_CANCEL&&!inMultiFingerRelease()){var ret,touches=event.touches,evt=touches?touches[0]:event,currentFinger=updateFingerData(evt);if(endTime=getTimeStamp(),touches&&(fingerCount=touches.length),options.hold&&clearTimeout(holdTimeout),phase=PHASE_MOVE,2==fingerCount&&(0==startTouchesDistance?(createFingerData(1,touches[1]),startTouchesDistance=endTouchesDistance=calculateTouchesDistance(fingerData[0].start,fingerData[1].start)):(updateFingerData(touches[1]),endTouchesDistance=calculateTouchesDistance(fingerData[0].end,fingerData[1].end),pinchDirection=calculatePinchDirection(fingerData[0].end,fingerData[1].end)),pinchZoom=calculatePinchZoom(startTouchesDistance,endTouchesDistance),pinchDistance=Math.abs(startTouchesDistance-endTouchesDistance)),fingerCount===options.fingers||options.fingers===ALL_FINGERS||!touches||hasPinches()){if(direction=calculateDirection(currentFinger.start,currentFinger.end),currentDirection=calculateDirection(currentFinger.last,currentFinger.end),validateDefaultEvent(jqEvent,currentDirection),distance=calculateDistance(currentFinger.start,currentFinger.end),duration=calculateDuration(),setMaxDistance(direction,distance),ret=triggerHandler(event,phase),!options.triggerOnTouchEnd||options.triggerOnTouchLeave){var inBounds=!0;if(options.triggerOnTouchLeave){var bounds=getbounds(this);inBounds=isInBounds(currentFinger.end,bounds)}!options.triggerOnTouchEnd&&inBounds?phase=getNextPhase(PHASE_MOVE):options.triggerOnTouchLeave&&!inBounds&&(phase=getNextPhase(PHASE_END)),phase!=PHASE_CANCEL&&phase!=PHASE_END||triggerHandler(event,phase)}}else phase=PHASE_CANCEL,triggerHandler(event,phase);ret===!1&&(phase=PHASE_CANCEL,triggerHandler(event,phase))}}function touchEnd(jqEvent){var event=jqEvent.originalEvent?jqEvent.originalEvent:jqEvent,touches=event.touches;if(touches){if(touches.length&&!inMultiFingerRelease())return startMultiFingerRelease(event),!0;if(touches.length&&inMultiFingerRelease())return!0}return inMultiFingerRelease()&&(fingerCount=fingerCountAtRelease),endTime=getTimeStamp(),duration=calculateDuration(),didSwipeBackToCancel()||!validateSwipeDistance()?(phase=PHASE_CANCEL,triggerHandler(event,phase)):options.triggerOnTouchEnd||options.triggerOnTouchEnd===!1&&phase===PHASE_MOVE?(options.preventDefaultEvents!==!1&&jqEvent.preventDefault(),phase=PHASE_END,triggerHandler(event,phase)):!options.triggerOnTouchEnd&&hasTap()?(phase=PHASE_END,triggerHandlerForGesture(event,phase,TAP)):phase===PHASE_MOVE&&(phase=PHASE_CANCEL,triggerHandler(event,phase)),setTouchInProgress(!1),null}function touchCancel(){fingerCount=0,endTime=0,startTime=0,startTouchesDistance=0,endTouchesDistance=0,pinchZoom=1,cancelMultiFingerRelease(),setTouchInProgress(!1)}function touchLeave(jqEvent){var event=jqEvent.originalEvent?jqEvent.originalEvent:jqEvent;options.triggerOnTouchLeave&&(phase=getNextPhase(PHASE_END),triggerHandler(event,phase))}function removeListeners(){$element.unbind(START_EV,touchStart),$element.unbind(CANCEL_EV,touchCancel),$element.unbind(MOVE_EV,touchMove),$element.unbind(END_EV,touchEnd),LEAVE_EV&&$element.unbind(LEAVE_EV,touchLeave),setTouchInProgress(!1)}function getNextPhase(currentPhase){var nextPhase=currentPhase,validTime=validateSwipeTime(),validDistance=validateSwipeDistance(),didCancel=didSwipeBackToCancel();return!validTime||didCancel?nextPhase=PHASE_CANCEL:!validDistance||currentPhase!=PHASE_MOVE||options.triggerOnTouchEnd&&!options.triggerOnTouchLeave?!validDistance&&currentPhase==PHASE_END&&options.triggerOnTouchLeave&&(nextPhase=PHASE_CANCEL):nextPhase=PHASE_END,nextPhase}function triggerHandler(event,phase){var ret,touches=event.touches;return(didSwipe()||hasSwipes())&&(ret=triggerHandlerForGesture(event,phase,SWIPE)),(didPinch()||hasPinches())&&ret!==!1&&(ret=triggerHandlerForGesture(event,phase,PINCH)),didDoubleTap()&&ret!==!1?ret=triggerHandlerForGesture(event,phase,DOUBLE_TAP):didLongTap()&&ret!==!1?ret=triggerHandlerForGesture(event,phase,LONG_TAP):didTap()&&ret!==!1&&(ret=triggerHandlerForGesture(event,phase,TAP)),phase===PHASE_CANCEL&&touchCancel(event),phase===PHASE_END&&(touches?touches.length||touchCancel(event):touchCancel(event)),ret}function triggerHandlerForGesture(event,phase,gesture){var ret;if(gesture==SWIPE){if($element.trigger("swipeStatus",[phase,direction||null,distance||0,duration||0,fingerCount,fingerData,currentDirection]),options.swipeStatus&&(ret=options.swipeStatus.call($element,event,phase,direction||null,distance||0,duration||0,fingerCount,fingerData,currentDirection),ret===!1))return!1;if(phase==PHASE_END&&validateSwipe()){if(clearTimeout(singleTapTimeout),clearTimeout(holdTimeout),$element.trigger("swipe",[direction,distance,duration,fingerCount,fingerData,currentDirection]),options.swipe&&(ret=options.swipe.call($element,event,direction,distance,duration,fingerCount,fingerData,currentDirection),ret===!1))return!1;switch(direction){case LEFT:$element.trigger("swipeLeft",[direction,distance,duration,fingerCount,fingerData,currentDirection]),options.swipeLeft&&(ret=options.swipeLeft.call($element,event,direction,distance,duration,fingerCount,fingerData,currentDirection));break;case RIGHT:$element.trigger("swipeRight",[direction,distance,duration,fingerCount,fingerData,currentDirection]),options.swipeRight&&(ret=options.swipeRight.call($element,event,direction,distance,duration,fingerCount,fingerData,currentDirection));break;case UP:$element.trigger("swipeUp",[direction,distance,duration,fingerCount,fingerData,currentDirection]),options.swipeUp&&(ret=options.swipeUp.call($element,event,direction,distance,duration,fingerCount,fingerData,currentDirection));break;case DOWN:$element.trigger("swipeDown",[direction,distance,duration,fingerCount,fingerData,currentDirection]),options.swipeDown&&(ret=options.swipeDown.call($element,event,direction,distance,duration,fingerCount,fingerData,currentDirection))}}}if(gesture==PINCH){if($element.trigger("pinchStatus",[phase,pinchDirection||null,pinchDistance||0,duration||0,fingerCount,pinchZoom,fingerData]),options.pinchStatus&&(ret=options.pinchStatus.call($element,event,phase,pinchDirection||null,pinchDistance||0,duration||0,fingerCount,pinchZoom,fingerData),ret===!1))return!1;if(phase==PHASE_END&&validatePinch())switch(pinchDirection){case IN:$element.trigger("pinchIn",[pinchDirection||null,pinchDistance||0,duration||0,fingerCount,pinchZoom,fingerData]),options.pinchIn&&(ret=options.pinchIn.call($element,event,pinchDirection||null,pinchDistance||0,duration||0,fingerCount,pinchZoom,fingerData));break;case OUT:$element.trigger("pinchOut",[pinchDirection||null,pinchDistance||0,duration||0,fingerCount,pinchZoom,fingerData]),options.pinchOut&&(ret=options.pinchOut.call($element,event,pinchDirection||null,pinchDistance||0,duration||0,fingerCount,pinchZoom,fingerData))}}return gesture==TAP?phase!==PHASE_CANCEL&&phase!==PHASE_END||(clearTimeout(singleTapTimeout),clearTimeout(holdTimeout),hasDoubleTap()&&!inDoubleTap()?(doubleTapStartTime=getTimeStamp(),singleTapTimeout=setTimeout($.proxy(function(){doubleTapStartTime=null,$element.trigger("tap",[event.target]),options.tap&&(ret=options.tap.call($element,event,event.target))},this),options.doubleTapThreshold)):(doubleTapStartTime=null,$element.trigger("tap",[event.target]),options.tap&&(ret=options.tap.call($element,event,event.target)))):gesture==DOUBLE_TAP?phase!==PHASE_CANCEL&&phase!==PHASE_END||(clearTimeout(singleTapTimeout),clearTimeout(holdTimeout),doubleTapStartTime=null,$element.trigger("doubletap",[event.target]),options.doubleTap&&(ret=options.doubleTap.call($element,event,event.target))):gesture==LONG_TAP&&(phase!==PHASE_CANCEL&&phase!==PHASE_END||(clearTimeout(singleTapTimeout),doubleTapStartTime=null,$element.trigger("longtap",[event.target]),options.longTap&&(ret=options.longTap.call($element,event,event.target)))),ret}function validateSwipeDistance(){var valid=!0;return null!==options.threshold&&(valid=distance>=options.threshold),valid}function didSwipeBackToCancel(){var cancelled=!1;return null!==options.cancelThreshold&&null!==direction&&(cancelled=getMaxDistance(direction)-distance>=options.cancelThreshold),cancelled}function validatePinchDistance(){return null===options.pinchThreshold||pinchDistance>=options.pinchThreshold}function validateSwipeTime(){var result;return result=!options.maxTimeThreshold||!(duration>=options.maxTimeThreshold)}function validateDefaultEvent(jqEvent,direction){if(options.preventDefaultEvents!==!1)if(options.allowPageScroll===NONE)jqEvent.preventDefault();else{var auto=options.allowPageScroll===AUTO;switch(direction){case LEFT:(options.swipeLeft&&auto||!auto&&options.allowPageScroll!=HORIZONTAL)&&jqEvent.preventDefault();break;case RIGHT:(options.swipeRight&&auto||!auto&&options.allowPageScroll!=HORIZONTAL)&&jqEvent.preventDefault();break;case UP:(options.swipeUp&&auto||!auto&&options.allowPageScroll!=VERTICAL)&&jqEvent.preventDefault();break;case DOWN:(options.swipeDown&&auto||!auto&&options.allowPageScroll!=VERTICAL)&&jqEvent.preventDefault();break;case NONE:}}}function validatePinch(){var hasCorrectFingerCount=validateFingers(),hasEndPoint=validateEndPoint(),hasCorrectDistance=validatePinchDistance();return hasCorrectFingerCount&&hasEndPoint&&hasCorrectDistance}function hasPinches(){return!!(options.pinchStatus||options.pinchIn||options.pinchOut)}function didPinch(){return!(!validatePinch()||!hasPinches())}function validateSwipe(){var hasValidTime=validateSwipeTime(),hasValidDistance=validateSwipeDistance(),hasCorrectFingerCount=validateFingers(),hasEndPoint=validateEndPoint(),didCancel=didSwipeBackToCancel(),valid=!didCancel&&hasEndPoint&&hasCorrectFingerCount&&hasValidDistance&&hasValidTime;return valid}function hasSwipes(){return!!(options.swipe||options.swipeStatus||options.swipeLeft||options.swipeRight||options.swipeUp||options.swipeDown)}function didSwipe(){return!(!validateSwipe()||!hasSwipes())}function validateFingers(){return fingerCount===options.fingers||options.fingers===ALL_FINGERS||!SUPPORTS_TOUCH}function validateEndPoint(){return 0!==fingerData[0].end.x}function hasTap(){return!!options.tap}function hasDoubleTap(){return!!options.doubleTap}function hasLongTap(){return!!options.longTap}function validateDoubleTap(){if(null==doubleTapStartTime)return!1;var now=getTimeStamp();return hasDoubleTap()&&now-doubleTapStartTime<=options.doubleTapThreshold}function inDoubleTap(){return validateDoubleTap()}function validateTap(){return(1===fingerCount||!SUPPORTS_TOUCH)&&(isNaN(distance)||distance<options.threshold)}function validateLongTap(){return duration>options.longTapThreshold&&distance<DOUBLE_TAP_THRESHOLD}function didTap(){return!(!validateTap()||!hasTap())}function didDoubleTap(){return!(!validateDoubleTap()||!hasDoubleTap())}function didLongTap(){return!(!validateLongTap()||!hasLongTap())}function startMultiFingerRelease(event){previousTouchEndTime=getTimeStamp(),fingerCountAtRelease=event.touches.length+1}function cancelMultiFingerRelease(){previousTouchEndTime=0,fingerCountAtRelease=0}function inMultiFingerRelease(){var withinThreshold=!1;if(previousTouchEndTime){var diff=getTimeStamp()-previousTouchEndTime;diff<=options.fingerReleaseThreshold&&(withinThreshold=!0)}return withinThreshold}function getTouchInProgress(){return!($element.data(PLUGIN_NS+"_intouch")!==!0)}function setTouchInProgress(val){$element&&(val===!0?($element.bind(MOVE_EV,touchMove),$element.bind(END_EV,touchEnd),LEAVE_EV&&$element.bind(LEAVE_EV,touchLeave)):($element.unbind(MOVE_EV,touchMove,!1),$element.unbind(END_EV,touchEnd,!1),LEAVE_EV&&$element.unbind(LEAVE_EV,touchLeave,!1)),$element.data(PLUGIN_NS+"_intouch",val===!0))}function createFingerData(id,evt){var f={start:{x:0,y:0},last:{x:0,y:0},end:{x:0,y:0}};return f.start.x=f.last.x=f.end.x=evt.pageX||evt.clientX,f.start.y=f.last.y=f.end.y=evt.pageY||evt.clientY,fingerData[id]=f,f}function updateFingerData(evt){var id=void 0!==evt.identifier?evt.identifier:0,f=getFingerData(id);return null===f&&(f=createFingerData(id,evt)),f.last.x=f.end.x,f.last.y=f.end.y,f.end.x=evt.pageX||evt.clientX,f.end.y=evt.pageY||evt.clientY,f}function getFingerData(id){return fingerData[id]||null}function setMaxDistance(direction,distance){direction!=NONE&&(distance=Math.max(distance,getMaxDistance(direction)),maximumsMap[direction].distance=distance)}function getMaxDistance(direction){if(maximumsMap[direction])return maximumsMap[direction].distance}function createMaximumsData(){var maxData={};return maxData[LEFT]=createMaximumVO(LEFT),maxData[RIGHT]=createMaximumVO(RIGHT),maxData[UP]=createMaximumVO(UP),maxData[DOWN]=createMaximumVO(DOWN),maxData}function createMaximumVO(dir){return{direction:dir,distance:0}}function calculateDuration(){return endTime-startTime}function calculateTouchesDistance(startPoint,endPoint){var diffX=Math.abs(startPoint.x-endPoint.x),diffY=Math.abs(startPoint.y-endPoint.y);return Math.round(Math.sqrt(diffX*diffX+diffY*diffY))}function calculatePinchZoom(startDistance,endDistance){var percent=endDistance/startDistance*1;return percent.toFixed(2)}function calculatePinchDirection(){return pinchZoom<1?OUT:IN}function calculateDistance(startPoint,endPoint){return Math.round(Math.sqrt(Math.pow(endPoint.x-startPoint.x,2)+Math.pow(endPoint.y-startPoint.y,2)))}function calculateAngle(startPoint,endPoint){var x=startPoint.x-endPoint.x,y=endPoint.y-startPoint.y,r=Math.atan2(y,x),angle=Math.round(180*r/Math.PI);return angle<0&&(angle=360-Math.abs(angle)),angle}function calculateDirection(startPoint,endPoint){if(comparePoints(startPoint,endPoint))return NONE;var angle=calculateAngle(startPoint,endPoint);return angle<=45&&angle>=0?LEFT:angle<=360&&angle>=315?LEFT:angle>=135&&angle<=225?RIGHT:angle>45&&angle<135?DOWN:UP}function getTimeStamp(){var now=new Date;return now.getTime()}function getbounds(el){el=$(el);var offset=el.offset(),bounds={left:offset.left,right:offset.left+el.outerWidth(),top:offset.top,bottom:offset.top+el.outerHeight()};return bounds}function isInBounds(point,bounds){return point.x>bounds.left&&point.x<bounds.right&&point.y>bounds.top&&point.y<bounds.bottom}function comparePoints(pointA,pointB){return pointA.x==pointB.x&&pointA.y==pointB.y}var options=$.extend({},options),useTouchEvents=SUPPORTS_TOUCH||SUPPORTS_POINTER||!options.fallbackToMouseEvents,START_EV=useTouchEvents?SUPPORTS_POINTER?SUPPORTS_POINTER_IE10?"MSPointerDown":"pointerdown":"touchstart":"mousedown",MOVE_EV=useTouchEvents?SUPPORTS_POINTER?SUPPORTS_POINTER_IE10?"MSPointerMove":"pointermove":"touchmove":"mousemove",END_EV=useTouchEvents?SUPPORTS_POINTER?SUPPORTS_POINTER_IE10?"MSPointerUp":"pointerup":"touchend":"mouseup",LEAVE_EV=useTouchEvents?SUPPORTS_POINTER?"mouseleave":null:"mouseleave",CANCEL_EV=SUPPORTS_POINTER?SUPPORTS_POINTER_IE10?"MSPointerCancel":"pointercancel":"touchcancel",distance=0,direction=null,currentDirection=null,duration=0,startTouchesDistance=0,endTouchesDistance=0,pinchZoom=1,pinchDistance=0,pinchDirection=0,maximumsMap=null,$element=$(element),phase="start",fingerCount=0,fingerData={},startTime=0,endTime=0,previousTouchEndTime=0,fingerCountAtRelease=0,doubleTapStartTime=0,singleTapTimeout=null,holdTimeout=null;try{$element.bind(START_EV,touchStart),$element.bind(CANCEL_EV,touchCancel)}catch(e){$.error("events not supported "+START_EV+","+CANCEL_EV+" on jQuery.swipe")}this.enable=function(){return this.disable(),$element.bind(START_EV,touchStart),$element.bind(CANCEL_EV,touchCancel),$element},this.disable=function(){return removeListeners(),$element},this.destroy=function(){removeListeners(),$element.data(PLUGIN_NS,null),$element=null},this.option=function(property,value){if("object"==typeof property)options=$.extend(options,property);else if(void 0!==options[property]){if(void 0===value)return options[property];options[property]=value}else{if(!property)return options;$.error("Option "+property+" does not exist on jQuery.swipe.options")}return null}}var VERSION="1.6.18",LEFT="left",RIGHT="right",UP="up",DOWN="down",IN="in",OUT="out",NONE="none",AUTO="auto",SWIPE="swipe",PINCH="pinch",TAP="tap",DOUBLE_TAP="doubletap",LONG_TAP="longtap",HORIZONTAL="horizontal",VERTICAL="vertical",ALL_FINGERS="all",DOUBLE_TAP_THRESHOLD=10,PHASE_START="start",PHASE_MOVE="move",PHASE_END="end",PHASE_CANCEL="cancel",SUPPORTS_TOUCH="ontouchstart"in window,SUPPORTS_POINTER_IE10=window.navigator.msPointerEnabled&&!window.PointerEvent&&!SUPPORTS_TOUCH,SUPPORTS_POINTER=(window.PointerEvent||window.navigator.msPointerEnabled)&&!SUPPORTS_TOUCH,PLUGIN_NS="TouchSwipe",defaults={fingers:1,threshold:75,cancelThreshold:null,pinchThreshold:20,maxTimeThreshold:null,fingerReleaseThreshold:250,longTapThreshold:500,doubleTapThreshold:200,swipe:null,swipeLeft:null,swipeRight:null,swipeUp:null,swipeDown:null,swipeStatus:null,pinchIn:null,pinchOut:null,pinchStatus:null,click:null,tap:null,doubleTap:null,longTap:null,hold:null,triggerOnTouchEnd:!0,triggerOnTouchLeave:!1,allowPageScroll:"auto",fallbackToMouseEvents:!0,excludedElements:".noSwipe",preventDefaultEvents:!0};$.fn.swipe=function(method){var $this=$(this),plugin=$this.data(PLUGIN_NS);if(plugin&&"string"==typeof method){if(plugin[method])return plugin[method].apply(plugin,Array.prototype.slice.call(arguments,1));$.error("Method "+method+" does not exist on jQuery.swipe")}else if(plugin&&"object"==typeof method)plugin.option.apply(plugin,arguments);else if(!(plugin||"object"!=typeof method&&method))return init.apply(this,arguments);return $this},$.fn.swipe.version=VERSION,$.fn.swipe.defaults=defaults,$.fn.swipe.phases={PHASE_START:PHASE_START,PHASE_MOVE:PHASE_MOVE,PHASE_END:PHASE_END,PHASE_CANCEL:PHASE_CANCEL},$.fn.swipe.directions={LEFT:LEFT,RIGHT:RIGHT,UP:UP,DOWN:DOWN,IN:IN,OUT:OUT},$.fn.swipe.pageScroll={NONE:NONE,HORIZONTAL:HORIZONTAL,VERTICAL:VERTICAL,AUTO:AUTO},$.fn.swipe.fingers={ONE:1,TWO:2,THREE:3,FOUR:4,FIVE:5,ALL:ALL_FINGERS}});
+
diff --git a/bemani/frontend/static/link.js b/bemani/frontend/static/link.js
new file mode 100644
index 0000000..1ac7e4f
--- /dev/null
+++ b/bemani/frontend/static/link.js
@@ -0,0 +1,15 @@
+var Link = {
+    // Helper for taking server-rendered links with a component that we want
+    // to change client-side, and updating them based on parameters.
+
+    get: function(name, param, anchor) {
+        var uri = window.uris[name];
+        if (!param || !uri) {
+            return uri;
+        } else if (!anchor) {
+            return uri.replace("/-1", "/" + param.toString());
+        } else {
+            return uri.replace("/-1", "/" + param.toString()) + '#' + anchor.toString();
+        }
+    },
+};
diff --git a/bemani/frontend/static/loading-16.gif b/bemani/frontend/static/loading-16.gif
new file mode 100644
index 0000000..b7596ab
Binary files /dev/null and b/bemani/frontend/static/loading-16.gif differ
diff --git a/bemani/frontend/static/loading-20.gif b/bemani/frontend/static/loading-20.gif
new file mode 100644
index 0000000..54f7f12
Binary files /dev/null and b/bemani/frontend/static/loading-20.gif differ
diff --git a/bemani/frontend/static/merge.js b/bemani/frontend/static/merge.js
new file mode 100644
index 0000000..a2b8d52
--- /dev/null
+++ b/bemani/frontend/static/merge.js
@@ -0,0 +1,25 @@
+function MergeManager (hash_function, merge_policy) {
+    this.merge_policy = merge_policy;
+    this.hash_function = hash_function;
+    this.data = {};
+
+    this.add = function(newdata) {
+        newdata.map(function(val) {
+            var hash = this.hash_function(val);
+            if (hash in this.data) {
+                if (this.merge_policy == MergeManager.MERGE_POLICY_REPLACE) {
+                    this.data[hash] = val;
+                }
+            } else {
+                this.data[hash] = val;
+            }
+        }.bind(this));
+
+        return Object.keys(this.data).map(function(hash) {
+            return this.data[hash];
+        }.bind(this));
+    };
+};
+
+MergeManager.MERGE_POLICY_DROP = 0;
+MergeManager.MERGE_POLICY_REPLACE = 1;
diff --git a/bemani/frontend/static/messages.js b/bemani/frontend/static/messages.js
new file mode 100644
index 0000000..40e4b8e
--- /dev/null
+++ b/bemani/frontend/static/messages.js
@@ -0,0 +1,21 @@
+var Messages = {
+    error: function(message) {
+        $("ul.messages").append("<li class=\"error\">" + message + "<div class=\"close\">&#10005;</div></li>");
+        window.floaterrors(true);
+    },
+
+    warning: function(message) {
+        $("ul.messages").append("<li class=\"warning\">" + message + "<div class=\"close\">&#10005;</div></li>");
+        window.floaterrors(true);
+    },
+
+    success: function(message) {
+        $("ul.messages").append("<li class=\"success\">" + message + "<div class=\"close\">&#10005;</div></li>");
+        window.floaterrors(true);
+    },
+
+    info: function(message) {
+        $("ul.messages").append("<li class=\"info\">" + message + "<div class=\"close\">&#10005;</div></li>");
+        window.floaterrors(true);
+    },
+};
diff --git a/bemani/frontend/static/react-dom.min.js b/bemani/frontend/static/react-dom.min.js
new file mode 100644
index 0000000..480c7f9
--- /dev/null
+++ b/bemani/frontend/static/react-dom.min.js
@@ -0,0 +1,15 @@
+/**
+ * ReactDOM v15.4.2
+ *
+ * Copyright 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e(require("react"));else if("function"==typeof define&&define.amd)define(["react"],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.ReactDOM=e(t.React)}}(function(e){return function(e){return e()}(function(){return function e(t,n,r){function o(a,s){if(!n[a]){if(!t[a]){var u="function"==typeof require&&require;if(!s&&u)return u(a,!0);if(i)return i(a,!0);var l=new Error("Cannot find module '"+a+"'");throw l.code="MODULE_NOT_FOUND",l}var c=n[a]={exports:{}};t[a][0].call(c.exports,function(e){var n=t[a][1][e];return o(n?n:e)},c,c.exports,e,t,n,r)}return n[a].exports}for(var i="function"==typeof require&&require,a=0;a<r.length;a++)o(r[a]);return o}({1:[function(e,t,n){"use strict";var r={Properties:{"aria-current":0,"aria-details":0,"aria-disabled":0,"aria-hidden":0,"aria-invalid":0,"aria-keyshortcuts":0,"aria-label":0,"aria-roledescription":0,"aria-autocomplete":0,"aria-checked":0,"aria-expanded":0,"aria-haspopup":0,"aria-level":0,"aria-modal":0,"aria-multiline":0,"aria-multiselectable":0,"aria-orientation":0,"aria-placeholder":0,"aria-pressed":0,"aria-readonly":0,"aria-required":0,"aria-selected":0,"aria-sort":0,"aria-valuemax":0,"aria-valuemin":0,"aria-valuenow":0,"aria-valuetext":0,"aria-atomic":0,"aria-busy":0,"aria-live":0,"aria-relevant":0,"aria-dropeffect":0,"aria-grabbed":0,"aria-activedescendant":0,"aria-colcount":0,"aria-colindex":0,"aria-colspan":0,"aria-controls":0,"aria-describedby":0,"aria-errormessage":0,"aria-flowto":0,"aria-labelledby":0,"aria-owns":0,"aria-posinset":0,"aria-rowcount":0,"aria-rowindex":0,"aria-rowspan":0,"aria-setsize":0},DOMAttributeNames:{},DOMPropertyNames:{}};t.exports=r},{}],2:[function(e,t,n){"use strict";var r=e(33),o=e(131),i={focusDOMComponent:function(){o(r.getNodeFromInstance(this))}};t.exports=i},{131:131,33:33}],3:[function(e,t,n){"use strict";function r(){var e=window.opera;return"object"==typeof e&&"function"==typeof e.version&&parseInt(e.version(),10)<=12}function o(e){return(e.ctrlKey||e.altKey||e.metaKey)&&!(e.ctrlKey&&e.altKey)}function i(e){switch(e){case"topCompositionStart":return k.compositionStart;case"topCompositionEnd":return k.compositionEnd;case"topCompositionUpdate":return k.compositionUpdate}}function a(e,t){return"topKeyDown"===e&&t.keyCode===_}function s(e,t){switch(e){case"topKeyUp":return y.indexOf(t.keyCode)!==-1;case"topKeyDown":return t.keyCode!==_;case"topKeyPress":case"topMouseDown":case"topBlur":return!0;default:return!1}}function u(e){var t=e.detail;return"object"==typeof t&&"data"in t?t.data:null}function l(e,t,n,r){var o,l;if(C?o=i(e):N?s(e,n)&&(o=k.compositionEnd):a(e,n)&&(o=k.compositionStart),!o)return null;x&&(N||o!==k.compositionStart?o===k.compositionEnd&&N&&(l=N.getData()):N=m.getPooled(r));var c=v.getPooled(o,t,n,r);if(l)c.data=l;else{var p=u(n);null!==p&&(c.data=p)}return f.accumulateTwoPhaseDispatches(c),c}function c(e,t){switch(e){case"topCompositionEnd":return u(t);case"topKeyPress":var n=t.which;return n!==w?null:(P=!0,T);case"topTextInput":var r=t.data;return r===T&&P?null:r;default:return null}}function p(e,t){if(N){if("topCompositionEnd"===e||!C&&s(e,t)){var n=N.getData();return m.release(N),N=null,n}return null}switch(e){case"topPaste":return null;case"topKeyPress":return t.which&&!o(t)?String.fromCharCode(t.which):null;case"topCompositionEnd":return x?null:t.data;default:return null}}function d(e,t,n,r){var o;if(o=E?c(e,n):p(e,n),!o)return null;var i=g.getPooled(k.beforeInput,t,n,r);return i.data=o,f.accumulateTwoPhaseDispatches(i),i}var f=e(19),h=e(123),m=e(20),v=e(78),g=e(82),y=[9,13,27,32],_=229,C=h.canUseDOM&&"CompositionEvent"in window,b=null;h.canUseDOM&&"documentMode"in document&&(b=document.documentMode);var E=h.canUseDOM&&"TextEvent"in window&&!b&&!r(),x=h.canUseDOM&&(!C||b&&b>8&&b<=11),w=32,T=String.fromCharCode(w),k={beforeInput:{phasedRegistrationNames:{bubbled:"onBeforeInput",captured:"onBeforeInputCapture"},dependencies:["topCompositionEnd","topKeyPress","topTextInput","topPaste"]},compositionEnd:{phasedRegistrationNames:{bubbled:"onCompositionEnd",captured:"onCompositionEndCapture"},dependencies:["topBlur","topCompositionEnd","topKeyDown","topKeyPress","topKeyUp","topMouseDown"]},compositionStart:{phasedRegistrationNames:{bubbled:"onCompositionStart",captured:"onCompositionStartCapture"},dependencies:["topBlur","topCompositionStart","topKeyDown","topKeyPress","topKeyUp","topMouseDown"]},compositionUpdate:{phasedRegistrationNames:{bubbled:"onCompositionUpdate",captured:"onCompositionUpdateCapture"},dependencies:["topBlur","topCompositionUpdate","topKeyDown","topKeyPress","topKeyUp","topMouseDown"]}},P=!1,N=null,S={eventTypes:k,extractEvents:function(e,t,n,r){return[l(e,t,n,r),d(e,t,n,r)]}};t.exports=S},{123:123,19:19,20:20,78:78,82:82}],4:[function(e,t,n){"use strict";function r(e,t){return e+t.charAt(0).toUpperCase()+t.substring(1)}var o={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridRow:!0,gridColumn:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},i=["Webkit","ms","Moz","O"];Object.keys(o).forEach(function(e){i.forEach(function(t){o[r(t,e)]=o[e]})});var a={background:{backgroundAttachment:!0,backgroundColor:!0,backgroundImage:!0,backgroundPositionX:!0,backgroundPositionY:!0,backgroundRepeat:!0},backgroundPosition:{backgroundPositionX:!0,backgroundPositionY:!0},border:{borderWidth:!0,borderStyle:!0,borderColor:!0},borderBottom:{borderBottomWidth:!0,borderBottomStyle:!0,borderBottomColor:!0},borderLeft:{borderLeftWidth:!0,borderLeftStyle:!0,borderLeftColor:!0},borderRight:{borderRightWidth:!0,borderRightStyle:!0,borderRightColor:!0},borderTop:{borderTopWidth:!0,borderTopStyle:!0,borderTopColor:!0},font:{fontStyle:!0,fontVariant:!0,fontWeight:!0,fontSize:!0,lineHeight:!0,fontFamily:!0},outline:{outlineWidth:!0,outlineStyle:!0,outlineColor:!0}},s={isUnitlessNumber:o,shorthandPropertyExpansions:a};t.exports=s},{}],5:[function(e,t,n){"use strict";var r=e(4),o=e(123),i=(e(58),e(125),e(94)),a=e(136),s=e(140),u=(e(142),s(function(e){return a(e)})),l=!1,c="cssFloat";if(o.canUseDOM){var p=document.createElement("div").style;try{p.font=""}catch(e){l=!0}void 0===document.documentElement.style.cssFloat&&(c="styleFloat")}var d={createMarkupForStyles:function(e,t){var n="";for(var r in e)if(e.hasOwnProperty(r)){var o=e[r];null!=o&&(n+=u(r)+":",n+=i(r,o,t)+";")}return n||null},setValueForStyles:function(e,t,n){var o=e.style;for(var a in t)if(t.hasOwnProperty(a)){var s=i(a,t[a],n);if("float"!==a&&"cssFloat"!==a||(a=c),s)o[a]=s;else{var u=l&&r.shorthandPropertyExpansions[a];if(u)for(var p in u)o[p]="";else o[a]=""}}}};t.exports=d},{123:123,125:125,136:136,140:140,142:142,4:4,58:58,94:94}],6:[function(e,t,n){"use strict";function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var o=e(113),i=e(24),a=(e(137),function(){function e(t){r(this,e),this._callbacks=null,this._contexts=null,this._arg=t}return e.prototype.enqueue=function(e,t){this._callbacks=this._callbacks||[],this._callbacks.push(e),this._contexts=this._contexts||[],this._contexts.push(t)},e.prototype.notifyAll=function(){var e=this._callbacks,t=this._contexts,n=this._arg;if(e&&t){e.length!==t.length?o("24"):void 0,this._callbacks=null,this._contexts=null;for(var r=0;r<e.length;r++)e[r].call(t[r],n);e.length=0,t.length=0}},e.prototype.checkpoint=function(){return this._callbacks?this._callbacks.length:0},e.prototype.rollback=function(e){this._callbacks&&this._contexts&&(this._callbacks.length=e,this._contexts.length=e)},e.prototype.reset=function(){this._callbacks=null,this._contexts=null},e.prototype.destructor=function(){this.reset()},e}());t.exports=i.addPoolingTo(a)},{113:113,137:137,24:24}],7:[function(e,t,n){"use strict";function r(e){var t=e.nodeName&&e.nodeName.toLowerCase();return"select"===t||"input"===t&&"file"===e.type}function o(e){var t=x.getPooled(P.change,S,e,w(e));_.accumulateTwoPhaseDispatches(t),E.batchedUpdates(i,t)}function i(e){y.enqueueEvents(e),y.processEventQueue(!1)}function a(e,t){N=e,S=t,N.attachEvent("onchange",o)}function s(){N&&(N.detachEvent("onchange",o),N=null,S=null)}function u(e,t){if("topChange"===e)return t}function l(e,t,n){"topFocus"===e?(s(),a(t,n)):"topBlur"===e&&s()}function c(e,t){N=e,S=t,M=e.value,I=Object.getOwnPropertyDescriptor(e.constructor.prototype,"value"),Object.defineProperty(N,"value",A),N.attachEvent?N.attachEvent("onpropertychange",d):N.addEventListener("propertychange",d,!1)}function p(){N&&(delete N.value,N.detachEvent?N.detachEvent("onpropertychange",d):N.removeEventListener("propertychange",d,!1),N=null,S=null,M=null,I=null)}function d(e){if("value"===e.propertyName){var t=e.srcElement.value;t!==M&&(M=t,o(e))}}function f(e,t){if("topInput"===e)return t}function h(e,t,n){"topFocus"===e?(p(),c(t,n)):"topBlur"===e&&p()}function m(e,t){if(("topSelectionChange"===e||"topKeyUp"===e||"topKeyDown"===e)&&N&&N.value!==M)return M=N.value,S}function v(e){return e.nodeName&&"input"===e.nodeName.toLowerCase()&&("checkbox"===e.type||"radio"===e.type)}function g(e,t){if("topClick"===e)return t}var y=e(16),_=e(19),C=e(123),b=e(33),E=e(71),x=e(80),w=e(102),T=e(110),k=e(111),P={change:{phasedRegistrationNames:{bubbled:"onChange",captured:"onChangeCapture"},dependencies:["topBlur","topChange","topClick","topFocus","topInput","topKeyDown","topKeyUp","topSelectionChange"]}},N=null,S=null,M=null,I=null,O=!1;C.canUseDOM&&(O=T("change")&&(!document.documentMode||document.documentMode>8));var R=!1;C.canUseDOM&&(R=T("input")&&(!document.documentMode||document.documentMode>11));var A={get:function(){return I.get.call(this)},set:function(e){M=""+e,I.set.call(this,e)}},D={eventTypes:P,extractEvents:function(e,t,n,o){var i,a,s=t?b.getNodeFromInstance(t):window;if(r(s)?O?i=u:a=l:k(s)?R?i=f:(i=m,a=h):v(s)&&(i=g),i){var c=i(e,t);if(c){var p=x.getPooled(P.change,c,n,o);return p.type="change",_.accumulateTwoPhaseDispatches(p),p}}a&&a(e,s,t)}};t.exports=D},{102:102,110:110,111:111,123:123,16:16,19:19,33:33,71:71,80:80}],8:[function(e,t,n){"use strict";function r(e,t){return Array.isArray(t)&&(t=t[1]),t?t.nextSibling:e.firstChild}function o(e,t,n){c.insertTreeBefore(e,t,n)}function i(e,t,n){Array.isArray(t)?s(e,t[0],t[1],n):m(e,t,n)}function a(e,t){if(Array.isArray(t)){var n=t[1];t=t[0],u(e,t,n),e.removeChild(n)}e.removeChild(t)}function s(e,t,n,r){for(var o=t;;){var i=o.nextSibling;if(m(e,o,r),o===n)break;o=i}}function u(e,t,n){for(;;){var r=t.nextSibling;if(r===n)break;e.removeChild(r)}}function l(e,t,n){var r=e.parentNode,o=e.nextSibling;o===t?n&&m(r,document.createTextNode(n),o):n?(h(o,n),u(r,o,t)):u(r,e,t)}var c=e(9),p=e(13),d=(e(33),e(58),e(93)),f=e(115),h=e(116),m=d(function(e,t,n){e.insertBefore(t,n)}),v=p.dangerouslyReplaceNodeWithMarkup,g={dangerouslyReplaceNodeWithMarkup:v,replaceDelimitedText:l,processUpdates:function(e,t){for(var n=0;n<t.length;n++){var s=t[n];switch(s.type){case"INSERT_MARKUP":o(e,s.content,r(e,s.afterNode));break;case"MOVE_EXISTING":i(e,s.fromNode,r(e,s.afterNode));break;case"SET_MARKUP":f(e,s.content);break;case"TEXT_CONTENT":h(e,s.content);break;case"REMOVE_NODE":a(e,s.fromNode)}}}};t.exports=g},{115:115,116:116,13:13,33:33,58:58,9:9,93:93}],9:[function(e,t,n){"use strict";function r(e){if(v){var t=e.node,n=e.children;if(n.length)for(var r=0;r<n.length;r++)g(t,n[r],null);else null!=e.html?p(t,e.html):null!=e.text&&f(t,e.text)}}function o(e,t){e.parentNode.replaceChild(t.node,e),r(t)}function i(e,t){v?e.children.push(t):e.node.appendChild(t.node)}function a(e,t){v?e.html=t:p(e.node,t)}function s(e,t){v?e.text=t:f(e.node,t)}function u(){return this.node.nodeName}function l(e){return{node:e,children:[],html:null,text:null,toString:u}}var c=e(10),p=e(115),d=e(93),f=e(116),h=1,m=11,v="undefined"!=typeof document&&"number"==typeof document.documentMode||"undefined"!=typeof navigator&&"string"==typeof navigator.userAgent&&/\bEdge\/\d/.test(navigator.userAgent),g=d(function(e,t,n){t.node.nodeType===m||t.node.nodeType===h&&"object"===t.node.nodeName.toLowerCase()&&(null==t.node.namespaceURI||t.node.namespaceURI===c.html)?(r(t),e.insertBefore(t.node,n)):(e.insertBefore(t.node,n),r(t))});l.insertTreeBefore=g,l.replaceChildWithTree=o,l.queueChild=i,l.queueHTML=a,l.queueText=s,t.exports=l},{10:10,115:115,116:116,93:93}],10:[function(e,t,n){"use strict";var r={html:"http://www.w3.org/1999/xhtml",mathml:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg"};t.exports=r},{}],11:[function(e,t,n){"use strict";function r(e,t){return(e&t)===t}var o=e(113),i=(e(137),{MUST_USE_PROPERTY:1,HAS_BOOLEAN_VALUE:4,HAS_NUMERIC_VALUE:8,HAS_POSITIVE_NUMERIC_VALUE:24,HAS_OVERLOADED_BOOLEAN_VALUE:32,injectDOMPropertyConfig:function(e){var t=i,n=e.Properties||{},a=e.DOMAttributeNamespaces||{},u=e.DOMAttributeNames||{},l=e.DOMPropertyNames||{},c=e.DOMMutationMethods||{};e.isCustomAttribute&&s._isCustomAttributeFunctions.push(e.isCustomAttribute);for(var p in n){s.properties.hasOwnProperty(p)?o("48",p):void 0;var d=p.toLowerCase(),f=n[p],h={attributeName:d,attributeNamespace:null,propertyName:p,mutationMethod:null,mustUseProperty:r(f,t.MUST_USE_PROPERTY),hasBooleanValue:r(f,t.HAS_BOOLEAN_VALUE),hasNumericValue:r(f,t.HAS_NUMERIC_VALUE),hasPositiveNumericValue:r(f,t.HAS_POSITIVE_NUMERIC_VALUE),hasOverloadedBooleanValue:r(f,t.HAS_OVERLOADED_BOOLEAN_VALUE)};if(h.hasBooleanValue+h.hasNumericValue+h.hasOverloadedBooleanValue<=1?void 0:o("50",p),u.hasOwnProperty(p)){var m=u[p];h.attributeName=m}a.hasOwnProperty(p)&&(h.attributeNamespace=a[p]),l.hasOwnProperty(p)&&(h.propertyName=l[p]),c.hasOwnProperty(p)&&(h.mutationMethod=c[p]),s.properties[p]=h}}}),a=":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD",s={ID_ATTRIBUTE_NAME:"data-reactid",ROOT_ATTRIBUTE_NAME:"data-reactroot",ATTRIBUTE_NAME_START_CHAR:a,ATTRIBUTE_NAME_CHAR:a+"\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040",properties:{},getPossibleStandardName:null,_isCustomAttributeFunctions:[],isCustomAttribute:function(e){for(var t=0;t<s._isCustomAttributeFunctions.length;t++){var n=s._isCustomAttributeFunctions[t];if(n(e))return!0}return!1},injection:i};t.exports=s},{113:113,137:137}],12:[function(e,t,n){"use strict";function r(e){return!!l.hasOwnProperty(e)||!u.hasOwnProperty(e)&&(s.test(e)?(l[e]=!0,!0):(u[e]=!0,!1))}function o(e,t){return null==t||e.hasBooleanValue&&!t||e.hasNumericValue&&isNaN(t)||e.hasPositiveNumericValue&&t<1||e.hasOverloadedBooleanValue&&t===!1}var i=e(11),a=(e(33),e(58),e(112)),s=(e(142),new RegExp("^["+i.ATTRIBUTE_NAME_START_CHAR+"]["+i.ATTRIBUTE_NAME_CHAR+"]*$")),u={},l={},c={createMarkupForID:function(e){return i.ID_ATTRIBUTE_NAME+"="+a(e)},setAttributeForID:function(e,t){e.setAttribute(i.ID_ATTRIBUTE_NAME,t)},createMarkupForRoot:function(){return i.ROOT_ATTRIBUTE_NAME+'=""'},setAttributeForRoot:function(e){e.setAttribute(i.ROOT_ATTRIBUTE_NAME,"")},createMarkupForProperty:function(e,t){var n=i.properties.hasOwnProperty(e)?i.properties[e]:null;if(n){if(o(n,t))return"";var r=n.attributeName;return n.hasBooleanValue||n.hasOverloadedBooleanValue&&t===!0?r+'=""':r+"="+a(t)}return i.isCustomAttribute(e)?null==t?"":e+"="+a(t):null},createMarkupForCustomAttribute:function(e,t){return r(e)&&null!=t?e+"="+a(t):""},setValueForProperty:function(e,t,n){var r=i.properties.hasOwnProperty(t)?i.properties[t]:null;if(r){var a=r.mutationMethod;if(a)a(e,n);else{if(o(r,n))return void this.deleteValueForProperty(e,t);if(r.mustUseProperty)e[r.propertyName]=n;else{var s=r.attributeName,u=r.attributeNamespace;u?e.setAttributeNS(u,s,""+n):r.hasBooleanValue||r.hasOverloadedBooleanValue&&n===!0?e.setAttribute(s,""):e.setAttribute(s,""+n)}}}else if(i.isCustomAttribute(t))return void c.setValueForAttribute(e,t,n)},setValueForAttribute:function(e,t,n){r(t)&&(null==n?e.removeAttribute(t):e.setAttribute(t,""+n))},deleteValueForAttribute:function(e,t){e.removeAttribute(t)},deleteValueForProperty:function(e,t){var n=i.properties.hasOwnProperty(t)?i.properties[t]:null;if(n){var r=n.mutationMethod;if(r)r(e,void 0);else if(n.mustUseProperty){var o=n.propertyName;n.hasBooleanValue?e[o]=!1:e[o]=""}else e.removeAttribute(n.attributeName)}else i.isCustomAttribute(t)&&e.removeAttribute(t)}};t.exports=c},{11:11,112:112,142:142,33:33,58:58}],13:[function(e,t,n){"use strict";var r=e(113),o=e(9),i=e(123),a=e(128),s=e(129),u=(e(137),{dangerouslyReplaceNodeWithMarkup:function(e,t){if(i.canUseDOM?void 0:r("56"),t?void 0:r("57"),"HTML"===e.nodeName?r("58"):void 0,"string"==typeof t){var n=a(t,s)[0];e.parentNode.replaceChild(n,e)}else o.replaceChildWithTree(e,t)}});t.exports=u},{113:113,123:123,128:128,129:129,137:137,9:9}],14:[function(e,t,n){"use strict";var r=["ResponderEventPlugin","SimpleEventPlugin","TapEventPlugin","EnterLeaveEventPlugin","ChangeEventPlugin","SelectEventPlugin","BeforeInputEventPlugin"];t.exports=r},{}],15:[function(e,t,n){"use strict";var r=e(19),o=e(33),i=e(84),a={mouseEnter:{registrationName:"onMouseEnter",dependencies:["topMouseOut","topMouseOver"]},mouseLeave:{registrationName:"onMouseLeave",dependencies:["topMouseOut","topMouseOver"]}},s={eventTypes:a,extractEvents:function(e,t,n,s){if("topMouseOver"===e&&(n.relatedTarget||n.fromElement))return null;if("topMouseOut"!==e&&"topMouseOver"!==e)return null;var u;if(s.window===s)u=s;else{var l=s.ownerDocument;u=l?l.defaultView||l.parentWindow:window}var c,p;if("topMouseOut"===e){c=t;var d=n.relatedTarget||n.toElement;p=d?o.getClosestInstanceFromNode(d):null}else c=null,p=t;if(c===p)return null;var f=null==c?u:o.getNodeFromInstance(c),h=null==p?u:o.getNodeFromInstance(p),m=i.getPooled(a.mouseLeave,c,n,s);m.type="mouseleave",m.target=f,m.relatedTarget=h;var v=i.getPooled(a.mouseEnter,p,n,s);return v.type="mouseenter",v.target=h,v.relatedTarget=f,r.accumulateEnterLeaveDispatches(m,v,c,p),[m,v]}};t.exports=s},{19:19,33:33,84:84}],16:[function(e,t,n){"use strict";function r(e){return"button"===e||"input"===e||"select"===e||"textarea"===e}function o(e,t,n){switch(e){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":return!(!n.disabled||!r(t));default:return!1}}var i=e(113),a=e(17),s=e(18),u=e(50),l=e(91),c=e(98),p=(e(137),{}),d=null,f=function(e,t){e&&(s.executeDispatchesInOrder(e,t),e.isPersistent()||e.constructor.release(e))},h=function(e){return f(e,!0)},m=function(e){return f(e,!1)},v=function(e){return"."+e._rootNodeID},g={injection:{injectEventPluginOrder:a.injectEventPluginOrder,injectEventPluginsByName:a.injectEventPluginsByName},putListener:function(e,t,n){"function"!=typeof n?i("94",t,typeof n):void 0;var r=v(e),o=p[t]||(p[t]={});o[r]=n;var s=a.registrationNameModules[t];s&&s.didPutListener&&s.didPutListener(e,t,n)},getListener:function(e,t){var n=p[t];if(o(t,e._currentElement.type,e._currentElement.props))return null;var r=v(e);return n&&n[r]},deleteListener:function(e,t){var n=a.registrationNameModules[t];n&&n.willDeleteListener&&n.willDeleteListener(e,t);var r=p[t];if(r){var o=v(e);delete r[o]}},deleteAllListeners:function(e){var t=v(e);for(var n in p)if(p.hasOwnProperty(n)&&p[n][t]){var r=a.registrationNameModules[n];r&&r.willDeleteListener&&r.willDeleteListener(e,n),delete p[n][t]}},extractEvents:function(e,t,n,r){for(var o,i=a.plugins,s=0;s<i.length;s++){var u=i[s];if(u){var c=u.extractEvents(e,t,n,r);c&&(o=l(o,c))}}return o},enqueueEvents:function(e){e&&(d=l(d,e))},processEventQueue:function(e){var t=d;d=null,e?c(t,h):c(t,m),d?i("95"):void 0,u.rethrowCaughtError()},__purge:function(){p={}},__getListenerBank:function(){return p}};t.exports=g},{113:113,137:137,17:17,18:18,50:50,91:91,98:98}],17:[function(e,t,n){"use strict";function r(){if(s)for(var e in u){var t=u[e],n=s.indexOf(e);if(n>-1?void 0:a("96",e),!l.plugins[n]){t.extractEvents?void 0:a("97",e),l.plugins[n]=t;var r=t.eventTypes;for(var i in r)o(r[i],t,i)?void 0:a("98",i,e)}}}function o(e,t,n){l.eventNameDispatchConfigs.hasOwnProperty(n)?a("99",n):void 0,l.eventNameDispatchConfigs[n]=e;var r=e.phasedRegistrationNames;if(r){for(var o in r)if(r.hasOwnProperty(o)){var s=r[o];i(s,t,n)}return!0}return!!e.registrationName&&(i(e.registrationName,t,n),!0)}function i(e,t,n){l.registrationNameModules[e]?a("100",e):void 0,l.registrationNameModules[e]=t,l.registrationNameDependencies[e]=t.eventTypes[n].dependencies}var a=e(113),s=(e(137),null),u={},l={plugins:[],eventNameDispatchConfigs:{},registrationNameModules:{},registrationNameDependencies:{},possibleRegistrationNames:null,injectEventPluginOrder:function(e){s?a("101"):void 0,s=Array.prototype.slice.call(e),r()},injectEventPluginsByName:function(e){var t=!1;for(var n in e)if(e.hasOwnProperty(n)){var o=e[n];u.hasOwnProperty(n)&&u[n]===o||(u[n]?a("102",n):void 0,u[n]=o,t=!0)}t&&r()},getPluginModuleForEvent:function(e){var t=e.dispatchConfig;if(t.registrationName)return l.registrationNameModules[t.registrationName]||null;if(void 0!==t.phasedRegistrationNames){var n=t.phasedRegistrationNames;for(var r in n)if(n.hasOwnProperty(r)){var o=l.registrationNameModules[n[r]];if(o)return o}}return null},_resetEventPlugins:function(){s=null;for(var e in u)u.hasOwnProperty(e)&&delete u[e];l.plugins.length=0;var t=l.eventNameDispatchConfigs;for(var n in t)t.hasOwnProperty(n)&&delete t[n];var r=l.registrationNameModules;for(var o in r)r.hasOwnProperty(o)&&delete r[o]}};t.exports=l},{113:113,137:137}],18:[function(e,t,n){"use strict";function r(e){return"topMouseUp"===e||"topTouchEnd"===e||"topTouchCancel"===e}function o(e){return"topMouseMove"===e||"topTouchMove"===e}function i(e){return"topMouseDown"===e||"topTouchStart"===e}function a(e,t,n,r){var o=e.type||"unknown-event";e.currentTarget=g.getNodeFromInstance(r),t?m.invokeGuardedCallbackWithCatch(o,n,e):m.invokeGuardedCallback(o,n,e),e.currentTarget=null}function s(e,t){var n=e._dispatchListeners,r=e._dispatchInstances;if(Array.isArray(n))for(var o=0;o<n.length&&!e.isPropagationStopped();o++)a(e,t,n[o],r[o]);else n&&a(e,t,n,r);e._dispatchListeners=null,e._dispatchInstances=null}function u(e){var t=e._dispatchListeners,n=e._dispatchInstances;if(Array.isArray(t)){for(var r=0;r<t.length&&!e.isPropagationStopped();r++)if(t[r](e,n[r]))return n[r]}else if(t&&t(e,n))return n;return null}function l(e){var t=u(e);return e._dispatchInstances=null,e._dispatchListeners=null,t}function c(e){var t=e._dispatchListeners,n=e._dispatchInstances;Array.isArray(t)?h("103"):void 0,e.currentTarget=t?g.getNodeFromInstance(n):null;var r=t?t(e):null;return e.currentTarget=null,e._dispatchListeners=null,e._dispatchInstances=null,r}function p(e){return!!e._dispatchListeners}var d,f,h=e(113),m=e(50),v=(e(137),e(142),{injectComponentTree:function(e){d=e},injectTreeTraversal:function(e){f=e}}),g={isEndish:r,isMoveish:o,isStartish:i,executeDirectDispatch:c,executeDispatchesInOrder:s,executeDispatchesInOrderStopAtTrue:l,hasDispatches:p,getInstanceFromNode:function(e){return d.getInstanceFromNode(e)},getNodeFromInstance:function(e){return d.getNodeFromInstance(e)},isAncestor:function(e,t){return f.isAncestor(e,t)},getLowestCommonAncestor:function(e,t){return f.getLowestCommonAncestor(e,t)},getParentInstance:function(e){return f.getParentInstance(e)},traverseTwoPhase:function(e,t,n){return f.traverseTwoPhase(e,t,n)},traverseEnterLeave:function(e,t,n,r,o){return f.traverseEnterLeave(e,t,n,r,o)},injection:v};t.exports=g},{113:113,137:137,142:142,50:50}],19:[function(e,t,n){"use strict";function r(e,t,n){var r=t.dispatchConfig.phasedRegistrationNames[n];return g(e,r)}function o(e,t,n){var o=r(e,n,t);o&&(n._dispatchListeners=m(n._dispatchListeners,o),n._dispatchInstances=m(n._dispatchInstances,e))}function i(e){e&&e.dispatchConfig.phasedRegistrationNames&&h.traverseTwoPhase(e._targetInst,o,e)}function a(e){if(e&&e.dispatchConfig.phasedRegistrationNames){var t=e._targetInst,n=t?h.getParentInstance(t):null;h.traverseTwoPhase(n,o,e)}}function s(e,t,n){if(n&&n.dispatchConfig.registrationName){var r=n.dispatchConfig.registrationName,o=g(e,r);o&&(n._dispatchListeners=m(n._dispatchListeners,o),n._dispatchInstances=m(n._dispatchInstances,e))}}function u(e){e&&e.dispatchConfig.registrationName&&s(e._targetInst,null,e)}function l(e){v(e,i)}function c(e){v(e,a)}function p(e,t,n,r){h.traverseEnterLeave(n,r,s,e,t)}function d(e){v(e,u)}var f=e(16),h=e(18),m=e(91),v=e(98),g=(e(142),f.getListener),y={accumulateTwoPhaseDispatches:l,accumulateTwoPhaseDispatchesSkipTarget:c,accumulateDirectDispatches:d,accumulateEnterLeaveDispatches:p};t.exports=y},{142:142,16:16,18:18,91:91,98:98}],20:[function(e,t,n){"use strict";function r(e){this._root=e,this._startText=this.getText(),this._fallbackText=null}var o=e(143),i=e(24),a=e(107);o(r.prototype,{destructor:function(){this._root=null,this._startText=null,this._fallbackText=null},getText:function(){return"value"in this._root?this._root.value:this._root[a()]},getData:function(){if(this._fallbackText)return this._fallbackText;var e,t,n=this._startText,r=n.length,o=this.getText(),i=o.length;for(e=0;e<r&&n[e]===o[e];e++);var a=r-e;for(t=1;t<=a&&n[r-t]===o[i-t];t++);var s=t>1?1-t:void 0;return this._fallbackText=o.slice(e,s),this._fallbackText}}),i.addPoolingTo(r),t.exports=r},{107:107,143:143,24:24}],21:[function(e,t,n){"use strict";var r=e(11),o=r.injection.MUST_USE_PROPERTY,i=r.injection.HAS_BOOLEAN_VALUE,a=r.injection.HAS_NUMERIC_VALUE,s=r.injection.HAS_POSITIVE_NUMERIC_VALUE,u=r.injection.HAS_OVERLOADED_BOOLEAN_VALUE,l={isCustomAttribute:RegExp.prototype.test.bind(new RegExp("^(data|aria)-["+r.ATTRIBUTE_NAME_CHAR+"]*$")),Properties:{accept:0,acceptCharset:0,accessKey:0,action:0,allowFullScreen:i,allowTransparency:0,alt:0,as:0,async:i,autoComplete:0,autoPlay:i,capture:i,cellPadding:0,cellSpacing:0,charSet:0,challenge:0,checked:o|i,cite:0,classID:0,className:0,cols:s,colSpan:0,content:0,contentEditable:0,contextMenu:0,controls:i,coords:0,crossOrigin:0,data:0,dateTime:0,default:i,defer:i,dir:0,disabled:i,download:u,draggable:0,encType:0,form:0,formAction:0,formEncType:0,formMethod:0,formNoValidate:i,formTarget:0,frameBorder:0,headers:0,height:0,hidden:i,high:0,href:0,hrefLang:0,htmlFor:0,httpEquiv:0,icon:0,id:0,inputMode:0,integrity:0,is:0,keyParams:0,keyType:0,kind:0,label:0,lang:0,list:0,loop:i,low:0,manifest:0,marginHeight:0,marginWidth:0,max:0,maxLength:0,media:0,mediaGroup:0,method:0,min:0,minLength:0,multiple:o|i,muted:o|i,name:0,nonce:0,noValidate:i,open:i,optimum:0,pattern:0,placeholder:0,playsInline:i,poster:0,preload:0,profile:0,radioGroup:0,readOnly:i,referrerPolicy:0,rel:0,required:i,reversed:i,role:0,rows:s,rowSpan:a,sandbox:0,scope:0,scoped:i,scrolling:0,seamless:i,selected:o|i,shape:0,size:s,sizes:0,span:s,spellCheck:0,src:0,srcDoc:0,srcLang:0,srcSet:0,start:a,step:0,style:0,summary:0,tabIndex:0,target:0,title:0,type:0,useMap:0,value:0,width:0,wmode:0,wrap:0,about:0,datatype:0,inlist:0,prefix:0,property:0,resource:0,typeof:0,vocab:0,autoCapitalize:0,autoCorrect:0,autoSave:0,color:0,itemProp:0,itemScope:i,itemType:0,itemID:0,itemRef:0,results:0,security:0,unselectable:0},DOMAttributeNames:{acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},DOMPropertyNames:{}};t.exports=l},{11:11}],22:[function(e,t,n){"use strict";function r(e){var t=/[=:]/g,n={"=":"=0",":":"=2"},r=(""+e).replace(t,function(e){return n[e]});return"$"+r}function o(e){var t=/(=0|=2)/g,n={"=0":"=","=2":":"},r="."===e[0]&&"$"===e[1]?e.substring(2):e.substring(1);return(""+r).replace(t,function(e){return n[e]})}var i={escape:r,unescape:o};t.exports=i},{}],23:[function(e,t,n){"use strict";function r(e){null!=e.checkedLink&&null!=e.valueLink?s("87"):void 0}function o(e){r(e),null!=e.value||null!=e.onChange?s("88"):void 0}function i(e){r(e),null!=e.checked||null!=e.onChange?s("89"):void 0}function a(e){if(e){var t=e.getName();if(t)return" Check the render method of `"+t+"`."}return""}var s=e(113),u=e(121),l=e(64),c=(e(137),e(142),{button:!0,checkbox:!0,image:!0,hidden:!0,radio:!0,reset:!0,submit:!0}),p={value:function(e,t,n){return!e[t]||c[e.type]||e.onChange||e.readOnly||e.disabled?null:new Error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`.")},checked:function(e,t,n){return!e[t]||e.onChange||e.readOnly||e.disabled?null:new Error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`.")},onChange:u.PropTypes.func},d={},f={checkPropTypes:function(e,t,n){for(var r in p){if(p.hasOwnProperty(r))var o=p[r](t,r,e,"prop",null,l);o instanceof Error&&!(o.message in d)&&(d[o.message]=!0,a(n))}},getValue:function(e){return e.valueLink?(o(e),e.valueLink.value):e.value},getChecked:function(e){return e.checkedLink?(i(e),e.checkedLink.value):e.checked},executeOnChange:function(e,t){return e.valueLink?(o(e),e.valueLink.requestChange(t.target.value)):e.checkedLink?(i(e),e.checkedLink.requestChange(t.target.checked)):e.onChange?e.onChange.call(void 0,t):void 0}};t.exports=f},{113:113,121:121,137:137,142:142,64:64}],24:[function(e,t,n){"use strict";var r=e(113),o=(e(137),function(e){var t=this;if(t.instancePool.length){var n=t.instancePool.pop();return t.call(n,e),n}return new t(e)}),i=function(e,t){var n=this;if(n.instancePool.length){var r=n.instancePool.pop();return n.call(r,e,t),r}return new n(e,t)},a=function(e,t,n){var r=this;if(r.instancePool.length){var o=r.instancePool.pop();return r.call(o,e,t,n),o}return new r(e,t,n)},s=function(e,t,n,r){var o=this;if(o.instancePool.length){var i=o.instancePool.pop();return o.call(i,e,t,n,r),i}return new o(e,t,n,r)},u=function(e){var t=this;e instanceof t?void 0:r("25"),e.destructor(),t.instancePool.length<t.poolSize&&t.instancePool.push(e)},l=10,c=o,p=function(e,t){var n=e;return n.instancePool=[],n.getPooled=t||c,n.poolSize||(n.poolSize=l),n.release=u,n},d={addPoolingTo:p,oneArgumentPooler:o,twoArgumentPooler:i,threeArgumentPooler:a,fourArgumentPooler:s};t.exports=d},{113:113,137:137}],25:[function(e,t,n){"use strict";function r(e){return Object.prototype.hasOwnProperty.call(e,m)||(e[m]=f++,p[e[m]]={}),p[e[m]]}var o,i=e(143),a=e(17),s=e(51),u=e(90),l=e(108),c=e(110),p={},d=!1,f=0,h={topAbort:"abort",topAnimationEnd:l("animationend")||"animationend",topAnimationIteration:l("animationiteration")||"animationiteration",topAnimationStart:l("animationstart")||"animationstart",topBlur:"blur",topCanPlay:"canplay",topCanPlayThrough:"canplaythrough",topChange:"change",topClick:"click",topCompositionEnd:"compositionend",topCompositionStart:"compositionstart",topCompositionUpdate:"compositionupdate",topContextMenu:"contextmenu",topCopy:"copy",topCut:"cut",topDoubleClick:"dblclick",topDrag:"drag",topDragEnd:"dragend",topDragEnter:"dragenter",topDragExit:"dragexit",topDragLeave:"dragleave",topDragOver:"dragover",topDragStart:"dragstart",topDrop:"drop",topDurationChange:"durationchange",topEmptied:"emptied",topEncrypted:"encrypted",topEnded:"ended",topError:"error",topFocus:"focus",topInput:"input",topKeyDown:"keydown",topKeyPress:"keypress",topKeyUp:"keyup",topLoadedData:"loadeddata",topLoadedMetadata:"loadedmetadata",topLoadStart:"loadstart",topMouseDown:"mousedown",topMouseMove:"mousemove",topMouseOut:"mouseout",topMouseOver:"mouseover",topMouseUp:"mouseup",topPaste:"paste",topPause:"pause",
+topPlay:"play",topPlaying:"playing",topProgress:"progress",topRateChange:"ratechange",topScroll:"scroll",topSeeked:"seeked",topSeeking:"seeking",topSelectionChange:"selectionchange",topStalled:"stalled",topSuspend:"suspend",topTextInput:"textInput",topTimeUpdate:"timeupdate",topTouchCancel:"touchcancel",topTouchEnd:"touchend",topTouchMove:"touchmove",topTouchStart:"touchstart",topTransitionEnd:l("transitionend")||"transitionend",topVolumeChange:"volumechange",topWaiting:"waiting",topWheel:"wheel"},m="_reactListenersID"+String(Math.random()).slice(2),v=i({},s,{ReactEventListener:null,injection:{injectReactEventListener:function(e){e.setHandleTopLevel(v.handleTopLevel),v.ReactEventListener=e}},setEnabled:function(e){v.ReactEventListener&&v.ReactEventListener.setEnabled(e)},isEnabled:function(){return!(!v.ReactEventListener||!v.ReactEventListener.isEnabled())},listenTo:function(e,t){for(var n=t,o=r(n),i=a.registrationNameDependencies[e],s=0;s<i.length;s++){var u=i[s];o.hasOwnProperty(u)&&o[u]||("topWheel"===u?c("wheel")?v.ReactEventListener.trapBubbledEvent("topWheel","wheel",n):c("mousewheel")?v.ReactEventListener.trapBubbledEvent("topWheel","mousewheel",n):v.ReactEventListener.trapBubbledEvent("topWheel","DOMMouseScroll",n):"topScroll"===u?c("scroll",!0)?v.ReactEventListener.trapCapturedEvent("topScroll","scroll",n):v.ReactEventListener.trapBubbledEvent("topScroll","scroll",v.ReactEventListener.WINDOW_HANDLE):"topFocus"===u||"topBlur"===u?(c("focus",!0)?(v.ReactEventListener.trapCapturedEvent("topFocus","focus",n),v.ReactEventListener.trapCapturedEvent("topBlur","blur",n)):c("focusin")&&(v.ReactEventListener.trapBubbledEvent("topFocus","focusin",n),v.ReactEventListener.trapBubbledEvent("topBlur","focusout",n)),o.topBlur=!0,o.topFocus=!0):h.hasOwnProperty(u)&&v.ReactEventListener.trapBubbledEvent(u,h[u],n),o[u]=!0)}},trapBubbledEvent:function(e,t,n){return v.ReactEventListener.trapBubbledEvent(e,t,n)},trapCapturedEvent:function(e,t,n){return v.ReactEventListener.trapCapturedEvent(e,t,n)},supportsEventPageXY:function(){if(!document.createEvent)return!1;var e=document.createEvent("MouseEvent");return null!=e&&"pageX"in e},ensureScrollValueMonitoring:function(){if(void 0===o&&(o=v.supportsEventPageXY()),!o&&!d){var e=u.refreshScrollValues;v.ReactEventListener.monitorScrollValue(e),d=!0}}});t.exports=v},{108:108,110:110,143:143,17:17,51:51,90:90}],26:[function(e,t,n){(function(n){"use strict";function r(e,t,n,r){var o=void 0===e[n];null!=t&&o&&(e[n]=i(t,!0))}var o=e(66),i=e(109),a=(e(22),e(117)),s=e(118);e(142);"undefined"!=typeof n&&n.env,1;var u={instantiateChildren:function(e,t,n,o){if(null==e)return null;var i={};return s(e,r,i),i},updateChildren:function(e,t,n,r,s,u,l,c,p){if(t||e){var d,f;for(d in t)if(t.hasOwnProperty(d)){f=e&&e[d];var h=f&&f._currentElement,m=t[d];if(null!=f&&a(h,m))o.receiveComponent(f,m,s,c),t[d]=f;else{f&&(r[d]=o.getHostNode(f),o.unmountComponent(f,!1));var v=i(m,!0);t[d]=v;var g=o.mountComponent(v,s,u,l,c,p);n.push(g)}}for(d in e)!e.hasOwnProperty(d)||t&&t.hasOwnProperty(d)||(f=e[d],r[d]=o.getHostNode(f),o.unmountComponent(f,!1))}},unmountChildren:function(e,t){for(var n in e)if(e.hasOwnProperty(n)){var r=e[n];o.unmountComponent(r,t)}}};t.exports=u}).call(this,void 0)},{109:109,117:117,118:118,142:142,22:22,66:66}],27:[function(e,t,n){"use strict";var r=e(8),o=e(37),i={processChildrenUpdates:o.dangerouslyProcessChildrenUpdates,replaceNodeWithMarkup:r.dangerouslyReplaceNodeWithMarkup};t.exports=i},{37:37,8:8}],28:[function(e,t,n){"use strict";var r=e(113),o=(e(137),!1),i={replaceNodeWithMarkup:null,processChildrenUpdates:null,injection:{injectEnvironment:function(e){o?r("104"):void 0,i.replaceNodeWithMarkup=e.replaceNodeWithMarkup,i.processChildrenUpdates=e.processChildrenUpdates,o=!0}}};t.exports=i},{113:113,137:137}],29:[function(e,t,n){"use strict";function r(e){}function o(e,t){}function i(e){return!(!e.prototype||!e.prototype.isReactComponent)}function a(e){return!(!e.prototype||!e.prototype.isPureReactComponent)}var s=e(113),u=e(143),l=e(121),c=e(28),p=e(120),d=e(50),f=e(57),h=(e(58),e(62)),m=e(66),v=e(130),g=(e(137),e(141)),y=e(117),_=(e(142),{ImpureClass:0,PureClass:1,StatelessFunctional:2});r.prototype.render=function(){var e=f.get(this)._currentElement.type,t=e(this.props,this.context,this.updater);return o(e,t),t};var C=1,b={construct:function(e){this._currentElement=e,this._rootNodeID=0,this._compositeType=null,this._instance=null,this._hostParent=null,this._hostContainerInfo=null,this._updateBatchNumber=null,this._pendingElement=null,this._pendingStateQueue=null,this._pendingReplaceState=!1,this._pendingForceUpdate=!1,this._renderedNodeType=null,this._renderedComponent=null,this._context=null,this._mountOrder=0,this._topLevelWrapper=null,this._pendingCallbacks=null,this._calledComponentWillUnmount=!1},mountComponent:function(e,t,n,u){this._context=u,this._mountOrder=C++,this._hostParent=t,this._hostContainerInfo=n;var c,p=this._currentElement.props,d=this._processContext(u),h=this._currentElement.type,m=e.getUpdateQueue(),g=i(h),y=this._constructComponent(g,p,d,m);g||null!=y&&null!=y.render?a(h)?this._compositeType=_.PureClass:this._compositeType=_.ImpureClass:(c=y,o(h,c),null===y||y===!1||l.isValidElement(y)?void 0:s("105",h.displayName||h.name||"Component"),y=new r(h),this._compositeType=_.StatelessFunctional),y.props=p,y.context=d,y.refs=v,y.updater=m,this._instance=y,f.set(y,this);var b=y.state;void 0===b&&(y.state=b=null),"object"!=typeof b||Array.isArray(b)?s("106",this.getName()||"ReactCompositeComponent"):void 0,this._pendingStateQueue=null,this._pendingReplaceState=!1,this._pendingForceUpdate=!1;var E;return E=y.unstable_handleError?this.performInitialMountWithErrorHandling(c,t,n,e,u):this.performInitialMount(c,t,n,e,u),y.componentDidMount&&e.getReactMountReady().enqueue(y.componentDidMount,y),E},_constructComponent:function(e,t,n,r){return this._constructComponentWithoutOwner(e,t,n,r)},_constructComponentWithoutOwner:function(e,t,n,r){var o=this._currentElement.type;return e?new o(t,n,r):o(t,n,r)},performInitialMountWithErrorHandling:function(e,t,n,r,o){var i,a=r.checkpoint();try{i=this.performInitialMount(e,t,n,r,o)}catch(s){r.rollback(a),this._instance.unstable_handleError(s),this._pendingStateQueue&&(this._instance.state=this._processPendingState(this._instance.props,this._instance.context)),a=r.checkpoint(),this._renderedComponent.unmountComponent(!0),r.rollback(a),i=this.performInitialMount(e,t,n,r,o)}return i},performInitialMount:function(e,t,n,r,o){var i=this._instance,a=0;i.componentWillMount&&(i.componentWillMount(),this._pendingStateQueue&&(i.state=this._processPendingState(i.props,i.context))),void 0===e&&(e=this._renderValidatedComponent());var s=h.getType(e);this._renderedNodeType=s;var u=this._instantiateReactComponent(e,s!==h.EMPTY);this._renderedComponent=u;var l=m.mountComponent(u,r,t,n,this._processChildContext(o),a);return l},getHostNode:function(){return m.getHostNode(this._renderedComponent)},unmountComponent:function(e){if(this._renderedComponent){var t=this._instance;if(t.componentWillUnmount&&!t._calledComponentWillUnmount)if(t._calledComponentWillUnmount=!0,e){var n=this.getName()+".componentWillUnmount()";d.invokeGuardedCallback(n,t.componentWillUnmount.bind(t))}else t.componentWillUnmount();this._renderedComponent&&(m.unmountComponent(this._renderedComponent,e),this._renderedNodeType=null,this._renderedComponent=null,this._instance=null),this._pendingStateQueue=null,this._pendingReplaceState=!1,this._pendingForceUpdate=!1,this._pendingCallbacks=null,this._pendingElement=null,this._context=null,this._rootNodeID=0,this._topLevelWrapper=null,f.remove(t)}},_maskContext:function(e){var t=this._currentElement.type,n=t.contextTypes;if(!n)return v;var r={};for(var o in n)r[o]=e[o];return r},_processContext:function(e){var t=this._maskContext(e);return t},_processChildContext:function(e){var t,n=this._currentElement.type,r=this._instance;if(r.getChildContext&&(t=r.getChildContext()),t){"object"!=typeof n.childContextTypes?s("107",this.getName()||"ReactCompositeComponent"):void 0;for(var o in t)o in n.childContextTypes?void 0:s("108",this.getName()||"ReactCompositeComponent",o);return u({},e,t)}return e},_checkContextTypes:function(e,t,n){},receiveComponent:function(e,t,n){var r=this._currentElement,o=this._context;this._pendingElement=null,this.updateComponent(t,r,e,o,n)},performUpdateIfNecessary:function(e){null!=this._pendingElement?m.receiveComponent(this,this._pendingElement,e,this._context):null!==this._pendingStateQueue||this._pendingForceUpdate?this.updateComponent(e,this._currentElement,this._currentElement,this._context,this._context):this._updateBatchNumber=null},updateComponent:function(e,t,n,r,o){var i=this._instance;null==i?s("136",this.getName()||"ReactCompositeComponent"):void 0;var a,u=!1;this._context===o?a=i.context:(a=this._processContext(o),u=!0);var l=t.props,c=n.props;t!==n&&(u=!0),u&&i.componentWillReceiveProps&&i.componentWillReceiveProps(c,a);var p=this._processPendingState(c,a),d=!0;this._pendingForceUpdate||(i.shouldComponentUpdate?d=i.shouldComponentUpdate(c,p,a):this._compositeType===_.PureClass&&(d=!g(l,c)||!g(i.state,p))),this._updateBatchNumber=null,d?(this._pendingForceUpdate=!1,this._performComponentUpdate(n,c,p,a,e,o)):(this._currentElement=n,this._context=o,i.props=c,i.state=p,i.context=a)},_processPendingState:function(e,t){var n=this._instance,r=this._pendingStateQueue,o=this._pendingReplaceState;if(this._pendingReplaceState=!1,this._pendingStateQueue=null,!r)return n.state;if(o&&1===r.length)return r[0];for(var i=u({},o?r[0]:n.state),a=o?1:0;a<r.length;a++){var s=r[a];u(i,"function"==typeof s?s.call(n,i,e,t):s)}return i},_performComponentUpdate:function(e,t,n,r,o,i){var a,s,u,l=this._instance,c=Boolean(l.componentDidUpdate);c&&(a=l.props,s=l.state,u=l.context),l.componentWillUpdate&&l.componentWillUpdate(t,n,r),this._currentElement=e,this._context=i,l.props=t,l.state=n,l.context=r,this._updateRenderedComponent(o,i),c&&o.getReactMountReady().enqueue(l.componentDidUpdate.bind(l,a,s,u),l)},_updateRenderedComponent:function(e,t){var n=this._renderedComponent,r=n._currentElement,o=this._renderValidatedComponent(),i=0;if(y(r,o))m.receiveComponent(n,o,e,this._processChildContext(t));else{var a=m.getHostNode(n);m.unmountComponent(n,!1);var s=h.getType(o);this._renderedNodeType=s;var u=this._instantiateReactComponent(o,s!==h.EMPTY);this._renderedComponent=u;var l=m.mountComponent(u,e,this._hostParent,this._hostContainerInfo,this._processChildContext(t),i);this._replaceNodeWithMarkup(a,l,n)}},_replaceNodeWithMarkup:function(e,t,n){c.replaceNodeWithMarkup(e,t,n)},_renderValidatedComponentWithoutOwnerOrContext:function(){var e,t=this._instance;return e=t.render()},_renderValidatedComponent:function(){var e;if(this._compositeType!==_.StatelessFunctional){p.current=this;try{e=this._renderValidatedComponentWithoutOwnerOrContext()}finally{p.current=null}}else e=this._renderValidatedComponentWithoutOwnerOrContext();return null===e||e===!1||l.isValidElement(e)?void 0:s("109",this.getName()||"ReactCompositeComponent"),e},attachRef:function(e,t){var n=this.getPublicInstance();null==n?s("110"):void 0;var r=t.getPublicInstance(),o=n.refs===v?n.refs={}:n.refs;o[e]=r},detachRef:function(e){var t=this.getPublicInstance().refs;delete t[e]},getName:function(){var e=this._currentElement.type,t=this._instance&&this._instance.constructor;return e.displayName||t&&t.displayName||e.name||t&&t.name||null},getPublicInstance:function(){var e=this._instance;return this._compositeType===_.StatelessFunctional?null:e},_instantiateReactComponent:null};t.exports=b},{113:113,117:117,120:120,121:121,130:130,137:137,141:141,142:142,143:143,28:28,50:50,57:57,58:58,62:62,66:66}],30:[function(e,t,n){"use strict";var r=e(33),o=e(47),i=e(60),a=e(66),s=e(71),u=e(72),l=e(96),c=e(103),p=e(114);e(142);o.inject();var d={findDOMNode:l,render:i.render,unmountComponentAtNode:i.unmountComponentAtNode,version:u,unstable_batchedUpdates:s.batchedUpdates,unstable_renderSubtreeIntoContainer:p};"undefined"!=typeof __REACT_DEVTOOLS_GLOBAL_HOOK__&&"function"==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject&&__REACT_DEVTOOLS_GLOBAL_HOOK__.inject({ComponentTree:{getClosestInstanceFromNode:r.getClosestInstanceFromNode,getNodeFromInstance:function(e){return e._renderedComponent&&(e=c(e)),e?r.getNodeFromInstance(e):null}},Mount:i,Reconciler:a});t.exports=d},{103:103,114:114,142:142,33:33,47:47,60:60,66:66,71:71,72:72,96:96}],31:[function(e,t,n){"use strict";function r(e){if(e){var t=e._currentElement._owner||null;if(t){var n=t.getName();if(n)return" This DOM node was rendered by `"+n+"`."}}return""}function o(e,t){t&&(X[e._tag]&&(null!=t.children||null!=t.dangerouslySetInnerHTML?m("137",e._tag,e._currentElement._owner?" Check the render method of "+e._currentElement._owner.getName()+".":""):void 0),null!=t.dangerouslySetInnerHTML&&(null!=t.children?m("60"):void 0,"object"==typeof t.dangerouslySetInnerHTML&&W in t.dangerouslySetInnerHTML?void 0:m("61")),null!=t.style&&"object"!=typeof t.style?m("62",r(e)):void 0)}function i(e,t,n,r){if(!(r instanceof R)){var o=e._hostContainerInfo,i=o._node&&o._node.nodeType===q,s=i?o._node:o._ownerDocument;F(t,s),r.getReactMountReady().enqueue(a,{inst:e,registrationName:t,listener:n})}}function a(){var e=this;x.putListener(e.inst,e.registrationName,e.listener)}function s(){var e=this;N.postMountWrapper(e)}function u(){var e=this;I.postMountWrapper(e)}function l(){var e=this;S.postMountWrapper(e)}function c(){var e=this;e._rootNodeID?void 0:m("63");var t=U(e);switch(t?void 0:m("64"),e._tag){case"iframe":case"object":e._wrapperState.listeners=[T.trapBubbledEvent("topLoad","load",t)];break;case"video":case"audio":e._wrapperState.listeners=[];for(var n in K)K.hasOwnProperty(n)&&e._wrapperState.listeners.push(T.trapBubbledEvent(n,K[n],t));break;case"source":e._wrapperState.listeners=[T.trapBubbledEvent("topError","error",t)];break;case"img":e._wrapperState.listeners=[T.trapBubbledEvent("topError","error",t),T.trapBubbledEvent("topLoad","load",t)];break;case"form":e._wrapperState.listeners=[T.trapBubbledEvent("topReset","reset",t),T.trapBubbledEvent("topSubmit","submit",t)];break;case"input":case"select":case"textarea":e._wrapperState.listeners=[T.trapBubbledEvent("topInvalid","invalid",t)]}}function p(){M.postUpdateWrapper(this)}function d(e){$.call(G,e)||(Q.test(e)?void 0:m("65",e),G[e]=!0)}function f(e,t){return e.indexOf("-")>=0||null!=t.is}function h(e){var t=e.type;d(t),this._currentElement=e,this._tag=t.toLowerCase(),this._namespaceURI=null,this._renderedChildren=null,this._previousStyle=null,this._previousStyleCopy=null,this._hostNode=null,this._hostParent=null,this._rootNodeID=0,this._domID=0,this._hostContainerInfo=null,this._wrapperState=null,this._topLevelWrapper=null,this._flags=0}var m=e(113),v=e(143),g=e(2),y=e(5),_=e(9),C=e(10),b=e(11),E=e(12),x=e(16),w=e(17),T=e(25),k=e(32),P=e(33),N=e(38),S=e(39),M=e(40),I=e(43),O=(e(58),e(61)),R=e(68),A=(e(129),e(95)),D=(e(137),e(110),e(141),e(119),e(142),k),L=x.deleteListener,U=P.getNodeFromInstance,F=T.listenTo,V=w.registrationNameModules,B={string:!0,number:!0},j="style",W="__html",H={children:null,dangerouslySetInnerHTML:null,suppressContentEditableWarning:null},q=11,K={topAbort:"abort",topCanPlay:"canplay",topCanPlayThrough:"canplaythrough",topDurationChange:"durationchange",topEmptied:"emptied",topEncrypted:"encrypted",topEnded:"ended",topError:"error",topLoadedData:"loadeddata",topLoadedMetadata:"loadedmetadata",topLoadStart:"loadstart",topPause:"pause",topPlay:"play",topPlaying:"playing",topProgress:"progress",topRateChange:"ratechange",topSeeked:"seeked",topSeeking:"seeking",topStalled:"stalled",topSuspend:"suspend",topTimeUpdate:"timeupdate",topVolumeChange:"volumechange",topWaiting:"waiting"},z={area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0},Y={listing:!0,pre:!0,textarea:!0},X=v({menuitem:!0},z),Q=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,G={},$={}.hasOwnProperty,Z=1;h.displayName="ReactDOMComponent",h.Mixin={mountComponent:function(e,t,n,r){this._rootNodeID=Z++,this._domID=n._idCounter++,this._hostParent=t,this._hostContainerInfo=n;var i=this._currentElement.props;switch(this._tag){case"audio":case"form":case"iframe":case"img":case"link":case"object":case"source":case"video":this._wrapperState={listeners:null},e.getReactMountReady().enqueue(c,this);break;case"input":N.mountWrapper(this,i,t),i=N.getHostProps(this,i),e.getReactMountReady().enqueue(c,this);break;case"option":S.mountWrapper(this,i,t),i=S.getHostProps(this,i);break;case"select":M.mountWrapper(this,i,t),i=M.getHostProps(this,i),e.getReactMountReady().enqueue(c,this);break;case"textarea":I.mountWrapper(this,i,t),i=I.getHostProps(this,i),e.getReactMountReady().enqueue(c,this)}o(this,i);var a,p;null!=t?(a=t._namespaceURI,p=t._tag):n._tag&&(a=n._namespaceURI,p=n._tag),(null==a||a===C.svg&&"foreignobject"===p)&&(a=C.html),a===C.html&&("svg"===this._tag?a=C.svg:"math"===this._tag&&(a=C.mathml)),this._namespaceURI=a;var d;if(e.useCreateElement){var f,h=n._ownerDocument;if(a===C.html)if("script"===this._tag){var m=h.createElement("div"),v=this._currentElement.type;m.innerHTML="<"+v+"></"+v+">",f=m.removeChild(m.firstChild)}else f=i.is?h.createElement(this._currentElement.type,i.is):h.createElement(this._currentElement.type);else f=h.createElementNS(a,this._currentElement.type);P.precacheNode(this,f),this._flags|=D.hasCachedChildNodes,this._hostParent||E.setAttributeForRoot(f),this._updateDOMProperties(null,i,e);var y=_(f);this._createInitialChildren(e,i,r,y),d=y}else{var b=this._createOpenTagMarkupAndPutListeners(e,i),x=this._createContentMarkup(e,i,r);d=!x&&z[this._tag]?b+"/>":b+">"+x+"</"+this._currentElement.type+">"}switch(this._tag){case"input":e.getReactMountReady().enqueue(s,this),i.autoFocus&&e.getReactMountReady().enqueue(g.focusDOMComponent,this);break;case"textarea":e.getReactMountReady().enqueue(u,this),i.autoFocus&&e.getReactMountReady().enqueue(g.focusDOMComponent,this);break;case"select":i.autoFocus&&e.getReactMountReady().enqueue(g.focusDOMComponent,this);break;case"button":i.autoFocus&&e.getReactMountReady().enqueue(g.focusDOMComponent,this);break;case"option":e.getReactMountReady().enqueue(l,this)}return d},_createOpenTagMarkupAndPutListeners:function(e,t){var n="<"+this._currentElement.type;for(var r in t)if(t.hasOwnProperty(r)){var o=t[r];if(null!=o)if(V.hasOwnProperty(r))o&&i(this,r,o,e);else{r===j&&(o&&(o=this._previousStyleCopy=v({},t.style)),o=y.createMarkupForStyles(o,this));var a=null;null!=this._tag&&f(this._tag,t)?H.hasOwnProperty(r)||(a=E.createMarkupForCustomAttribute(r,o)):a=E.createMarkupForProperty(r,o),a&&(n+=" "+a)}}return e.renderToStaticMarkup?n:(this._hostParent||(n+=" "+E.createMarkupForRoot()),n+=" "+E.createMarkupForID(this._domID))},_createContentMarkup:function(e,t,n){var r="",o=t.dangerouslySetInnerHTML;if(null!=o)null!=o.__html&&(r=o.__html);else{var i=B[typeof t.children]?t.children:null,a=null!=i?null:t.children;if(null!=i)r=A(i);else if(null!=a){var s=this.mountChildren(a,e,n);r=s.join("")}}return Y[this._tag]&&"\n"===r.charAt(0)?"\n"+r:r},_createInitialChildren:function(e,t,n,r){var o=t.dangerouslySetInnerHTML;if(null!=o)null!=o.__html&&_.queueHTML(r,o.__html);else{var i=B[typeof t.children]?t.children:null,a=null!=i?null:t.children;if(null!=i)""!==i&&_.queueText(r,i);else if(null!=a)for(var s=this.mountChildren(a,e,n),u=0;u<s.length;u++)_.queueChild(r,s[u])}},receiveComponent:function(e,t,n){var r=this._currentElement;this._currentElement=e,this.updateComponent(t,r,e,n)},updateComponent:function(e,t,n,r){var i=t.props,a=this._currentElement.props;switch(this._tag){case"input":i=N.getHostProps(this,i),a=N.getHostProps(this,a);break;case"option":i=S.getHostProps(this,i),a=S.getHostProps(this,a);break;case"select":i=M.getHostProps(this,i),a=M.getHostProps(this,a);break;case"textarea":i=I.getHostProps(this,i),a=I.getHostProps(this,a)}switch(o(this,a),this._updateDOMProperties(i,a,e),this._updateDOMChildren(i,a,e,r),this._tag){case"input":N.updateWrapper(this);break;case"textarea":I.updateWrapper(this);break;case"select":e.getReactMountReady().enqueue(p,this)}},_updateDOMProperties:function(e,t,n){var r,o,a;for(r in e)if(!t.hasOwnProperty(r)&&e.hasOwnProperty(r)&&null!=e[r])if(r===j){var s=this._previousStyleCopy;for(o in s)s.hasOwnProperty(o)&&(a=a||{},a[o]="");this._previousStyleCopy=null}else V.hasOwnProperty(r)?e[r]&&L(this,r):f(this._tag,e)?H.hasOwnProperty(r)||E.deleteValueForAttribute(U(this),r):(b.properties[r]||b.isCustomAttribute(r))&&E.deleteValueForProperty(U(this),r);for(r in t){var u=t[r],l=r===j?this._previousStyleCopy:null!=e?e[r]:void 0;if(t.hasOwnProperty(r)&&u!==l&&(null!=u||null!=l))if(r===j)if(u?u=this._previousStyleCopy=v({},u):this._previousStyleCopy=null,l){for(o in l)!l.hasOwnProperty(o)||u&&u.hasOwnProperty(o)||(a=a||{},a[o]="");for(o in u)u.hasOwnProperty(o)&&l[o]!==u[o]&&(a=a||{},a[o]=u[o])}else a=u;else if(V.hasOwnProperty(r))u?i(this,r,u,n):l&&L(this,r);else if(f(this._tag,t))H.hasOwnProperty(r)||E.setValueForAttribute(U(this),r,u);else if(b.properties[r]||b.isCustomAttribute(r)){var c=U(this);null!=u?E.setValueForProperty(c,r,u):E.deleteValueForProperty(c,r)}}a&&y.setValueForStyles(U(this),a,this)},_updateDOMChildren:function(e,t,n,r){var o=B[typeof e.children]?e.children:null,i=B[typeof t.children]?t.children:null,a=e.dangerouslySetInnerHTML&&e.dangerouslySetInnerHTML.__html,s=t.dangerouslySetInnerHTML&&t.dangerouslySetInnerHTML.__html,u=null!=o?null:e.children,l=null!=i?null:t.children,c=null!=o||null!=a,p=null!=i||null!=s;null!=u&&null==l?this.updateChildren(null,n,r):c&&!p&&this.updateTextContent(""),null!=i?o!==i&&this.updateTextContent(""+i):null!=s?a!==s&&this.updateMarkup(""+s):null!=l&&this.updateChildren(l,n,r)},getHostNode:function(){return U(this)},unmountComponent:function(e){switch(this._tag){case"audio":case"form":case"iframe":case"img":case"link":case"object":case"source":case"video":var t=this._wrapperState.listeners;if(t)for(var n=0;n<t.length;n++)t[n].remove();break;case"html":case"head":case"body":m("66",this._tag)}this.unmountChildren(e),P.uncacheNode(this),x.deleteAllListeners(this),this._rootNodeID=0,this._domID=0,this._wrapperState=null},getPublicInstance:function(){return U(this)}},v(h.prototype,h.Mixin,O.Mixin),t.exports=h},{10:10,11:11,110:110,113:113,119:119,12:12,129:129,137:137,141:141,142:142,143:143,16:16,17:17,2:2,25:25,32:32,33:33,38:38,39:39,40:40,43:43,5:5,58:58,61:61,68:68,9:9,95:95}],32:[function(e,t,n){"use strict";var r={hasCachedChildNodes:1};t.exports=r},{}],33:[function(e,t,n){"use strict";function r(e,t){return 1===e.nodeType&&e.getAttribute(h)===String(t)||8===e.nodeType&&e.nodeValue===" react-text: "+t+" "||8===e.nodeType&&e.nodeValue===" react-empty: "+t+" "}function o(e){for(var t;t=e._renderedComponent;)e=t;return e}function i(e,t){var n=o(e);n._hostNode=t,t[v]=n}function a(e){var t=e._hostNode;t&&(delete t[v],e._hostNode=null)}function s(e,t){if(!(e._flags&m.hasCachedChildNodes)){var n=e._renderedChildren,a=t.firstChild;e:for(var s in n)if(n.hasOwnProperty(s)){var u=n[s],l=o(u)._domID;if(0!==l){for(;null!==a;a=a.nextSibling)if(r(a,l)){i(u,a);continue e}p("32",l)}}e._flags|=m.hasCachedChildNodes}}function u(e){if(e[v])return e[v];for(var t=[];!e[v];){if(t.push(e),!e.parentNode)return null;e=e.parentNode}for(var n,r;e&&(r=e[v]);e=t.pop())n=r,t.length&&s(r,e);return n}function l(e){var t=u(e);return null!=t&&t._hostNode===e?t:null}function c(e){if(void 0===e._hostNode?p("33"):void 0,e._hostNode)return e._hostNode;for(var t=[];!e._hostNode;)t.push(e),e._hostParent?void 0:p("34"),e=e._hostParent;for(;t.length;e=t.pop())s(e,e._hostNode);return e._hostNode}var p=e(113),d=e(11),f=e(32),h=(e(137),d.ID_ATTRIBUTE_NAME),m=f,v="__reactInternalInstance$"+Math.random().toString(36).slice(2),g={getClosestInstanceFromNode:u,getInstanceFromNode:l,getNodeFromInstance:c,precacheChildNodes:s,precacheNode:i,uncacheNode:a};t.exports=g},{11:11,113:113,137:137,32:32}],34:[function(e,t,n){"use strict";function r(e,t){var n={_topLevelWrapper:e,_idCounter:1,_ownerDocument:t?t.nodeType===o?t:t.ownerDocument:null,_node:t,_tag:t?t.nodeName.toLowerCase():null,_namespaceURI:t?t.namespaceURI:null};return n}var o=(e(119),9);t.exports=r},{119:119}],35:[function(e,t,n){"use strict";var r=e(143),o=e(9),i=e(33),a=function(e){this._currentElement=null,this._hostNode=null,this._hostParent=null,this._hostContainerInfo=null,this._domID=0};r(a.prototype,{mountComponent:function(e,t,n,r){var a=n._idCounter++;this._domID=a,this._hostParent=t,this._hostContainerInfo=n;var s=" react-empty: "+this._domID+" ";if(e.useCreateElement){var u=n._ownerDocument,l=u.createComment(s);return i.precacheNode(this,l),o(l)}return e.renderToStaticMarkup?"":"<!--"+s+"-->"},receiveComponent:function(){},getHostNode:function(){return i.getNodeFromInstance(this)},unmountComponent:function(){i.uncacheNode(this)}}),t.exports=a},{143:143,33:33,9:9}],36:[function(e,t,n){"use strict";var r={useCreateElement:!0,useFiber:!1};t.exports=r},{}],37:[function(e,t,n){"use strict";var r=e(8),o=e(33),i={dangerouslyProcessChildrenUpdates:function(e,t){var n=o.getNodeFromInstance(e);r.processUpdates(n,t)}};t.exports=i},{33:33,8:8}],38:[function(e,t,n){"use strict";function r(){this._rootNodeID&&p.updateWrapper(this)}function o(e){var t=this._currentElement.props,n=u.executeOnChange(t,e);c.asap(r,this);var o=t.name;if("radio"===t.type&&null!=o){for(var a=l.getNodeFromInstance(this),s=a;s.parentNode;)s=s.parentNode;for(var p=s.querySelectorAll("input[name="+JSON.stringify(""+o)+'][type="radio"]'),d=0;d<p.length;d++){var f=p[d];if(f!==a&&f.form===a.form){var h=l.getInstanceFromNode(f);h?void 0:i("90"),c.asap(r,h)}}}return n}var i=e(113),a=e(143),s=e(12),u=e(23),l=e(33),c=e(71),p=(e(137),e(142),{getHostProps:function(e,t){var n=u.getValue(t),r=u.getChecked(t),o=a({type:void 0,step:void 0,min:void 0,max:void 0},t,{defaultChecked:void 0,defaultValue:void 0,value:null!=n?n:e._wrapperState.initialValue,checked:null!=r?r:e._wrapperState.initialChecked,onChange:e._wrapperState.onChange});return o},mountWrapper:function(e,t){var n=t.defaultValue;e._wrapperState={initialChecked:null!=t.checked?t.checked:t.defaultChecked,initialValue:null!=t.value?t.value:n,listeners:null,onChange:o.bind(e)}},updateWrapper:function(e){var t=e._currentElement.props,n=t.checked;null!=n&&s.setValueForProperty(l.getNodeFromInstance(e),"checked",n||!1);var r=l.getNodeFromInstance(e),o=u.getValue(t);if(null!=o){var i=""+o;i!==r.value&&(r.value=i)}else null==t.value&&null!=t.defaultValue&&r.defaultValue!==""+t.defaultValue&&(r.defaultValue=""+t.defaultValue),null==t.checked&&null!=t.defaultChecked&&(r.defaultChecked=!!t.defaultChecked)},postMountWrapper:function(e){var t=e._currentElement.props,n=l.getNodeFromInstance(e);switch(t.type){case"submit":case"reset":break;case"color":case"date":case"datetime":case"datetime-local":case"month":case"time":case"week":n.value="",n.value=n.defaultValue;break;default:n.value=n.value}var r=n.name;""!==r&&(n.name=""),n.defaultChecked=!n.defaultChecked,n.defaultChecked=!n.defaultChecked,""!==r&&(n.name=r)}});t.exports=p},{113:113,12:12,137:137,142:142,143:143,23:23,33:33,71:71}],39:[function(e,t,n){"use strict";function r(e){var t="";return i.Children.forEach(e,function(e){null!=e&&("string"==typeof e||"number"==typeof e?t+=e:u||(u=!0))}),t}var o=e(143),i=e(121),a=e(33),s=e(40),u=(e(142),!1),l={mountWrapper:function(e,t,n){var o=null;if(null!=n){var i=n;"optgroup"===i._tag&&(i=i._hostParent),null!=i&&"select"===i._tag&&(o=s.getSelectValueContext(i))}var a=null;if(null!=o){var u;if(u=null!=t.value?t.value+"":r(t.children),a=!1,Array.isArray(o)){for(var l=0;l<o.length;l++)if(""+o[l]===u){a=!0;break}}else a=""+o===u}e._wrapperState={selected:a}},postMountWrapper:function(e){var t=e._currentElement.props;if(null!=t.value){var n=a.getNodeFromInstance(e);n.setAttribute("value",t.value)}},getHostProps:function(e,t){var n=o({selected:void 0,children:void 0},t);null!=e._wrapperState.selected&&(n.selected=e._wrapperState.selected);var i=r(t.children);return i&&(n.children=i),n}};t.exports=l},{121:121,142:142,143:143,33:33,40:40}],40:[function(e,t,n){"use strict";function r(){if(this._rootNodeID&&this._wrapperState.pendingUpdate){this._wrapperState.pendingUpdate=!1;var e=this._currentElement.props,t=s.getValue(e);null!=t&&o(this,Boolean(e.multiple),t)}}function o(e,t,n){var r,o,i=u.getNodeFromInstance(e).options;if(t){for(r={},o=0;o<n.length;o++)r[""+n[o]]=!0;for(o=0;o<i.length;o++){var a=r.hasOwnProperty(i[o].value);i[o].selected!==a&&(i[o].selected=a)}}else{for(r=""+n,o=0;o<i.length;o++)if(i[o].value===r)return void(i[o].selected=!0);i.length&&(i[0].selected=!0)}}function i(e){var t=this._currentElement.props,n=s.executeOnChange(t,e);return this._rootNodeID&&(this._wrapperState.pendingUpdate=!0),l.asap(r,this),n}var a=e(143),s=e(23),u=e(33),l=e(71),c=(e(142),!1),p={getHostProps:function(e,t){return a({},t,{onChange:e._wrapperState.onChange,value:void 0})},mountWrapper:function(e,t){var n=s.getValue(t);e._wrapperState={pendingUpdate:!1,initialValue:null!=n?n:t.defaultValue,listeners:null,onChange:i.bind(e),wasMultiple:Boolean(t.multiple)},void 0===t.value||void 0===t.defaultValue||c||(c=!0)},getSelectValueContext:function(e){return e._wrapperState.initialValue},postUpdateWrapper:function(e){var t=e._currentElement.props;e._wrapperState.initialValue=void 0;var n=e._wrapperState.wasMultiple;e._wrapperState.wasMultiple=Boolean(t.multiple);var r=s.getValue(t);null!=r?(e._wrapperState.pendingUpdate=!1,o(e,Boolean(t.multiple),r)):n!==Boolean(t.multiple)&&(null!=t.defaultValue?o(e,Boolean(t.multiple),t.defaultValue):o(e,Boolean(t.multiple),t.multiple?[]:""))}};t.exports=p},{142:142,143:143,23:23,33:33,71:71}],41:[function(e,t,n){"use strict";function r(e,t,n,r){return e===n&&t===r}function o(e){var t=document.selection,n=t.createRange(),r=n.text.length,o=n.duplicate();o.moveToElementText(e),o.setEndPoint("EndToStart",n);var i=o.text.length,a=i+r;return{start:i,end:a}}function i(e){var t=window.getSelection&&window.getSelection();if(!t||0===t.rangeCount)return null;var n=t.anchorNode,o=t.anchorOffset,i=t.focusNode,a=t.focusOffset,s=t.getRangeAt(0);try{s.startContainer.nodeType,s.endContainer.nodeType}catch(e){return null}var u=r(t.anchorNode,t.anchorOffset,t.focusNode,t.focusOffset),l=u?0:s.toString().length,c=s.cloneRange();c.selectNodeContents(e),c.setEnd(s.startContainer,s.startOffset);var p=r(c.startContainer,c.startOffset,c.endContainer,c.endOffset),d=p?0:c.toString().length,f=d+l,h=document.createRange();h.setStart(n,o),h.setEnd(i,a);var m=h.collapsed;return{start:m?f:d,end:m?d:f}}function a(e,t){var n,r,o=document.selection.createRange().duplicate();void 0===t.end?(n=t.start,r=n):t.start>t.end?(n=t.end,r=t.start):(n=t.start,r=t.end),o.moveToElementText(e),o.moveStart("character",n),o.setEndPoint("EndToStart",o),o.moveEnd("character",r-n),o.select()}function s(e,t){if(window.getSelection){var n=window.getSelection(),r=e[c()].length,o=Math.min(t.start,r),i=void 0===t.end?o:Math.min(t.end,r);if(!n.extend&&o>i){var a=i;i=o,o=a}var s=l(e,o),u=l(e,i);if(s&&u){var p=document.createRange();p.setStart(s.node,s.offset),n.removeAllRanges(),o>i?(n.addRange(p),n.extend(u.node,u.offset)):(p.setEnd(u.node,u.offset),n.addRange(p))}}}var u=e(123),l=e(106),c=e(107),p=u.canUseDOM&&"selection"in document&&!("getSelection"in window),d={getOffsets:p?o:i,setOffsets:p?a:s};t.exports=d},{106:106,107:107,123:123}],42:[function(e,t,n){"use strict";var r=e(113),o=e(143),i=e(8),a=e(9),s=e(33),u=e(95),l=(e(137),e(119),function(e){this._currentElement=e,this._stringText=""+e,this._hostNode=null,this._hostParent=null,this._domID=0,this._mountIndex=0,this._closingComment=null,this._commentNodes=null});o(l.prototype,{mountComponent:function(e,t,n,r){var o=n._idCounter++,i=" react-text: "+o+" ",l=" /react-text ";if(this._domID=o,this._hostParent=t,e.useCreateElement){
+var c=n._ownerDocument,p=c.createComment(i),d=c.createComment(l),f=a(c.createDocumentFragment());return a.queueChild(f,a(p)),this._stringText&&a.queueChild(f,a(c.createTextNode(this._stringText))),a.queueChild(f,a(d)),s.precacheNode(this,p),this._closingComment=d,f}var h=u(this._stringText);return e.renderToStaticMarkup?h:"<!--"+i+"-->"+h+"<!--"+l+"-->"},receiveComponent:function(e,t){if(e!==this._currentElement){this._currentElement=e;var n=""+e;if(n!==this._stringText){this._stringText=n;var r=this.getHostNode();i.replaceDelimitedText(r[0],r[1],n)}}},getHostNode:function(){var e=this._commentNodes;if(e)return e;if(!this._closingComment)for(var t=s.getNodeFromInstance(this),n=t.nextSibling;;){if(null==n?r("67",this._domID):void 0,8===n.nodeType&&" /react-text "===n.nodeValue){this._closingComment=n;break}n=n.nextSibling}return e=[this._hostNode,this._closingComment],this._commentNodes=e,e},unmountComponent:function(){this._closingComment=null,this._commentNodes=null,s.uncacheNode(this)}}),t.exports=l},{113:113,119:119,137:137,143:143,33:33,8:8,9:9,95:95}],43:[function(e,t,n){"use strict";function r(){this._rootNodeID&&c.updateWrapper(this)}function o(e){var t=this._currentElement.props,n=s.executeOnChange(t,e);return l.asap(r,this),n}var i=e(113),a=e(143),s=e(23),u=e(33),l=e(71),c=(e(137),e(142),{getHostProps:function(e,t){null!=t.dangerouslySetInnerHTML?i("91"):void 0;var n=a({},t,{value:void 0,defaultValue:void 0,children:""+e._wrapperState.initialValue,onChange:e._wrapperState.onChange});return n},mountWrapper:function(e,t){var n=s.getValue(t),r=n;if(null==n){var a=t.defaultValue,u=t.children;null!=u&&(null!=a?i("92"):void 0,Array.isArray(u)&&(u.length<=1?void 0:i("93"),u=u[0]),a=""+u),null==a&&(a=""),r=a}e._wrapperState={initialValue:""+r,listeners:null,onChange:o.bind(e)}},updateWrapper:function(e){var t=e._currentElement.props,n=u.getNodeFromInstance(e),r=s.getValue(t);if(null!=r){var o=""+r;o!==n.value&&(n.value=o),null==t.defaultValue&&(n.defaultValue=o)}null!=t.defaultValue&&(n.defaultValue=t.defaultValue)},postMountWrapper:function(e){var t=u.getNodeFromInstance(e),n=t.textContent;n===e._wrapperState.initialValue&&(t.value=n)}});t.exports=c},{113:113,137:137,142:142,143:143,23:23,33:33,71:71}],44:[function(e,t,n){"use strict";function r(e,t){"_hostNode"in e?void 0:u("33"),"_hostNode"in t?void 0:u("33");for(var n=0,r=e;r;r=r._hostParent)n++;for(var o=0,i=t;i;i=i._hostParent)o++;for(;n-o>0;)e=e._hostParent,n--;for(;o-n>0;)t=t._hostParent,o--;for(var a=n;a--;){if(e===t)return e;e=e._hostParent,t=t._hostParent}return null}function o(e,t){"_hostNode"in e?void 0:u("35"),"_hostNode"in t?void 0:u("35");for(;t;){if(t===e)return!0;t=t._hostParent}return!1}function i(e){return"_hostNode"in e?void 0:u("36"),e._hostParent}function a(e,t,n){for(var r=[];e;)r.push(e),e=e._hostParent;var o;for(o=r.length;o-- >0;)t(r[o],"captured",n);for(o=0;o<r.length;o++)t(r[o],"bubbled",n)}function s(e,t,n,o,i){for(var a=e&&t?r(e,t):null,s=[];e&&e!==a;)s.push(e),e=e._hostParent;for(var u=[];t&&t!==a;)u.push(t),t=t._hostParent;var l;for(l=0;l<s.length;l++)n(s[l],"bubbled",o);for(l=u.length;l-- >0;)n(u[l],"captured",i)}var u=e(113);e(137);t.exports={isAncestor:o,getLowestCommonAncestor:r,getParentInstance:i,traverseTwoPhase:a,traverseEnterLeave:s}},{113:113,137:137}],45:[function(e,t,n){"use strict";var r=e(121),o=e(30),i=o;r.addons&&(r.__SECRET_INJECTED_REACT_DOM_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=i),t.exports=i},{121:121,30:30}],46:[function(e,t,n){"use strict";function r(){this.reinitializeTransaction()}var o=e(143),i=e(71),a=e(89),s=e(129),u={initialize:s,close:function(){d.isBatchingUpdates=!1}},l={initialize:s,close:i.flushBatchedUpdates.bind(i)},c=[l,u];o(r.prototype,a,{getTransactionWrappers:function(){return c}});var p=new r,d={isBatchingUpdates:!1,batchedUpdates:function(e,t,n,r,o,i){var a=d.isBatchingUpdates;return d.isBatchingUpdates=!0,a?e(t,n,r,o,i):p.perform(e,null,t,n,r,o,i)}};t.exports=d},{129:129,143:143,71:71,89:89}],47:[function(e,t,n){"use strict";function r(){x||(x=!0,y.EventEmitter.injectReactEventListener(g),y.EventPluginHub.injectEventPluginOrder(s),y.EventPluginUtils.injectComponentTree(d),y.EventPluginUtils.injectTreeTraversal(h),y.EventPluginHub.injectEventPluginsByName({SimpleEventPlugin:E,EnterLeaveEventPlugin:u,ChangeEventPlugin:a,SelectEventPlugin:b,BeforeInputEventPlugin:i}),y.HostComponent.injectGenericComponentClass(p),y.HostComponent.injectTextComponentClass(m),y.DOMProperty.injectDOMPropertyConfig(o),y.DOMProperty.injectDOMPropertyConfig(l),y.DOMProperty.injectDOMPropertyConfig(C),y.EmptyComponent.injectEmptyComponentFactory(function(e){return new f(e)}),y.Updates.injectReconcileTransaction(_),y.Updates.injectBatchingStrategy(v),y.Component.injectEnvironment(c))}var o=e(1),i=e(3),a=e(7),s=e(14),u=e(15),l=e(21),c=e(27),p=e(31),d=e(33),f=e(35),h=e(44),m=e(42),v=e(46),g=e(52),y=e(55),_=e(65),C=e(73),b=e(74),E=e(75),x=!1;t.exports={inject:r}},{1:1,14:14,15:15,21:21,27:27,3:3,31:31,33:33,35:35,42:42,44:44,46:46,52:52,55:55,65:65,7:7,73:73,74:74,75:75}],48:[function(e,t,n){"use strict";var r="function"==typeof Symbol&&Symbol.for&&Symbol.for("react.element")||60103;t.exports=r},{}],49:[function(e,t,n){"use strict";var r,o={injectEmptyComponentFactory:function(e){r=e}},i={create:function(e){return r(e)}};i.injection=o,t.exports=i},{}],50:[function(e,t,n){"use strict";function r(e,t,n){try{t(n)}catch(e){null===o&&(o=e)}}var o=null,i={invokeGuardedCallback:r,invokeGuardedCallbackWithCatch:r,rethrowCaughtError:function(){if(o){var e=o;throw o=null,e}}};t.exports=i},{}],51:[function(e,t,n){"use strict";function r(e){o.enqueueEvents(e),o.processEventQueue(!1)}var o=e(16),i={handleTopLevel:function(e,t,n,i){var a=o.extractEvents(e,t,n,i);r(a)}};t.exports=i},{16:16}],52:[function(e,t,n){"use strict";function r(e){for(;e._hostParent;)e=e._hostParent;var t=p.getNodeFromInstance(e),n=t.parentNode;return p.getClosestInstanceFromNode(n)}function o(e,t){this.topLevelType=e,this.nativeEvent=t,this.ancestors=[]}function i(e){var t=f(e.nativeEvent),n=p.getClosestInstanceFromNode(t),o=n;do e.ancestors.push(o),o=o&&r(o);while(o);for(var i=0;i<e.ancestors.length;i++)n=e.ancestors[i],m._handleTopLevel(e.topLevelType,n,e.nativeEvent,f(e.nativeEvent))}function a(e){var t=h(window);e(t)}var s=e(143),u=e(122),l=e(123),c=e(24),p=e(33),d=e(71),f=e(102),h=e(134);s(o.prototype,{destructor:function(){this.topLevelType=null,this.nativeEvent=null,this.ancestors.length=0}}),c.addPoolingTo(o,c.twoArgumentPooler);var m={_enabled:!0,_handleTopLevel:null,WINDOW_HANDLE:l.canUseDOM?window:null,setHandleTopLevel:function(e){m._handleTopLevel=e},setEnabled:function(e){m._enabled=!!e},isEnabled:function(){return m._enabled},trapBubbledEvent:function(e,t,n){return n?u.listen(n,t,m.dispatchEvent.bind(null,e)):null},trapCapturedEvent:function(e,t,n){return n?u.capture(n,t,m.dispatchEvent.bind(null,e)):null},monitorScrollValue:function(e){var t=a.bind(null,e);u.listen(window,"scroll",t)},dispatchEvent:function(e,t){if(m._enabled){var n=o.getPooled(e,t);try{d.batchedUpdates(i,n)}finally{o.release(n)}}}};t.exports=m},{102:102,122:122,123:123,134:134,143:143,24:24,33:33,71:71}],53:[function(e,t,n){"use strict";var r={logTopLevelRenders:!1};t.exports=r},{}],54:[function(e,t,n){"use strict";function r(e){return s?void 0:a("111",e.type),new s(e)}function o(e){return new u(e)}function i(e){return e instanceof u}var a=e(113),s=(e(137),null),u=null,l={injectGenericComponentClass:function(e){s=e},injectTextComponentClass:function(e){u=e}},c={createInternalComponent:r,createInstanceForText:o,isTextComponent:i,injection:l};t.exports=c},{113:113,137:137}],55:[function(e,t,n){"use strict";var r=e(11),o=e(16),i=e(18),a=e(28),s=e(49),u=e(25),l=e(54),c=e(71),p={Component:a.injection,DOMProperty:r.injection,EmptyComponent:s.injection,EventPluginHub:o.injection,EventPluginUtils:i.injection,EventEmitter:u.injection,HostComponent:l.injection,Updates:c.injection};t.exports=p},{11:11,16:16,18:18,25:25,28:28,49:49,54:54,71:71}],56:[function(e,t,n){"use strict";function r(e){return i(document.documentElement,e)}var o=e(41),i=e(126),a=e(131),s=e(132),u={hasSelectionCapabilities:function(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&("input"===t&&"text"===e.type||"textarea"===t||"true"===e.contentEditable)},getSelectionInformation:function(){var e=s();return{focusedElem:e,selectionRange:u.hasSelectionCapabilities(e)?u.getSelection(e):null}},restoreSelection:function(e){var t=s(),n=e.focusedElem,o=e.selectionRange;t!==n&&r(n)&&(u.hasSelectionCapabilities(n)&&u.setSelection(n,o),a(n))},getSelection:function(e){var t;if("selectionStart"in e)t={start:e.selectionStart,end:e.selectionEnd};else if(document.selection&&e.nodeName&&"input"===e.nodeName.toLowerCase()){var n=document.selection.createRange();n.parentElement()===e&&(t={start:-n.moveStart("character",-e.value.length),end:-n.moveEnd("character",-e.value.length)})}else t=o.getOffsets(e);return t||{start:0,end:0}},setSelection:function(e,t){var n=t.start,r=t.end;if(void 0===r&&(r=n),"selectionStart"in e)e.selectionStart=n,e.selectionEnd=Math.min(r,e.value.length);else if(document.selection&&e.nodeName&&"input"===e.nodeName.toLowerCase()){var i=e.createTextRange();i.collapse(!0),i.moveStart("character",n),i.moveEnd("character",r-n),i.select()}else o.setOffsets(e,t)}};t.exports=u},{126:126,131:131,132:132,41:41}],57:[function(e,t,n){"use strict";var r={remove:function(e){e._reactInternalInstance=void 0},get:function(e){return e._reactInternalInstance},has:function(e){return void 0!==e._reactInternalInstance},set:function(e,t){e._reactInternalInstance=t}};t.exports=r},{}],58:[function(e,t,n){"use strict";var r=null;t.exports={debugTool:r}},{}],59:[function(e,t,n){"use strict";var r=e(92),o=/\/?>/,i=/^<\!\-\-/,a={CHECKSUM_ATTR_NAME:"data-react-checksum",addChecksumToMarkup:function(e){var t=r(e);return i.test(e)?e:e.replace(o," "+a.CHECKSUM_ATTR_NAME+'="'+t+'"$&')},canReuseMarkup:function(e,t){var n=t.getAttribute(a.CHECKSUM_ATTR_NAME);n=n&&parseInt(n,10);var o=r(e);return o===n}};t.exports=a},{92:92}],60:[function(e,t,n){"use strict";function r(e,t){for(var n=Math.min(e.length,t.length),r=0;r<n;r++)if(e.charAt(r)!==t.charAt(r))return r;return e.length===t.length?-1:n}function o(e){return e?e.nodeType===A?e.documentElement:e.firstChild:null}function i(e){return e.getAttribute&&e.getAttribute(I)||""}function a(e,t,n,r,o){var i;if(b.logTopLevelRenders){var a=e._currentElement.props.child,s=a.type;i="React mount: "+("string"==typeof s?s:s.displayName||s.name),console.time(i)}var u=w.mountComponent(e,n,null,_(e,t),o,0);i&&console.timeEnd(i),e._renderedComponent._topLevelWrapper=e,V._mountImageIntoNode(u,t,e,r,n)}function s(e,t,n,r){var o=k.ReactReconcileTransaction.getPooled(!n&&C.useCreateElement);o.perform(a,null,e,t,o,n,r),k.ReactReconcileTransaction.release(o)}function u(e,t,n){for(w.unmountComponent(e,n),t.nodeType===A&&(t=t.documentElement);t.lastChild;)t.removeChild(t.lastChild)}function l(e){var t=o(e);if(t){var n=y.getInstanceFromNode(t);return!(!n||!n._hostParent)}}function c(e){return!(!e||e.nodeType!==R&&e.nodeType!==A&&e.nodeType!==D)}function p(e){var t=o(e),n=t&&y.getInstanceFromNode(t);return n&&!n._hostParent?n:null}function d(e){var t=p(e);return t?t._hostContainerInfo._topLevelWrapper:null}var f=e(113),h=e(9),m=e(11),v=e(121),g=e(25),y=(e(120),e(33)),_=e(34),C=e(36),b=e(53),E=e(57),x=(e(58),e(59)),w=e(66),T=e(70),k=e(71),P=e(130),N=e(109),S=(e(137),e(115)),M=e(117),I=(e(142),m.ID_ATTRIBUTE_NAME),O=m.ROOT_ATTRIBUTE_NAME,R=1,A=9,D=11,L={},U=1,F=function(){this.rootID=U++};F.prototype.isReactComponent={},F.prototype.render=function(){return this.props.child},F.isReactTopLevelWrapper=!0;var V={TopLevelWrapper:F,_instancesByReactRootID:L,scrollMonitor:function(e,t){t()},_updateRootComponent:function(e,t,n,r,o){return V.scrollMonitor(r,function(){T.enqueueElementInternal(e,t,n),o&&T.enqueueCallbackInternal(e,o)}),e},_renderNewRootComponent:function(e,t,n,r){c(t)?void 0:f("37"),g.ensureScrollValueMonitoring();var o=N(e,!1);k.batchedUpdates(s,o,t,n,r);var i=o._instance.rootID;return L[i]=o,o},renderSubtreeIntoContainer:function(e,t,n,r){return null!=e&&E.has(e)?void 0:f("38"),V._renderSubtreeIntoContainer(e,t,n,r)},_renderSubtreeIntoContainer:function(e,t,n,r){T.validateCallback(r,"ReactDOM.render"),v.isValidElement(t)?void 0:f("39","string"==typeof t?" Instead of passing a string like 'div', pass React.createElement('div') or <div />.":"function"==typeof t?" Instead of passing a class like Foo, pass React.createElement(Foo) or <Foo />.":null!=t&&void 0!==t.props?" This may be caused by unintentionally loading two independent copies of React.":"");var a,s=v.createElement(F,{child:t});if(e){var u=E.get(e);a=u._processChildContext(u._context)}else a=P;var c=d(n);if(c){var p=c._currentElement,h=p.props.child;if(M(h,t)){var m=c._renderedComponent.getPublicInstance(),g=r&&function(){r.call(m)};return V._updateRootComponent(c,s,a,n,g),m}V.unmountComponentAtNode(n)}var y=o(n),_=y&&!!i(y),C=l(n),b=_&&!c&&!C,x=V._renderNewRootComponent(s,n,b,a)._renderedComponent.getPublicInstance();return r&&r.call(x),x},render:function(e,t,n){return V._renderSubtreeIntoContainer(null,e,t,n)},unmountComponentAtNode:function(e){c(e)?void 0:f("40");var t=d(e);return t?(delete L[t._instance.rootID],k.batchedUpdates(u,t,e,!1),!0):(l(e),1===e.nodeType&&e.hasAttribute(O),!1)},_mountImageIntoNode:function(e,t,n,i,a){if(c(t)?void 0:f("41"),i){var s=o(t);if(x.canReuseMarkup(e,s))return void y.precacheNode(n,s);var u=s.getAttribute(x.CHECKSUM_ATTR_NAME);s.removeAttribute(x.CHECKSUM_ATTR_NAME);var l=s.outerHTML;s.setAttribute(x.CHECKSUM_ATTR_NAME,u);var p=e,d=r(p,l),m=" (client) "+p.substring(d-20,d+20)+"\n (server) "+l.substring(d-20,d+20);t.nodeType===A?f("42",m):void 0}if(t.nodeType===A?f("43"):void 0,a.useCreateElement){for(;t.lastChild;)t.removeChild(t.lastChild);h.insertTreeBefore(t,e,null)}else S(t,e),y.precacheNode(n,t.firstChild)}};t.exports=V},{109:109,11:11,113:113,115:115,117:117,120:120,121:121,130:130,137:137,142:142,25:25,33:33,34:34,36:36,53:53,57:57,58:58,59:59,66:66,70:70,71:71,9:9}],61:[function(e,t,n){"use strict";function r(e,t,n){return{type:"INSERT_MARKUP",content:e,fromIndex:null,fromNode:null,toIndex:n,afterNode:t}}function o(e,t,n){return{type:"MOVE_EXISTING",content:null,fromIndex:e._mountIndex,fromNode:d.getHostNode(e),toIndex:n,afterNode:t}}function i(e,t){return{type:"REMOVE_NODE",content:null,fromIndex:e._mountIndex,fromNode:t,toIndex:null,afterNode:null}}function a(e){return{type:"SET_MARKUP",content:e,fromIndex:null,fromNode:null,toIndex:null,afterNode:null}}function s(e){return{type:"TEXT_CONTENT",content:e,fromIndex:null,fromNode:null,toIndex:null,afterNode:null}}function u(e,t){return t&&(e=e||[],e.push(t)),e}function l(e,t){p.processChildrenUpdates(e,t)}var c=e(113),p=e(28),d=(e(57),e(58),e(120),e(66)),f=e(26),h=(e(129),e(97)),m=(e(137),{Mixin:{_reconcilerInstantiateChildren:function(e,t,n){return f.instantiateChildren(e,t,n)},_reconcilerUpdateChildren:function(e,t,n,r,o,i){var a,s=0;return a=h(t,s),f.updateChildren(e,a,n,r,o,this,this._hostContainerInfo,i,s),a},mountChildren:function(e,t,n){var r=this._reconcilerInstantiateChildren(e,t,n);this._renderedChildren=r;var o=[],i=0;for(var a in r)if(r.hasOwnProperty(a)){var s=r[a],u=0,l=d.mountComponent(s,t,this,this._hostContainerInfo,n,u);s._mountIndex=i++,o.push(l)}return o},updateTextContent:function(e){var t=this._renderedChildren;f.unmountChildren(t,!1);for(var n in t)t.hasOwnProperty(n)&&c("118");var r=[s(e)];l(this,r)},updateMarkup:function(e){var t=this._renderedChildren;f.unmountChildren(t,!1);for(var n in t)t.hasOwnProperty(n)&&c("118");var r=[a(e)];l(this,r)},updateChildren:function(e,t,n){this._updateChildren(e,t,n)},_updateChildren:function(e,t,n){var r=this._renderedChildren,o={},i=[],a=this._reconcilerUpdateChildren(r,e,i,o,t,n);if(a||r){var s,c=null,p=0,f=0,h=0,m=null;for(s in a)if(a.hasOwnProperty(s)){var v=r&&r[s],g=a[s];v===g?(c=u(c,this.moveChild(v,m,p,f)),f=Math.max(v._mountIndex,f),v._mountIndex=p):(v&&(f=Math.max(v._mountIndex,f)),c=u(c,this._mountChildAtIndex(g,i[h],m,p,t,n)),h++),p++,m=d.getHostNode(g)}for(s in o)o.hasOwnProperty(s)&&(c=u(c,this._unmountChild(r[s],o[s])));c&&l(this,c),this._renderedChildren=a}},unmountChildren:function(e){var t=this._renderedChildren;f.unmountChildren(t,e),this._renderedChildren=null},moveChild:function(e,t,n,r){if(e._mountIndex<r)return o(e,t,n)},createChild:function(e,t,n){return r(n,t,e._mountIndex)},removeChild:function(e,t){return i(e,t)},_mountChildAtIndex:function(e,t,n,r,o,i){return e._mountIndex=r,this.createChild(e,n,t)},_unmountChild:function(e,t){var n=this.removeChild(e,t);return e._mountIndex=null,n}}});t.exports=m},{113:113,120:120,129:129,137:137,26:26,28:28,57:57,58:58,66:66,97:97}],62:[function(e,t,n){"use strict";var r=e(113),o=e(121),i=(e(137),{HOST:0,COMPOSITE:1,EMPTY:2,getType:function(e){return null===e||e===!1?i.EMPTY:o.isValidElement(e)?"function"==typeof e.type?i.COMPOSITE:i.HOST:void r("26",e)}});t.exports=i},{113:113,121:121,137:137}],63:[function(e,t,n){"use strict";function r(e){return!(!e||"function"!=typeof e.attachRef||"function"!=typeof e.detachRef)}var o=e(113),i=(e(137),{addComponentAsRefTo:function(e,t,n){r(n)?void 0:o("119"),n.attachRef(t,e)},removeComponentAsRefFrom:function(e,t,n){r(n)?void 0:o("120");var i=n.getPublicInstance();i&&i.refs[t]===e.getPublicInstance()&&n.detachRef(t)}});t.exports=i},{113:113,137:137}],64:[function(e,t,n){"use strict";var r="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";t.exports=r},{}],65:[function(e,t,n){"use strict";function r(e){this.reinitializeTransaction(),this.renderToStaticMarkup=!1,this.reactMountReady=i.getPooled(null),this.useCreateElement=e}var o=e(143),i=e(6),a=e(24),s=e(25),u=e(56),l=(e(58),e(89)),c=e(70),p={initialize:u.getSelectionInformation,close:u.restoreSelection},d={initialize:function(){var e=s.isEnabled();return s.setEnabled(!1),e},close:function(e){s.setEnabled(e)}},f={initialize:function(){this.reactMountReady.reset()},close:function(){this.reactMountReady.notifyAll()}},h=[p,d,f],m={getTransactionWrappers:function(){return h},getReactMountReady:function(){return this.reactMountReady},getUpdateQueue:function(){return c},checkpoint:function(){return this.reactMountReady.checkpoint()},rollback:function(e){this.reactMountReady.rollback(e)},destructor:function(){i.release(this.reactMountReady),this.reactMountReady=null}};o(r.prototype,l,m),a.addPoolingTo(r),t.exports=r},{143:143,24:24,25:25,56:56,58:58,6:6,70:70,89:89}],66:[function(e,t,n){"use strict";function r(){o.attachRefs(this,this._currentElement)}var o=e(67),i=(e(58),e(142),{mountComponent:function(e,t,n,o,i,a){var s=e.mountComponent(t,n,o,i,a);return e._currentElement&&null!=e._currentElement.ref&&t.getReactMountReady().enqueue(r,e),s},getHostNode:function(e){return e.getHostNode()},unmountComponent:function(e,t){o.detachRefs(e,e._currentElement),e.unmountComponent(t)},receiveComponent:function(e,t,n,i){var a=e._currentElement;if(t!==a||i!==e._context){var s=o.shouldUpdateRefs(a,t);s&&o.detachRefs(e,a),e.receiveComponent(t,n,i),s&&e._currentElement&&null!=e._currentElement.ref&&n.getReactMountReady().enqueue(r,e)}},performUpdateIfNecessary:function(e,t,n){e._updateBatchNumber===n&&e.performUpdateIfNecessary(t)}});t.exports=i},{142:142,58:58,67:67}],67:[function(e,t,n){"use strict";function r(e,t,n){"function"==typeof e?e(t.getPublicInstance()):i.addComponentAsRefTo(t,e,n)}function o(e,t,n){"function"==typeof e?e(null):i.removeComponentAsRefFrom(t,e,n)}var i=e(63),a={};a.attachRefs=function(e,t){if(null!==t&&"object"==typeof t){var n=t.ref;null!=n&&r(n,e,t._owner)}},a.shouldUpdateRefs=function(e,t){var n=null,r=null;null!==e&&"object"==typeof e&&(n=e.ref,r=e._owner);var o=null,i=null;return null!==t&&"object"==typeof t&&(o=t.ref,i=t._owner),n!==o||"string"==typeof o&&i!==r},a.detachRefs=function(e,t){if(null!==t&&"object"==typeof t){var n=t.ref;null!=n&&o(n,e,t._owner)}},t.exports=a},{63:63}],68:[function(e,t,n){"use strict";function r(e){this.reinitializeTransaction(),this.renderToStaticMarkup=e,this.useCreateElement=!1,this.updateQueue=new s(this)}var o=e(143),i=e(24),a=e(89),s=(e(58),e(69)),u=[],l={enqueue:function(){}},c={getTransactionWrappers:function(){return u},getReactMountReady:function(){return l},getUpdateQueue:function(){return this.updateQueue},destructor:function(){},checkpoint:function(){},rollback:function(){}};o(r.prototype,a,c),i.addPoolingTo(r),t.exports=r},{143:143,24:24,58:58,69:69,89:89}],69:[function(e,t,n){"use strict";function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e,t){}var i=e(70),a=(e(142),function(){function e(t){r(this,e),this.transaction=t}return e.prototype.isMounted=function(e){return!1},e.prototype.enqueueCallback=function(e,t,n){this.transaction.isInTransaction()&&i.enqueueCallback(e,t,n)},e.prototype.enqueueForceUpdate=function(e){this.transaction.isInTransaction()?i.enqueueForceUpdate(e):o(e,"forceUpdate")},e.prototype.enqueueReplaceState=function(e,t){this.transaction.isInTransaction()?i.enqueueReplaceState(e,t):o(e,"replaceState")},e.prototype.enqueueSetState=function(e,t){this.transaction.isInTransaction()?i.enqueueSetState(e,t):o(e,"setState")},e}());t.exports=a},{142:142,70:70}],70:[function(e,t,n){"use strict";function r(e){u.enqueueUpdate(e)}function o(e){var t=typeof e;if("object"!==t)return t;var n=e.constructor&&e.constructor.name||t,r=Object.keys(e);return r.length>0&&r.length<20?n+" (keys: "+r.join(", ")+")":n}function i(e,t){var n=s.get(e);return n?n:null}var a=e(113),s=(e(120),e(57)),u=(e(58),e(71)),l=(e(137),e(142),{isMounted:function(e){var t=s.get(e);return!!t&&!!t._renderedComponent},enqueueCallback:function(e,t,n){l.validateCallback(t,n);var o=i(e);return o?(o._pendingCallbacks?o._pendingCallbacks.push(t):o._pendingCallbacks=[t],void r(o)):null},enqueueCallbackInternal:function(e,t){e._pendingCallbacks?e._pendingCallbacks.push(t):e._pendingCallbacks=[t],r(e)},enqueueForceUpdate:function(e){var t=i(e,"forceUpdate");t&&(t._pendingForceUpdate=!0,r(t))},enqueueReplaceState:function(e,t){var n=i(e,"replaceState");n&&(n._pendingStateQueue=[t],n._pendingReplaceState=!0,r(n))},enqueueSetState:function(e,t){var n=i(e,"setState");if(n){var o=n._pendingStateQueue||(n._pendingStateQueue=[]);o.push(t),r(n)}},enqueueElementInternal:function(e,t,n){e._pendingElement=t,e._context=n,r(e)},validateCallback:function(e,t){e&&"function"!=typeof e?a("122",t,o(e)):void 0}});t.exports=l},{113:113,120:120,137:137,142:142,57:57,58:58,71:71}],71:[function(e,t,n){"use strict";function r(){P.ReactReconcileTransaction&&b?void 0:c("123")}function o(){this.reinitializeTransaction(),this.dirtyComponentsLength=null,this.callbackQueue=d.getPooled(),this.reconcileTransaction=P.ReactReconcileTransaction.getPooled(!0)}function i(e,t,n,o,i,a){return r(),b.batchedUpdates(e,t,n,o,i,a)}function a(e,t){return e._mountOrder-t._mountOrder}function s(e){var t=e.dirtyComponentsLength;t!==g.length?c("124",t,g.length):void 0,g.sort(a),y++;for(var n=0;n<t;n++){var r=g[n],o=r._pendingCallbacks;r._pendingCallbacks=null;var i;if(h.logTopLevelRenders){var s=r;r._currentElement.type.isReactTopLevelWrapper&&(s=r._renderedComponent),i="React update: "+s.getName(),console.time(i)}if(m.performUpdateIfNecessary(r,e.reconcileTransaction,y),i&&console.timeEnd(i),o)for(var u=0;u<o.length;u++)e.callbackQueue.enqueue(o[u],r.getPublicInstance())}}function u(e){return r(),b.isBatchingUpdates?(g.push(e),void(null==e._updateBatchNumber&&(e._updateBatchNumber=y+1))):void b.batchedUpdates(u,e)}function l(e,t){b.isBatchingUpdates?void 0:c("125"),_.enqueue(e,t),C=!0}var c=e(113),p=e(143),d=e(6),f=e(24),h=e(53),m=e(66),v=e(89),g=(e(137),[]),y=0,_=d.getPooled(),C=!1,b=null,E={initialize:function(){this.dirtyComponentsLength=g.length},close:function(){this.dirtyComponentsLength!==g.length?(g.splice(0,this.dirtyComponentsLength),T()):g.length=0}},x={initialize:function(){this.callbackQueue.reset()},close:function(){this.callbackQueue.notifyAll()}},w=[E,x];p(o.prototype,v,{getTransactionWrappers:function(){return w},destructor:function(){this.dirtyComponentsLength=null,d.release(this.callbackQueue),this.callbackQueue=null,P.ReactReconcileTransaction.release(this.reconcileTransaction),this.reconcileTransaction=null},perform:function(e,t,n){return v.perform.call(this,this.reconcileTransaction.perform,this.reconcileTransaction,e,t,n)}}),f.addPoolingTo(o);var T=function(){for(;g.length||C;){if(g.length){var e=o.getPooled();e.perform(s,null,e),o.release(e)}if(C){C=!1;var t=_;_=d.getPooled(),t.notifyAll(),d.release(t)}}},k={injectReconcileTransaction:function(e){e?void 0:c("126"),P.ReactReconcileTransaction=e},injectBatchingStrategy:function(e){e?void 0:c("127"),"function"!=typeof e.batchedUpdates?c("128"):void 0,"boolean"!=typeof e.isBatchingUpdates?c("129"):void 0,b=e}},P={ReactReconcileTransaction:null,batchedUpdates:i,enqueueUpdate:u,flushBatchedUpdates:T,injection:k,asap:l};t.exports=P},{113:113,137:137,143:143,24:24,53:53,6:6,66:66,89:89}],72:[function(e,t,n){"use strict";t.exports="15.4.2"},{}],73:[function(e,t,n){"use strict";var r={xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace"},o={accentHeight:"accent-height",accumulate:0,additive:0,alignmentBaseline:"alignment-baseline",allowReorder:"allowReorder",alphabetic:0,amplitude:0,arabicForm:"arabic-form",ascent:0,attributeName:"attributeName",attributeType:"attributeType",autoReverse:"autoReverse",azimuth:0,baseFrequency:"baseFrequency",baseProfile:"baseProfile",baselineShift:"baseline-shift",bbox:0,begin:0,bias:0,by:0,calcMode:"calcMode",capHeight:"cap-height",clip:0,clipPath:"clip-path",clipRule:"clip-rule",clipPathUnits:"clipPathUnits",colorInterpolation:"color-interpolation",colorInterpolationFilters:"color-interpolation-filters",colorProfile:"color-profile",colorRendering:"color-rendering",contentScriptType:"contentScriptType",contentStyleType:"contentStyleType",cursor:0,cx:0,cy:0,d:0,decelerate:0,descent:0,diffuseConstant:"diffuseConstant",direction:0,display:0,divisor:0,dominantBaseline:"dominant-baseline",dur:0,dx:0,dy:0,edgeMode:"edgeMode",elevation:0,enableBackground:"enable-background",end:0,exponent:0,externalResourcesRequired:"externalResourcesRequired",fill:0,fillOpacity:"fill-opacity",fillRule:"fill-rule",filter:0,filterRes:"filterRes",filterUnits:"filterUnits",floodColor:"flood-color",floodOpacity:"flood-opacity",focusable:0,fontFamily:"font-family",fontSize:"font-size",fontSizeAdjust:"font-size-adjust",fontStretch:"font-stretch",fontStyle:"font-style",fontVariant:"font-variant",fontWeight:"font-weight",format:0,from:0,fx:0,fy:0,g1:0,g2:0,glyphName:"glyph-name",glyphOrientationHorizontal:"glyph-orientation-horizontal",glyphOrientationVertical:"glyph-orientation-vertical",glyphRef:"glyphRef",gradientTransform:"gradientTransform",gradientUnits:"gradientUnits",hanging:0,horizAdvX:"horiz-adv-x",horizOriginX:"horiz-origin-x",ideographic:0,imageRendering:"image-rendering",in:0,in2:0,intercept:0,k:0,k1:0,k2:0,k3:0,k4:0,kernelMatrix:"kernelMatrix",kernelUnitLength:"kernelUnitLength",kerning:0,keyPoints:"keyPoints",keySplines:"keySplines",keyTimes:"keyTimes",lengthAdjust:"lengthAdjust",letterSpacing:"letter-spacing",lightingColor:"lighting-color",limitingConeAngle:"limitingConeAngle",local:0,markerEnd:"marker-end",markerMid:"marker-mid",markerStart:"marker-start",markerHeight:"markerHeight",markerUnits:"markerUnits",markerWidth:"markerWidth",mask:0,maskContentUnits:"maskContentUnits",maskUnits:"maskUnits",mathematical:0,mode:0,numOctaves:"numOctaves",offset:0,opacity:0,operator:0,order:0,orient:0,orientation:0,origin:0,overflow:0,overlinePosition:"overline-position",overlineThickness:"overline-thickness",paintOrder:"paint-order",panose1:"panose-1",pathLength:"pathLength",patternContentUnits:"patternContentUnits",patternTransform:"patternTransform",patternUnits:"patternUnits",pointerEvents:"pointer-events",points:0,pointsAtX:"pointsAtX",pointsAtY:"pointsAtY",pointsAtZ:"pointsAtZ",preserveAlpha:"preserveAlpha",preserveAspectRatio:"preserveAspectRatio",primitiveUnits:"primitiveUnits",r:0,radius:0,refX:"refX",refY:"refY",renderingIntent:"rendering-intent",repeatCount:"repeatCount",repeatDur:"repeatDur",requiredExtensions:"requiredExtensions",requiredFeatures:"requiredFeatures",restart:0,result:0,rotate:0,rx:0,ry:0,scale:0,seed:0,shapeRendering:"shape-rendering",slope:0,spacing:0,specularConstant:"specularConstant",specularExponent:"specularExponent",speed:0,spreadMethod:"spreadMethod",startOffset:"startOffset",stdDeviation:"stdDeviation",stemh:0,stemv:0,stitchTiles:"stitchTiles",stopColor:"stop-color",stopOpacity:"stop-opacity",strikethroughPosition:"strikethrough-position",strikethroughThickness:"strikethrough-thickness",string:0,stroke:0,strokeDasharray:"stroke-dasharray",strokeDashoffset:"stroke-dashoffset",strokeLinecap:"stroke-linecap",strokeLinejoin:"stroke-linejoin",strokeMiterlimit:"stroke-miterlimit",strokeOpacity:"stroke-opacity",strokeWidth:"stroke-width",surfaceScale:"surfaceScale",systemLanguage:"systemLanguage",tableValues:"tableValues",targetX:"targetX",targetY:"targetY",textAnchor:"text-anchor",textDecoration:"text-decoration",textRendering:"text-rendering",textLength:"textLength",to:0,transform:0,u1:0,u2:0,underlinePosition:"underline-position",underlineThickness:"underline-thickness",unicode:0,unicodeBidi:"unicode-bidi",unicodeRange:"unicode-range",unitsPerEm:"units-per-em",vAlphabetic:"v-alphabetic",vHanging:"v-hanging",vIdeographic:"v-ideographic",vMathematical:"v-mathematical",values:0,vectorEffect:"vector-effect",version:0,vertAdvY:"vert-adv-y",vertOriginX:"vert-origin-x",vertOriginY:"vert-origin-y",viewBox:"viewBox",viewTarget:"viewTarget",visibility:0,widths:0,wordSpacing:"word-spacing",writingMode:"writing-mode",x:0,xHeight:"x-height",x1:0,x2:0,xChannelSelector:"xChannelSelector",xlinkActuate:"xlink:actuate",xlinkArcrole:"xlink:arcrole",xlinkHref:"xlink:href",xlinkRole:"xlink:role",xlinkShow:"xlink:show",xlinkTitle:"xlink:title",xlinkType:"xlink:type",xmlBase:"xml:base",xmlns:0,xmlnsXlink:"xmlns:xlink",xmlLang:"xml:lang",xmlSpace:"xml:space",y:0,y1:0,y2:0,yChannelSelector:"yChannelSelector",z:0,zoomAndPan:"zoomAndPan"},i={Properties:{},DOMAttributeNamespaces:{xlinkActuate:r.xlink,xlinkArcrole:r.xlink,xlinkHref:r.xlink,xlinkRole:r.xlink,xlinkShow:r.xlink,xlinkTitle:r.xlink,xlinkType:r.xlink,xmlBase:r.xml,xmlLang:r.xml,xmlSpace:r.xml},DOMAttributeNames:{}};Object.keys(o).forEach(function(e){i.Properties[e]=0,o[e]&&(i.DOMAttributeNames[e]=o[e])}),t.exports=i},{}],74:[function(e,t,n){"use strict";function r(e){if("selectionStart"in e&&u.hasSelectionCapabilities(e))return{start:e.selectionStart,end:e.selectionEnd};if(window.getSelection){var t=window.getSelection();return{anchorNode:t.anchorNode,anchorOffset:t.anchorOffset,focusNode:t.focusNode,focusOffset:t.focusOffset}}if(document.selection){var n=document.selection.createRange();return{parentElement:n.parentElement(),text:n.text,top:n.boundingTop,left:n.boundingLeft}}}function o(e,t){if(y||null==m||m!==c())return null;var n=r(m);if(!g||!d(g,n)){g=n;var o=l.getPooled(h.select,v,e,t);return o.type="select",o.target=m,i.accumulateTwoPhaseDispatches(o),o}return null}var i=e(19),a=e(123),s=e(33),u=e(56),l=e(80),c=e(132),p=e(111),d=e(141),f=a.canUseDOM&&"documentMode"in document&&document.documentMode<=11,h={select:{phasedRegistrationNames:{bubbled:"onSelect",captured:"onSelectCapture"},dependencies:["topBlur","topContextMenu","topFocus","topKeyDown","topKeyUp","topMouseDown","topMouseUp","topSelectionChange"]}},m=null,v=null,g=null,y=!1,_=!1,C={eventTypes:h,extractEvents:function(e,t,n,r){if(!_)return null;var i=t?s.getNodeFromInstance(t):window;switch(e){case"topFocus":(p(i)||"true"===i.contentEditable)&&(m=i,v=t,g=null);break;case"topBlur":m=null,v=null,g=null;break;case"topMouseDown":y=!0;break;case"topContextMenu":case"topMouseUp":return y=!1,
+o(n,r);case"topSelectionChange":if(f)break;case"topKeyDown":case"topKeyUp":return o(n,r)}return null},didPutListener:function(e,t,n){"onSelect"===t&&(_=!0)}};t.exports=C},{111:111,123:123,132:132,141:141,19:19,33:33,56:56,80:80}],75:[function(e,t,n){"use strict";function r(e){return"."+e._rootNodeID}function o(e){return"button"===e||"input"===e||"select"===e||"textarea"===e}var i=e(113),a=e(122),s=e(19),u=e(33),l=e(76),c=e(77),p=e(80),d=e(81),f=e(83),h=e(84),m=e(79),v=e(85),g=e(86),y=e(87),_=e(88),C=e(129),b=e(99),E=(e(137),{}),x={};["abort","animationEnd","animationIteration","animationStart","blur","canPlay","canPlayThrough","click","contextMenu","copy","cut","doubleClick","drag","dragEnd","dragEnter","dragExit","dragLeave","dragOver","dragStart","drop","durationChange","emptied","encrypted","ended","error","focus","input","invalid","keyDown","keyPress","keyUp","load","loadedData","loadedMetadata","loadStart","mouseDown","mouseMove","mouseOut","mouseOver","mouseUp","paste","pause","play","playing","progress","rateChange","reset","scroll","seeked","seeking","stalled","submit","suspend","timeUpdate","touchCancel","touchEnd","touchMove","touchStart","transitionEnd","volumeChange","waiting","wheel"].forEach(function(e){var t=e[0].toUpperCase()+e.slice(1),n="on"+t,r="top"+t,o={phasedRegistrationNames:{bubbled:n,captured:n+"Capture"},dependencies:[r]};E[e]=o,x[r]=o});var w={},T={eventTypes:E,extractEvents:function(e,t,n,r){var o=x[e];if(!o)return null;var a;switch(e){case"topAbort":case"topCanPlay":case"topCanPlayThrough":case"topDurationChange":case"topEmptied":case"topEncrypted":case"topEnded":case"topError":case"topInput":case"topInvalid":case"topLoad":case"topLoadedData":case"topLoadedMetadata":case"topLoadStart":case"topPause":case"topPlay":case"topPlaying":case"topProgress":case"topRateChange":case"topReset":case"topSeeked":case"topSeeking":case"topStalled":case"topSubmit":case"topSuspend":case"topTimeUpdate":case"topVolumeChange":case"topWaiting":a=p;break;case"topKeyPress":if(0===b(n))return null;case"topKeyDown":case"topKeyUp":a=f;break;case"topBlur":case"topFocus":a=d;break;case"topClick":if(2===n.button)return null;case"topDoubleClick":case"topMouseDown":case"topMouseMove":case"topMouseUp":case"topMouseOut":case"topMouseOver":case"topContextMenu":a=h;break;case"topDrag":case"topDragEnd":case"topDragEnter":case"topDragExit":case"topDragLeave":case"topDragOver":case"topDragStart":case"topDrop":a=m;break;case"topTouchCancel":case"topTouchEnd":case"topTouchMove":case"topTouchStart":a=v;break;case"topAnimationEnd":case"topAnimationIteration":case"topAnimationStart":a=l;break;case"topTransitionEnd":a=g;break;case"topScroll":a=y;break;case"topWheel":a=_;break;case"topCopy":case"topCut":case"topPaste":a=c}a?void 0:i("86",e);var u=a.getPooled(o,t,n,r);return s.accumulateTwoPhaseDispatches(u),u},didPutListener:function(e,t,n){if("onClick"===t&&!o(e._tag)){var i=r(e),s=u.getNodeFromInstance(e);w[i]||(w[i]=a.listen(s,"click",C))}},willDeleteListener:function(e,t){if("onClick"===t&&!o(e._tag)){var n=r(e);w[n].remove(),delete w[n]}}};t.exports=T},{113:113,122:122,129:129,137:137,19:19,33:33,76:76,77:77,79:79,80:80,81:81,83:83,84:84,85:85,86:86,87:87,88:88,99:99}],76:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(80),i={animationName:null,elapsedTime:null,pseudoElement:null};o.augmentClass(r,i),t.exports=r},{80:80}],77:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(80),i={clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}};o.augmentClass(r,i),t.exports=r},{80:80}],78:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(80),i={data:null};o.augmentClass(r,i),t.exports=r},{80:80}],79:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(84),i={dataTransfer:null};o.augmentClass(r,i),t.exports=r},{84:84}],80:[function(e,t,n){"use strict";function r(e,t,n,r){this.dispatchConfig=e,this._targetInst=t,this.nativeEvent=n;var o=this.constructor.Interface;for(var i in o)if(o.hasOwnProperty(i)){var s=o[i];s?this[i]=s(n):"target"===i?this.target=r:this[i]=n[i]}var u=null!=n.defaultPrevented?n.defaultPrevented:n.returnValue===!1;return u?this.isDefaultPrevented=a.thatReturnsTrue:this.isDefaultPrevented=a.thatReturnsFalse,this.isPropagationStopped=a.thatReturnsFalse,this}var o=e(143),i=e(24),a=e(129),s=(e(142),"function"==typeof Proxy,["dispatchConfig","_targetInst","nativeEvent","isDefaultPrevented","isPropagationStopped","_dispatchListeners","_dispatchInstances"]),u={type:null,target:null,currentTarget:a.thatReturnsNull,eventPhase:null,bubbles:null,cancelable:null,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:null,isTrusted:null};o(r.prototype,{preventDefault:function(){this.defaultPrevented=!0;var e=this.nativeEvent;e&&(e.preventDefault?e.preventDefault():"unknown"!=typeof e.returnValue&&(e.returnValue=!1),this.isDefaultPrevented=a.thatReturnsTrue)},stopPropagation:function(){var e=this.nativeEvent;e&&(e.stopPropagation?e.stopPropagation():"unknown"!=typeof e.cancelBubble&&(e.cancelBubble=!0),this.isPropagationStopped=a.thatReturnsTrue)},persist:function(){this.isPersistent=a.thatReturnsTrue},isPersistent:a.thatReturnsFalse,destructor:function(){var e=this.constructor.Interface;for(var t in e)this[t]=null;for(var n=0;n<s.length;n++)this[s[n]]=null}}),r.Interface=u,r.augmentClass=function(e,t){var n=this,r=function(){};r.prototype=n.prototype;var a=new r;o(a,e.prototype),e.prototype=a,e.prototype.constructor=e,e.Interface=o({},n.Interface,t),e.augmentClass=n.augmentClass,i.addPoolingTo(e,i.fourArgumentPooler)},i.addPoolingTo(r,i.fourArgumentPooler),t.exports=r},{129:129,142:142,143:143,24:24}],81:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(87),i={relatedTarget:null};o.augmentClass(r,i),t.exports=r},{87:87}],82:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(80),i={data:null};o.augmentClass(r,i),t.exports=r},{80:80}],83:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(87),i=e(99),a=e(100),s=e(101),u={key:a,location:null,ctrlKey:null,shiftKey:null,altKey:null,metaKey:null,repeat:null,locale:null,getModifierState:s,charCode:function(e){return"keypress"===e.type?i(e):0},keyCode:function(e){return"keydown"===e.type||"keyup"===e.type?e.keyCode:0},which:function(e){return"keypress"===e.type?i(e):"keydown"===e.type||"keyup"===e.type?e.keyCode:0}};o.augmentClass(r,u),t.exports=r},{100:100,101:101,87:87,99:99}],84:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(87),i=e(90),a=e(101),s={screenX:null,screenY:null,clientX:null,clientY:null,ctrlKey:null,shiftKey:null,altKey:null,metaKey:null,getModifierState:a,button:function(e){var t=e.button;return"which"in e?t:2===t?2:4===t?1:0},buttons:null,relatedTarget:function(e){return e.relatedTarget||(e.fromElement===e.srcElement?e.toElement:e.fromElement)},pageX:function(e){return"pageX"in e?e.pageX:e.clientX+i.currentScrollLeft},pageY:function(e){return"pageY"in e?e.pageY:e.clientY+i.currentScrollTop}};o.augmentClass(r,s),t.exports=r},{101:101,87:87,90:90}],85:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(87),i=e(101),a={touches:null,targetTouches:null,changedTouches:null,altKey:null,metaKey:null,ctrlKey:null,shiftKey:null,getModifierState:i};o.augmentClass(r,a),t.exports=r},{101:101,87:87}],86:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(80),i={propertyName:null,elapsedTime:null,pseudoElement:null};o.augmentClass(r,i),t.exports=r},{80:80}],87:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(80),i=e(102),a={view:function(e){if(e.view)return e.view;var t=i(e);if(t.window===t)return t;var n=t.ownerDocument;return n?n.defaultView||n.parentWindow:window},detail:function(e){return e.detail||0}};o.augmentClass(r,a),t.exports=r},{102:102,80:80}],88:[function(e,t,n){"use strict";function r(e,t,n,r){return o.call(this,e,t,n,r)}var o=e(84),i={deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:null,deltaMode:null};o.augmentClass(r,i),t.exports=r},{84:84}],89:[function(e,t,n){"use strict";var r=e(113),o=(e(137),{}),i={reinitializeTransaction:function(){this.transactionWrappers=this.getTransactionWrappers(),this.wrapperInitData?this.wrapperInitData.length=0:this.wrapperInitData=[],this._isInTransaction=!1},_isInTransaction:!1,getTransactionWrappers:null,isInTransaction:function(){return!!this._isInTransaction},perform:function(e,t,n,o,i,a,s,u){this.isInTransaction()?r("27"):void 0;var l,c;try{this._isInTransaction=!0,l=!0,this.initializeAll(0),c=e.call(t,n,o,i,a,s,u),l=!1}finally{try{if(l)try{this.closeAll(0)}catch(e){}else this.closeAll(0)}finally{this._isInTransaction=!1}}return c},initializeAll:function(e){for(var t=this.transactionWrappers,n=e;n<t.length;n++){var r=t[n];try{this.wrapperInitData[n]=o,this.wrapperInitData[n]=r.initialize?r.initialize.call(this):null}finally{if(this.wrapperInitData[n]===o)try{this.initializeAll(n+1)}catch(e){}}}},closeAll:function(e){this.isInTransaction()?void 0:r("28");for(var t=this.transactionWrappers,n=e;n<t.length;n++){var i,a=t[n],s=this.wrapperInitData[n];try{i=!0,s!==o&&a.close&&a.close.call(this,s),i=!1}finally{if(i)try{this.closeAll(n+1)}catch(e){}}}this.wrapperInitData.length=0}};t.exports=i},{113:113,137:137}],90:[function(e,t,n){"use strict";var r={currentScrollLeft:0,currentScrollTop:0,refreshScrollValues:function(e){r.currentScrollLeft=e.x,r.currentScrollTop=e.y}};t.exports=r},{}],91:[function(e,t,n){"use strict";function r(e,t){return null==t?o("30"):void 0,null==e?t:Array.isArray(e)?Array.isArray(t)?(e.push.apply(e,t),e):(e.push(t),e):Array.isArray(t)?[e].concat(t):[e,t]}var o=e(113);e(137);t.exports=r},{113:113,137:137}],92:[function(e,t,n){"use strict";function r(e){for(var t=1,n=0,r=0,i=e.length,a=i&-4;r<a;){for(var s=Math.min(r+4096,a);r<s;r+=4)n+=(t+=e.charCodeAt(r))+(t+=e.charCodeAt(r+1))+(t+=e.charCodeAt(r+2))+(t+=e.charCodeAt(r+3));t%=o,n%=o}for(;r<i;r++)n+=t+=e.charCodeAt(r);return t%=o,n%=o,t|n<<16}var o=65521;t.exports=r},{}],93:[function(e,t,n){"use strict";var r=function(e){return"undefined"!=typeof MSApp&&MSApp.execUnsafeLocalFunction?function(t,n,r,o){MSApp.execUnsafeLocalFunction(function(){return e(t,n,r,o)})}:e};t.exports=r},{}],94:[function(e,t,n){"use strict";function r(e,t,n){var r=null==t||"boolean"==typeof t||""===t;if(r)return"";var o=isNaN(t);return o||0===t||i.hasOwnProperty(e)&&i[e]?""+t:("string"==typeof t&&(t=t.trim()),t+"px")}var o=e(4),i=(e(142),o.isUnitlessNumber);t.exports=r},{142:142,4:4}],95:[function(e,t,n){"use strict";function r(e){var t=""+e,n=i.exec(t);if(!n)return t;var r,o="",a=0,s=0;for(a=n.index;a<t.length;a++){switch(t.charCodeAt(a)){case 34:r="&quot;";break;case 38:r="&amp;";break;case 39:r="&#x27;";break;case 60:r="&lt;";break;case 62:r="&gt;";break;default:continue}s!==a&&(o+=t.substring(s,a)),s=a+1,o+=r}return s!==a?o+t.substring(s,a):o}function o(e){return"boolean"==typeof e||"number"==typeof e?""+e:r(e)}var i=/["'&<>]/;t.exports=o},{}],96:[function(e,t,n){"use strict";function r(e){if(null==e)return null;if(1===e.nodeType)return e;var t=a.get(e);return t?(t=s(t),t?i.getNodeFromInstance(t):null):void("function"==typeof e.render?o("44"):o("45",Object.keys(e)))}var o=e(113),i=(e(120),e(33)),a=e(57),s=e(103);e(137),e(142);t.exports=r},{103:103,113:113,120:120,137:137,142:142,33:33,57:57}],97:[function(e,t,n){(function(n){"use strict";function r(e,t,n,r){if(e&&"object"==typeof e){var o=e,i=void 0===o[n];i&&null!=t&&(o[n]=t)}}function o(e,t){if(null==e)return e;var n={};return i(e,r,n),n}var i=(e(22),e(118));e(142);"undefined"!=typeof n&&n.env,t.exports=o}).call(this,void 0)},{118:118,142:142,22:22}],98:[function(e,t,n){"use strict";function r(e,t,n){Array.isArray(e)?e.forEach(t,n):e&&t.call(n,e)}t.exports=r},{}],99:[function(e,t,n){"use strict";function r(e){var t,n=e.keyCode;return"charCode"in e?(t=e.charCode,0===t&&13===n&&(t=13)):t=n,t>=32||13===t?t:0}t.exports=r},{}],100:[function(e,t,n){"use strict";function r(e){if(e.key){var t=i[e.key]||e.key;if("Unidentified"!==t)return t}if("keypress"===e.type){var n=o(e);return 13===n?"Enter":String.fromCharCode(n)}return"keydown"===e.type||"keyup"===e.type?a[e.keyCode]||"Unidentified":""}var o=e(99),i={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},a={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"};t.exports=r},{99:99}],101:[function(e,t,n){"use strict";function r(e){var t=this,n=t.nativeEvent;if(n.getModifierState)return n.getModifierState(e);var r=i[e];return!!r&&!!n[r]}function o(e){return r}var i={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};t.exports=o},{}],102:[function(e,t,n){"use strict";function r(e){var t=e.target||e.srcElement||window;return t.correspondingUseElement&&(t=t.correspondingUseElement),3===t.nodeType?t.parentNode:t}t.exports=r},{}],103:[function(e,t,n){"use strict";function r(e){for(var t;(t=e._renderedNodeType)===o.COMPOSITE;)e=e._renderedComponent;return t===o.HOST?e._renderedComponent:t===o.EMPTY?null:void 0}var o=e(62);t.exports=r},{62:62}],104:[function(e,t,n){"use strict";function r(e){var t=e&&(o&&e[o]||e[i]);if("function"==typeof t)return t}var o="function"==typeof Symbol&&Symbol.iterator,i="@@iterator";t.exports=r},{}],105:[function(e,t,n){"use strict";function r(){return o++}var o=1;t.exports=r},{}],106:[function(e,t,n){"use strict";function r(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function o(e){for(;e;){if(e.nextSibling)return e.nextSibling;e=e.parentNode}}function i(e,t){for(var n=r(e),i=0,a=0;n;){if(3===n.nodeType){if(a=i+n.textContent.length,i<=t&&a>=t)return{node:n,offset:t-i};i=a}n=r(o(n))}}t.exports=i},{}],107:[function(e,t,n){"use strict";function r(){return!i&&o.canUseDOM&&(i="textContent"in document.documentElement?"textContent":"innerText"),i}var o=e(123),i=null;t.exports=r},{123:123}],108:[function(e,t,n){"use strict";function r(e,t){var n={};return n[e.toLowerCase()]=t.toLowerCase(),n["Webkit"+e]="webkit"+t,n["Moz"+e]="moz"+t,n["ms"+e]="MS"+t,n["O"+e]="o"+t.toLowerCase(),n}function o(e){if(s[e])return s[e];if(!a[e])return e;var t=a[e];for(var n in t)if(t.hasOwnProperty(n)&&n in u)return s[e]=t[n];return""}var i=e(123),a={animationend:r("Animation","AnimationEnd"),animationiteration:r("Animation","AnimationIteration"),animationstart:r("Animation","AnimationStart"),transitionend:r("Transition","TransitionEnd")},s={},u={};i.canUseDOM&&(u=document.createElement("div").style,"AnimationEvent"in window||(delete a.animationend.animation,delete a.animationiteration.animation,delete a.animationstart.animation),"TransitionEvent"in window||delete a.transitionend.transition),t.exports=o},{123:123}],109:[function(e,t,n){"use strict";function r(e){if(e){var t=e.getName();if(t)return" Check the render method of `"+t+"`."}return""}function o(e){return"function"==typeof e&&"undefined"!=typeof e.prototype&&"function"==typeof e.prototype.mountComponent&&"function"==typeof e.prototype.receiveComponent}function i(e,t){var n;if(null===e||e===!1)n=l.create(i);else if("object"==typeof e){var s=e,u=s.type;if("function"!=typeof u&&"string"!=typeof u){var d="";d+=r(s._owner),a("130",null==u?u:typeof u,d)}"string"==typeof s.type?n=c.createInternalComponent(s):o(s.type)?(n=new s.type(s),n.getHostNode||(n.getHostNode=n.getNativeNode)):n=new p(s)}else"string"==typeof e||"number"==typeof e?n=c.createInstanceForText(e):a("131",typeof e);return n._mountIndex=0,n._mountImage=null,n}var a=e(113),s=e(143),u=e(29),l=e(49),c=e(54),p=(e(105),e(137),e(142),function(e){this.construct(e)});s(p.prototype,u,{_instantiateReactComponent:i}),t.exports=i},{105:105,113:113,137:137,142:142,143:143,29:29,49:49,54:54}],110:[function(e,t,n){"use strict";function r(e,t){if(!i.canUseDOM||t&&!("addEventListener"in document))return!1;var n="on"+e,r=n in document;if(!r){var a=document.createElement("div");a.setAttribute(n,"return;"),r="function"==typeof a[n]}return!r&&o&&"wheel"===e&&(r=document.implementation.hasFeature("Events.wheel","3.0")),r}var o,i=e(123);i.canUseDOM&&(o=document.implementation&&document.implementation.hasFeature&&document.implementation.hasFeature("","")!==!0),t.exports=r},{123:123}],111:[function(e,t,n){"use strict";function r(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return"input"===t?!!o[e.type]:"textarea"===t}var o={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};t.exports=r},{}],112:[function(e,t,n){"use strict";function r(e){return'"'+o(e)+'"'}var o=e(95);t.exports=r},{95:95}],113:[function(e,t,n){"use strict";function r(e){for(var t=arguments.length-1,n="Minified React error #"+e+"; visit http://facebook.github.io/react/docs/error-decoder.html?invariant="+e,r=0;r<t;r++)n+="&args[]="+encodeURIComponent(arguments[r+1]);n+=" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";var o=new Error(n);throw o.name="Invariant Violation",o.framesToPop=1,o}t.exports=r},{}],114:[function(e,t,n){"use strict";var r=e(60);t.exports=r.renderSubtreeIntoContainer},{60:60}],115:[function(e,t,n){"use strict";var r,o=e(123),i=e(10),a=/^[ \r\n\t\f]/,s=/<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/,u=e(93),l=u(function(e,t){if(e.namespaceURI!==i.svg||"innerHTML"in e)e.innerHTML=t;else{r=r||document.createElement("div"),r.innerHTML="<svg>"+t+"</svg>";for(var n=r.firstChild;n.firstChild;)e.appendChild(n.firstChild)}});if(o.canUseDOM){var c=document.createElement("div");c.innerHTML=" ",""===c.innerHTML&&(l=function(e,t){if(e.parentNode&&e.parentNode.replaceChild(e,e),a.test(t)||"<"===t[0]&&s.test(t)){e.innerHTML=String.fromCharCode(65279)+t;var n=e.firstChild;1===n.data.length?e.removeChild(n):n.deleteData(0,1)}else e.innerHTML=t}),c=null}t.exports=l},{10:10,123:123,93:93}],116:[function(e,t,n){"use strict";var r=e(123),o=e(95),i=e(115),a=function(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&3===n.nodeType)return void(n.nodeValue=t)}e.textContent=t};r.canUseDOM&&("textContent"in document.documentElement||(a=function(e,t){return 3===e.nodeType?void(e.nodeValue=t):void i(e,o(t))})),t.exports=a},{115:115,123:123,95:95}],117:[function(e,t,n){"use strict";function r(e,t){var n=null===e||e===!1,r=null===t||t===!1;if(n||r)return n===r;var o=typeof e,i=typeof t;return"string"===o||"number"===o?"string"===i||"number"===i:"object"===i&&e.type===t.type&&e.key===t.key}t.exports=r},{}],118:[function(e,t,n){"use strict";function r(e,t){return e&&"object"==typeof e&&null!=e.key?l.escape(e.key):t.toString(36)}function o(e,t,n,i){var d=typeof e;if("undefined"!==d&&"boolean"!==d||(e=null),null===e||"string"===d||"number"===d||"object"===d&&e.$$typeof===s)return n(i,e,""===t?c+r(e,0):t),1;var f,h,m=0,v=""===t?c:t+p;if(Array.isArray(e))for(var g=0;g<e.length;g++)f=e[g],h=v+r(f,g),m+=o(f,h,n,i);else{var y=u(e);if(y){var _,C=y.call(e);if(y!==e.entries)for(var b=0;!(_=C.next()).done;)f=_.value,h=v+r(f,b++),m+=o(f,h,n,i);else for(;!(_=C.next()).done;){var E=_.value;E&&(f=E[1],h=v+l.escape(E[0])+p+r(f,0),m+=o(f,h,n,i))}}else if("object"===d){var x="",w=String(e);a("31","[object Object]"===w?"object with keys {"+Object.keys(e).join(", ")+"}":w,x)}}return m}function i(e,t,n){return null==e?0:o(e,"",t,n)}var a=e(113),s=(e(120),e(48)),u=e(104),l=(e(137),e(22)),c=(e(142),"."),p=":";t.exports=i},{104:104,113:113,120:120,137:137,142:142,22:22,48:48}],119:[function(e,t,n){"use strict";var r=(e(143),e(129)),o=(e(142),r);t.exports=o},{129:129,142:142,143:143}],120:[function(t,n,r){"use strict";var o=e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;n.exports=o.ReactCurrentOwner},{}],121:[function(t,n,r){"use strict";n.exports=e},{}],122:[function(e,t,n){"use strict";var r=e(129),o={listen:function(e,t,n){return e.addEventListener?(e.addEventListener(t,n,!1),{remove:function(){e.removeEventListener(t,n,!1)}}):e.attachEvent?(e.attachEvent("on"+t,n),{remove:function(){e.detachEvent("on"+t,n)}}):void 0},capture:function(e,t,n){return e.addEventListener?(e.addEventListener(t,n,!0),{remove:function(){e.removeEventListener(t,n,!0)}}):{remove:r}},registerDefault:function(){}};t.exports=o},{129:129}],123:[function(e,t,n){"use strict";var r=!("undefined"==typeof window||!window.document||!window.document.createElement),o={canUseDOM:r,canUseWorkers:"undefined"!=typeof Worker,canUseEventListeners:r&&!(!window.addEventListener&&!window.attachEvent),canUseViewport:r&&!!window.screen,isInWorker:!r};t.exports=o},{}],124:[function(e,t,n){"use strict";function r(e){return e.replace(o,function(e,t){return t.toUpperCase()})}var o=/-(.)/g;t.exports=r},{}],125:[function(e,t,n){"use strict";function r(e){return o(e.replace(i,"ms-"))}var o=e(124),i=/^-ms-/;t.exports=r},{124:124}],126:[function(e,t,n){"use strict";function r(e,t){return!(!e||!t)&&(e===t||!o(e)&&(o(t)?r(e,t.parentNode):"contains"in e?e.contains(t):!!e.compareDocumentPosition&&!!(16&e.compareDocumentPosition(t))))}var o=e(139);t.exports=r},{139:139}],127:[function(e,t,n){"use strict";function r(e){var t=e.length;if(Array.isArray(e)||"object"!=typeof e&&"function"!=typeof e?a(!1):void 0,"number"!=typeof t?a(!1):void 0,0===t||t-1 in e?void 0:a(!1),"function"==typeof e.callee?a(!1):void 0,e.hasOwnProperty)try{return Array.prototype.slice.call(e)}catch(e){}for(var n=Array(t),r=0;r<t;r++)n[r]=e[r];return n}function o(e){return!!e&&("object"==typeof e||"function"==typeof e)&&"length"in e&&!("setInterval"in e)&&"number"!=typeof e.nodeType&&(Array.isArray(e)||"callee"in e||"item"in e)}function i(e){return o(e)?Array.isArray(e)?e.slice():r(e):[e]}var a=e(137);t.exports=i},{137:137}],128:[function(e,t,n){"use strict";function r(e){var t=e.match(c);return t&&t[1].toLowerCase()}function o(e,t){var n=l;l?void 0:u(!1);var o=r(e),i=o&&s(o);if(i){n.innerHTML=i[1]+e+i[2];for(var c=i[0];c--;)n=n.lastChild}else n.innerHTML=e;var p=n.getElementsByTagName("script");p.length&&(t?void 0:u(!1),a(p).forEach(t));for(var d=Array.from(n.childNodes);n.lastChild;)n.removeChild(n.lastChild);return d}var i=e(123),a=e(127),s=e(133),u=e(137),l=i.canUseDOM?document.createElement("div"):null,c=/^\s*<(\w+)/;t.exports=o},{123:123,127:127,133:133,137:137}],129:[function(e,t,n){"use strict";function r(e){return function(){return e}}var o=function(){};o.thatReturns=r,o.thatReturnsFalse=r(!1),o.thatReturnsTrue=r(!0),o.thatReturnsNull=r(null),o.thatReturnsThis=function(){return this},o.thatReturnsArgument=function(e){return e},t.exports=o},{}],130:[function(e,t,n){"use strict";var r={};t.exports=r},{}],131:[function(e,t,n){"use strict";function r(e){try{e.focus()}catch(e){}}t.exports=r},{}],132:[function(e,t,n){"use strict";function r(){if("undefined"==typeof document)return null;try{return document.activeElement||document.body}catch(e){return document.body}}t.exports=r},{}],133:[function(e,t,n){"use strict";function r(e){return a?void 0:i(!1),d.hasOwnProperty(e)||(e="*"),s.hasOwnProperty(e)||("*"===e?a.innerHTML="<link />":a.innerHTML="<"+e+"></"+e+">",s[e]=!a.firstChild),s[e]?d[e]:null}var o=e(123),i=e(137),a=o.canUseDOM?document.createElement("div"):null,s={},u=[1,'<select multiple="true">',"</select>"],l=[1,"<table>","</table>"],c=[3,"<table><tbody><tr>","</tr></tbody></table>"],p=[1,'<svg xmlns="http://www.w3.org/2000/svg">',"</svg>"],d={"*":[1,"?<div>","</div>"],area:[1,"<map>","</map>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],legend:[1,"<fieldset>","</fieldset>"],param:[1,"<object>","</object>"],tr:[2,"<table><tbody>","</tbody></table>"],optgroup:u,option:u,caption:l,colgroup:l,tbody:l,tfoot:l,thead:l,td:c,th:c},f=["circle","clipPath","defs","ellipse","g","image","line","linearGradient","mask","path","pattern","polygon","polyline","radialGradient","rect","stop","text","tspan"];f.forEach(function(e){d[e]=p,s[e]=!0}),t.exports=r},{123:123,137:137}],134:[function(e,t,n){"use strict";function r(e){return e===window?{x:window.pageXOffset||document.documentElement.scrollLeft,y:window.pageYOffset||document.documentElement.scrollTop}:{x:e.scrollLeft,y:e.scrollTop}}t.exports=r},{}],135:[function(e,t,n){"use strict";function r(e){return e.replace(o,"-$1").toLowerCase()}var o=/([A-Z])/g;t.exports=r},{}],136:[function(e,t,n){"use strict";function r(e){return o(e).replace(i,"-ms-")}var o=e(135),i=/^ms-/;t.exports=r},{135:135}],137:[function(e,t,n){"use strict";function r(e,t,n,r,i,a,s,u){if(o(t),!e){var l;if(void 0===t)l=new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else{var c=[n,r,i,a,s,u],p=0;l=new Error(t.replace(/%s/g,function(){return c[p++]})),l.name="Invariant Violation"}throw l.framesToPop=1,l}}var o=function(e){};t.exports=r},{}],138:[function(e,t,n){"use strict";function r(e){return!(!e||!("function"==typeof Node?e instanceof Node:"object"==typeof e&&"number"==typeof e.nodeType&&"string"==typeof e.nodeName))}t.exports=r},{}],139:[function(e,t,n){"use strict";function r(e){return o(e)&&3==e.nodeType}var o=e(138);t.exports=r},{138:138}],140:[function(e,t,n){"use strict";function r(e){var t={};return function(n){return t.hasOwnProperty(n)||(t[n]=e.call(this,n)),t[n]}}t.exports=r},{}],141:[function(e,t,n){"use strict";function r(e,t){return e===t?0!==e||0!==t||1/e===1/t:e!==e&&t!==t}function o(e,t){if(r(e,t))return!0;if("object"!=typeof e||null===e||"object"!=typeof t||null===t)return!1;var n=Object.keys(e),o=Object.keys(t);if(n.length!==o.length)return!1;for(var a=0;a<n.length;a++)if(!i.call(t,n[a])||!r(e[n[a]],t[n[a]]))return!1;return!0}var i=Object.prototype.hasOwnProperty;t.exports=o},{}],142:[function(e,t,n){"use strict";var r=e(129),o=r;t.exports=o},{129:129}],143:[function(e,t,n){"use strict";function r(e){if(null===e||void 0===e)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(e)}function o(){try{if(!Object.assign)return!1;var e=new String("abc");if(e[5]="de","5"===Object.getOwnPropertyNames(e)[0])return!1;for(var t={},n=0;n<10;n++)t["_"+String.fromCharCode(n)]=n;var r=Object.getOwnPropertyNames(t).map(function(e){return t[e]});if("0123456789"!==r.join(""))return!1;var o={};return"abcdefghijklmnopqrst".split("").forEach(function(e){o[e]=e}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},o)).join("")}catch(e){return!1}}var i=Object.prototype.hasOwnProperty,a=Object.prototype.propertyIsEnumerable;t.exports=o()?Object.assign:function(e,t){for(var n,o,s=r(e),u=1;u<arguments.length;u++){n=Object(arguments[u]);for(var l in n)i.call(n,l)&&(s[l]=n[l]);if(Object.getOwnPropertySymbols){o=Object.getOwnPropertySymbols(n);for(var c=0;c<o.length;c++)a.call(n,o[c])&&(s[o[c]]=n[o[c]])}}return s}},{}]},{},[45])(45)})});
\ No newline at end of file
diff --git a/bemani/frontend/static/react.min.js b/bemani/frontend/static/react.min.js
new file mode 100644
index 0000000..b424edd
--- /dev/null
+++ b/bemani/frontend/static/react.min.js
@@ -0,0 +1,12 @@
+/**
+ * React v15.4.2
+ *
+ * Copyright 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+!function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var e;e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,e.React=t()}}(function(){return function t(e,n,r){function o(u,a){if(!n[u]){if(!e[u]){var s="function"==typeof require&&require;if(!a&&s)return s(u,!0);if(i)return i(u,!0);var c=new Error("Cannot find module '"+u+"'");throw c.code="MODULE_NOT_FOUND",c}var l=n[u]={exports:{}};e[u][0].call(l.exports,function(t){var n=e[u][1][t];return o(n?n:t)},l,l.exports,t,e,n,r)}return n[u].exports}for(var i="function"==typeof require&&require,u=0;u<r.length;u++)o(r[u]);return o}({1:[function(t,e,n){"use strict";function r(t){var e=/[=:]/g,n={"=":"=0",":":"=2"},r=(""+t).replace(e,function(t){return n[t]});return"$"+r}function o(t){var e=/(=0|=2)/g,n={"=0":"=","=2":":"},r="."===t[0]&&"$"===t[1]?t.substring(2):t.substring(1);return(""+r).replace(e,function(t){return n[t]})}var i={escape:r,unescape:o};e.exports=i},{}],2:[function(t,e,n){"use strict";var r=t(21),o=(t(25),function(t){var e=this;if(e.instancePool.length){var n=e.instancePool.pop();return e.call(n,t),n}return new e(t)}),i=function(t,e){var n=this;if(n.instancePool.length){var r=n.instancePool.pop();return n.call(r,t,e),r}return new n(t,e)},u=function(t,e,n){var r=this;if(r.instancePool.length){var o=r.instancePool.pop();return r.call(o,t,e,n),o}return new r(t,e,n)},a=function(t,e,n,r){var o=this;if(o.instancePool.length){var i=o.instancePool.pop();return o.call(i,t,e,n,r),i}return new o(t,e,n,r)},s=function(t){var e=this;t instanceof e?void 0:r("25"),t.destructor(),e.instancePool.length<e.poolSize&&e.instancePool.push(t)},c=10,l=o,f=function(t,e){var n=t;return n.instancePool=[],n.getPooled=e||l,n.poolSize||(n.poolSize=c),n.release=s,n},p={addPoolingTo:f,oneArgumentPooler:o,twoArgumentPooler:i,threeArgumentPooler:u,fourArgumentPooler:a};e.exports=p},{21:21,25:25}],3:[function(t,e,n){"use strict";var r=t(27),o=t(4),i=t(6),u=t(15),a=t(5),s=t(8),c=t(9),l=t(13),f=t(17),p=t(20),d=(t(26),c.createElement),y=c.createFactory,v=c.cloneElement,h=r,m={Children:{map:o.map,forEach:o.forEach,count:o.count,toArray:o.toArray,only:p},Component:i,PureComponent:u,createElement:d,cloneElement:v,isValidElement:c.isValidElement,PropTypes:l,createClass:a.createClass,createFactory:y,createMixin:function(t){return t},DOM:s,version:f,__spread:h};e.exports=m},{13:13,15:15,17:17,20:20,26:26,27:27,4:4,5:5,6:6,8:8,9:9}],4:[function(t,e,n){"use strict";function r(t){return(""+t).replace(E,"$&/")}function o(t,e){this.func=t,this.context=e,this.count=0}function i(t,e,n){var r=t.func,o=t.context;r.call(o,e,t.count++)}function u(t,e,n){if(null==t)return t;var r=o.getPooled(e,n);m(t,i,r),o.release(r)}function a(t,e,n,r){this.result=t,this.keyPrefix=e,this.func=n,this.context=r,this.count=0}function s(t,e,n){var o=t.result,i=t.keyPrefix,u=t.func,a=t.context,s=u.call(a,e,t.count++);Array.isArray(s)?c(s,o,n,h.thatReturnsArgument):null!=s&&(v.isValidElement(s)&&(s=v.cloneAndReplaceKey(s,i+(!s.key||e&&e.key===s.key?"":r(s.key)+"/")+n)),o.push(s))}function c(t,e,n,o,i){var u="";null!=n&&(u=r(n)+"/");var c=a.getPooled(e,u,o,i);m(t,s,c),a.release(c)}function l(t,e,n){if(null==t)return t;var r=[];return c(t,r,null,e,n),r}function f(t,e,n){return null}function p(t,e){return m(t,f,null)}function d(t){var e=[];return c(t,e,null,h.thatReturnsArgument),e}var y=t(2),v=t(9),h=t(23),m=t(22),b=y.twoArgumentPooler,g=y.fourArgumentPooler,E=/\/+/g;o.prototype.destructor=function(){this.func=null,this.context=null,this.count=0},y.addPoolingTo(o,b),a.prototype.destructor=function(){this.result=null,this.keyPrefix=null,this.func=null,this.context=null,this.count=0},y.addPoolingTo(a,g);var x={forEach:u,map:l,mapIntoWithKeyPrefixInternal:c,count:p,toArray:d};e.exports=x},{2:2,22:22,23:23,9:9}],5:[function(t,e,n){"use strict";function r(t){return t}function o(t,e){var n=E.hasOwnProperty(e)?E[e]:null;_.hasOwnProperty(e)&&("OVERRIDE_BASE"!==n?p("73",e):void 0),t&&("DEFINE_MANY"!==n&&"DEFINE_MANY_MERGED"!==n?p("74",e):void 0)}function i(t,e){if(e){"function"==typeof e?p("75"):void 0,v.isValidElement(e)?p("76"):void 0;var n=t.prototype,r=n.__reactAutoBindPairs;e.hasOwnProperty(b)&&x.mixins(t,e.mixins);for(var i in e)if(e.hasOwnProperty(i)&&i!==b){var u=e[i],a=n.hasOwnProperty(i);if(o(a,i),x.hasOwnProperty(i))x[i](t,u);else{var l=E.hasOwnProperty(i),f="function"==typeof u,d=f&&!l&&!a&&e.autobind!==!1;if(d)r.push(i,u),n[i]=u;else if(a){var y=E[i];!l||"DEFINE_MANY_MERGED"!==y&&"DEFINE_MANY"!==y?p("77",y,i):void 0,"DEFINE_MANY_MERGED"===y?n[i]=s(n[i],u):"DEFINE_MANY"===y&&(n[i]=c(n[i],u))}else n[i]=u}}}}function u(t,e){if(e)for(var n in e){var r=e[n];if(e.hasOwnProperty(n)){var o=n in x;o?p("78",n):void 0;var i=n in t;i?p("79",n):void 0,t[n]=r}}}function a(t,e){t&&e&&"object"==typeof t&&"object"==typeof e?void 0:p("80");for(var n in e)e.hasOwnProperty(n)&&(void 0!==t[n]?p("81",n):void 0,t[n]=e[n]);return t}function s(t,e){return function(){var n=t.apply(this,arguments),r=e.apply(this,arguments);if(null==n)return r;if(null==r)return n;var o={};return a(o,n),a(o,r),o}}function c(t,e){return function(){t.apply(this,arguments),e.apply(this,arguments)}}function l(t,e){var n=e.bind(t);return n}function f(t){for(var e=t.__reactAutoBindPairs,n=0;n<e.length;n+=2){var r=e[n],o=e[n+1];t[r]=l(t,o)}}var p=t(21),d=t(27),y=t(6),v=t(9),h=(t(12),t(11)),m=t(24),b=(t(25),t(26),"mixins"),g=[],E={mixins:"DEFINE_MANY",statics:"DEFINE_MANY",propTypes:"DEFINE_MANY",contextTypes:"DEFINE_MANY",childContextTypes:"DEFINE_MANY",getDefaultProps:"DEFINE_MANY_MERGED",getInitialState:"DEFINE_MANY_MERGED",getChildContext:"DEFINE_MANY_MERGED",render:"DEFINE_ONCE",componentWillMount:"DEFINE_MANY",componentDidMount:"DEFINE_MANY",componentWillReceiveProps:"DEFINE_MANY",shouldComponentUpdate:"DEFINE_ONCE",componentWillUpdate:"DEFINE_MANY",componentDidUpdate:"DEFINE_MANY",componentWillUnmount:"DEFINE_MANY",updateComponent:"OVERRIDE_BASE"},x={displayName:function(t,e){t.displayName=e},mixins:function(t,e){if(e)for(var n=0;n<e.length;n++)i(t,e[n])},childContextTypes:function(t,e){t.childContextTypes=d({},t.childContextTypes,e)},contextTypes:function(t,e){t.contextTypes=d({},t.contextTypes,e)},getDefaultProps:function(t,e){t.getDefaultProps?t.getDefaultProps=s(t.getDefaultProps,e):t.getDefaultProps=e},propTypes:function(t,e){t.propTypes=d({},t.propTypes,e)},statics:function(t,e){u(t,e)},autobind:function(){}},_={replaceState:function(t,e){this.updater.enqueueReplaceState(this,t),e&&this.updater.enqueueCallback(this,e,"replaceState")},isMounted:function(){return this.updater.isMounted(this)}},P=function(){};d(P.prototype,y.prototype,_);var w={createClass:function(t){var e=r(function(t,n,r){this.__reactAutoBindPairs.length&&f(this),this.props=t,this.context=n,this.refs=m,this.updater=r||h,this.state=null;var o=this.getInitialState?this.getInitialState():null;"object"!=typeof o||Array.isArray(o)?p("82",e.displayName||"ReactCompositeComponent"):void 0,this.state=o});e.prototype=new P,e.prototype.constructor=e,e.prototype.__reactAutoBindPairs=[],g.forEach(i.bind(null,e)),i(e,t),e.getDefaultProps&&(e.defaultProps=e.getDefaultProps()),e.prototype.render?void 0:p("83");for(var n in E)e.prototype[n]||(e.prototype[n]=null);return e},injection:{injectMixin:function(t){g.push(t)}}};e.exports=w},{11:11,12:12,21:21,24:24,25:25,26:26,27:27,6:6,9:9}],6:[function(t,e,n){"use strict";function r(t,e,n){this.props=t,this.context=e,this.refs=u,this.updater=n||i}var o=t(21),i=t(11),u=(t(18),t(24));t(25),t(26);r.prototype.isReactComponent={},r.prototype.setState=function(t,e){"object"!=typeof t&&"function"!=typeof t&&null!=t?o("85"):void 0,this.updater.enqueueSetState(this,t),e&&this.updater.enqueueCallback(this,e,"setState")},r.prototype.forceUpdate=function(t){this.updater.enqueueForceUpdate(this),t&&this.updater.enqueueCallback(this,t,"forceUpdate")};e.exports=r},{11:11,18:18,21:21,24:24,25:25,26:26}],7:[function(t,e,n){"use strict";var r={current:null};e.exports=r},{}],8:[function(t,e,n){"use strict";var r=t(9),o=r.createFactory,i={a:o("a"),abbr:o("abbr"),address:o("address"),area:o("area"),article:o("article"),aside:o("aside"),audio:o("audio"),b:o("b"),base:o("base"),bdi:o("bdi"),bdo:o("bdo"),big:o("big"),blockquote:o("blockquote"),body:o("body"),br:o("br"),button:o("button"),canvas:o("canvas"),caption:o("caption"),cite:o("cite"),code:o("code"),col:o("col"),colgroup:o("colgroup"),data:o("data"),datalist:o("datalist"),dd:o("dd"),del:o("del"),details:o("details"),dfn:o("dfn"),dialog:o("dialog"),div:o("div"),dl:o("dl"),dt:o("dt"),em:o("em"),embed:o("embed"),fieldset:o("fieldset"),figcaption:o("figcaption"),figure:o("figure"),footer:o("footer"),form:o("form"),h1:o("h1"),h2:o("h2"),h3:o("h3"),h4:o("h4"),h5:o("h5"),h6:o("h6"),head:o("head"),header:o("header"),hgroup:o("hgroup"),hr:o("hr"),html:o("html"),i:o("i"),iframe:o("iframe"),img:o("img"),input:o("input"),ins:o("ins"),kbd:o("kbd"),keygen:o("keygen"),label:o("label"),legend:o("legend"),li:o("li"),link:o("link"),main:o("main"),map:o("map"),mark:o("mark"),menu:o("menu"),menuitem:o("menuitem"),meta:o("meta"),meter:o("meter"),nav:o("nav"),noscript:o("noscript"),object:o("object"),ol:o("ol"),optgroup:o("optgroup"),option:o("option"),output:o("output"),p:o("p"),param:o("param"),picture:o("picture"),pre:o("pre"),progress:o("progress"),q:o("q"),rp:o("rp"),rt:o("rt"),ruby:o("ruby"),s:o("s"),samp:o("samp"),script:o("script"),section:o("section"),select:o("select"),small:o("small"),source:o("source"),span:o("span"),strong:o("strong"),style:o("style"),sub:o("sub"),summary:o("summary"),sup:o("sup"),table:o("table"),tbody:o("tbody"),td:o("td"),textarea:o("textarea"),tfoot:o("tfoot"),th:o("th"),thead:o("thead"),time:o("time"),title:o("title"),tr:o("tr"),track:o("track"),u:o("u"),ul:o("ul"),var:o("var"),video:o("video"),wbr:o("wbr"),circle:o("circle"),clipPath:o("clipPath"),defs:o("defs"),ellipse:o("ellipse"),g:o("g"),image:o("image"),line:o("line"),linearGradient:o("linearGradient"),mask:o("mask"),path:o("path"),pattern:o("pattern"),polygon:o("polygon"),polyline:o("polyline"),radialGradient:o("radialGradient"),rect:o("rect"),stop:o("stop"),svg:o("svg"),text:o("text"),tspan:o("tspan")};e.exports=i},{9:9}],9:[function(t,e,n){"use strict";function r(t){return void 0!==t.ref}function o(t){return void 0!==t.key}var i=t(27),u=t(7),a=(t(26),t(18),Object.prototype.hasOwnProperty),s=t(10),c={key:!0,ref:!0,__self:!0,__source:!0},l=function(t,e,n,r,o,i,u){var a={$$typeof:s,type:t,key:e,ref:n,props:u,_owner:i};return a};l.createElement=function(t,e,n){var i,s={},f=null,p=null,d=null,y=null;if(null!=e){r(e)&&(p=e.ref),o(e)&&(f=""+e.key),d=void 0===e.__self?null:e.__self,y=void 0===e.__source?null:e.__source;for(i in e)a.call(e,i)&&!c.hasOwnProperty(i)&&(s[i]=e[i])}var v=arguments.length-2;if(1===v)s.children=n;else if(v>1){for(var h=Array(v),m=0;m<v;m++)h[m]=arguments[m+2];s.children=h}if(t&&t.defaultProps){var b=t.defaultProps;for(i in b)void 0===s[i]&&(s[i]=b[i])}return l(t,f,p,d,y,u.current,s)},l.createFactory=function(t){var e=l.createElement.bind(null,t);return e.type=t,e},l.cloneAndReplaceKey=function(t,e){var n=l(t.type,e,t.ref,t._self,t._source,t._owner,t.props);return n},l.cloneElement=function(t,e,n){var s,f=i({},t.props),p=t.key,d=t.ref,y=t._self,v=t._source,h=t._owner;if(null!=e){r(e)&&(d=e.ref,h=u.current),o(e)&&(p=""+e.key);var m;t.type&&t.type.defaultProps&&(m=t.type.defaultProps);for(s in e)a.call(e,s)&&!c.hasOwnProperty(s)&&(void 0===e[s]&&void 0!==m?f[s]=m[s]:f[s]=e[s])}var b=arguments.length-2;if(1===b)f.children=n;else if(b>1){for(var g=Array(b),E=0;E<b;E++)g[E]=arguments[E+2];f.children=g}return l(t.type,p,d,y,v,h,f)},l.isValidElement=function(t){return"object"==typeof t&&null!==t&&t.$$typeof===s},e.exports=l},{10:10,18:18,26:26,27:27,7:7}],10:[function(t,e,n){"use strict";var r="function"==typeof Symbol&&Symbol.for&&Symbol.for("react.element")||60103;e.exports=r},{}],11:[function(t,e,n){"use strict";function r(t,e){}var o=(t(26),{isMounted:function(t){return!1},enqueueCallback:function(t,e){},enqueueForceUpdate:function(t){r(t,"forceUpdate")},enqueueReplaceState:function(t,e){r(t,"replaceState")},enqueueSetState:function(t,e){r(t,"setState")}});e.exports=o},{26:26}],12:[function(t,e,n){"use strict";var r={};e.exports=r},{}],13:[function(t,e,n){"use strict";function r(t,e){return t===e?0!==t||1/t===1/e:t!==t&&e!==e}function o(t){this.message=t,this.stack=""}function i(t){function e(e,n,r,i,u,a,s){if(i=i||N,a=a||r,null==n[r]){var c=_[u];return e?new o(null===n[r]?"The "+c+" `"+a+"` is marked as required "+("in `"+i+"`, but its value is `null`."):"The "+c+" `"+a+"` is marked as required in "+("`"+i+"`, but its value is `undefined`.")):null}return t(n,r,i,u,a)}var n=e.bind(null,!1);return n.isRequired=e.bind(null,!0),n}function u(t){function e(e,n,r,i,u,a){var s=e[n],c=b(s);if(c!==t){var l=_[i],f=g(s);return new o("Invalid "+l+" `"+u+"` of type "+("`"+f+"` supplied to `"+r+"`, expected ")+("`"+t+"`."))}return null}return i(e)}function a(){return i(w.thatReturns(null))}function s(t){function e(e,n,r,i,u){if("function"!=typeof t)return new o("Property `"+u+"` of component `"+r+"` has invalid PropType notation inside arrayOf.");var a=e[n];if(!Array.isArray(a)){var s=_[i],c=b(a);return new o("Invalid "+s+" `"+u+"` of type "+("`"+c+"` supplied to `"+r+"`, expected an array."))}for(var l=0;l<a.length;l++){var f=t(a,l,r,i,u+"["+l+"]",P);if(f instanceof Error)return f}return null}return i(e)}function c(){function t(t,e,n,r,i){var u=t[e];if(!x.isValidElement(u)){var a=_[r],s=b(u);return new o("Invalid "+a+" `"+i+"` of type "+("`"+s+"` supplied to `"+n+"`, expected a single ReactElement."))}return null}return i(t)}function l(t){function e(e,n,r,i,u){if(!(e[n]instanceof t)){var a=_[i],s=t.name||N,c=E(e[n]);return new o("Invalid "+a+" `"+u+"` of type "+("`"+c+"` supplied to `"+r+"`, expected ")+("instance of `"+s+"`."))}return null}return i(e)}function f(t){function e(e,n,i,u,a){for(var s=e[n],c=0;c<t.length;c++)if(r(s,t[c]))return null;var l=_[u],f=JSON.stringify(t);return new o("Invalid "+l+" `"+a+"` of value `"+s+"` "+("supplied to `"+i+"`, expected one of "+f+"."))}return Array.isArray(t)?i(e):w.thatReturnsNull}function p(t){function e(e,n,r,i,u){if("function"!=typeof t)return new o("Property `"+u+"` of component `"+r+"` has invalid PropType notation inside objectOf.");var a=e[n],s=b(a);if("object"!==s){var c=_[i];return new o("Invalid "+c+" `"+u+"` of type "+("`"+s+"` supplied to `"+r+"`, expected an object."))}for(var l in a)if(a.hasOwnProperty(l)){var f=t(a,l,r,i,u+"."+l,P);if(f instanceof Error)return f}return null}return i(e)}function d(t){function e(e,n,r,i,u){for(var a=0;a<t.length;a++){var s=t[a];if(null==s(e,n,r,i,u,P))return null}var c=_[i];return new o("Invalid "+c+" `"+u+"` supplied to "+("`"+r+"`."))}return Array.isArray(t)?i(e):w.thatReturnsNull}function y(){function t(t,e,n,r,i){if(!h(t[e])){var u=_[r];return new o("Invalid "+u+" `"+i+"` supplied to "+("`"+n+"`, expected a ReactNode."))}return null}return i(t)}function v(t){function e(e,n,r,i,u){var a=e[n],s=b(a);if("object"!==s){var c=_[i];return new o("Invalid "+c+" `"+u+"` of type `"+s+"` "+("supplied to `"+r+"`, expected `object`."))}for(var l in t){var f=t[l];if(f){var p=f(a,l,r,i,u+"."+l,P);if(p)return p}}return null}return i(e)}function h(t){switch(typeof t){case"number":case"string":case"undefined":return!0;case"boolean":return!t;case"object":if(Array.isArray(t))return t.every(h);if(null===t||x.isValidElement(t))return!0;var e=A(t);if(!e)return!1;var n,r=e.call(t);if(e!==t.entries){for(;!(n=r.next()).done;)if(!h(n.value))return!1}else for(;!(n=r.next()).done;){var o=n.value;if(o&&!h(o[1]))return!1}return!0;default:return!1}}function m(t,e){return"symbol"===t||"Symbol"===e["@@toStringTag"]||"function"==typeof Symbol&&e instanceof Symbol}function b(t){var e=typeof t;return Array.isArray(t)?"array":t instanceof RegExp?"object":m(e,t)?"symbol":e}function g(t){var e=b(t);if("object"===e){if(t instanceof Date)return"date";if(t instanceof RegExp)return"regexp"}return e}function E(t){return t.constructor&&t.constructor.name?t.constructor.name:N}var x=t(9),_=t(12),P=t(14),w=t(23),A=t(19),N=(t(26),"<<anonymous>>"),O={array:u("array"),bool:u("boolean"),func:u("function"),number:u("number"),object:u("object"),string:u("string"),symbol:u("symbol"),any:a(),arrayOf:s,element:c(),instanceOf:l,node:y(),objectOf:p,oneOf:f,oneOfType:d,shape:v};o.prototype=Error.prototype,e.exports=O},{12:12,14:14,19:19,23:23,26:26,9:9}],14:[function(t,e,n){"use strict";var r="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";e.exports=r},{}],15:[function(t,e,n){"use strict";function r(t,e,n){this.props=t,this.context=e,this.refs=s,this.updater=n||a}function o(){}var i=t(27),u=t(6),a=t(11),s=t(24);o.prototype=u.prototype,r.prototype=new o,r.prototype.constructor=r,i(r.prototype,u.prototype),r.prototype.isPureReactComponent=!0,e.exports=r},{11:11,24:24,27:27,6:6}],16:[function(t,e,n){"use strict";var r=t(27),o=t(3),i=r({__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED:{ReactCurrentOwner:t(7)}},o);e.exports=i},{27:27,3:3,7:7}],17:[function(t,e,n){"use strict";e.exports="15.4.2"},{}],18:[function(t,e,n){"use strict";var r=!1;e.exports=r},{}],19:[function(t,e,n){"use strict";function r(t){var e=t&&(o&&t[o]||t[i]);if("function"==typeof e)return e}var o="function"==typeof Symbol&&Symbol.iterator,i="@@iterator";e.exports=r},{}],20:[function(t,e,n){"use strict";function r(t){return i.isValidElement(t)?void 0:o("143"),t}var o=t(21),i=t(9);t(25);e.exports=r},{21:21,25:25,9:9}],21:[function(t,e,n){"use strict";function r(t){for(var e=arguments.length-1,n="Minified React error #"+t+"; visit http://facebook.github.io/react/docs/error-decoder.html?invariant="+t,r=0;r<e;r++)n+="&args[]="+encodeURIComponent(arguments[r+1]);n+=" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";var o=new Error(n);throw o.name="Invariant Violation",o.framesToPop=1,o}e.exports=r},{}],22:[function(t,e,n){"use strict";function r(t,e){return t&&"object"==typeof t&&null!=t.key?c.escape(t.key):e.toString(36)}function o(t,e,n,i){var p=typeof t;if("undefined"!==p&&"boolean"!==p||(t=null),null===t||"string"===p||"number"===p||"object"===p&&t.$$typeof===a)return n(i,t,""===e?l+r(t,0):e),1;var d,y,v=0,h=""===e?l:e+f;if(Array.isArray(t))for(var m=0;m<t.length;m++)d=t[m],y=h+r(d,m),v+=o(d,y,n,i);else{var b=s(t);if(b){var g,E=b.call(t);if(b!==t.entries)for(var x=0;!(g=E.next()).done;)d=g.value,y=h+r(d,x++),v+=o(d,y,n,i);else for(;!(g=E.next()).done;){var _=g.value;_&&(d=_[1],y=h+c.escape(_[0])+f+r(d,0),v+=o(d,y,n,i))}}else if("object"===p){var P="",w=String(t);u("31","[object Object]"===w?"object with keys {"+Object.keys(t).join(", ")+"}":w,P)}}return v}function i(t,e,n){return null==t?0:o(t,"",e,n)}var u=t(21),a=(t(7),t(10)),s=t(19),c=(t(25),t(1)),l=(t(26),"."),f=":";e.exports=i},{1:1,10:10,19:19,21:21,25:25,26:26,7:7}],23:[function(t,e,n){"use strict";function r(t){return function(){return t}}var o=function(){};o.thatReturns=r,o.thatReturnsFalse=r(!1),o.thatReturnsTrue=r(!0),o.thatReturnsNull=r(null),o.thatReturnsThis=function(){return this},o.thatReturnsArgument=function(t){return t},e.exports=o},{}],24:[function(t,e,n){"use strict";var r={};e.exports=r},{}],25:[function(t,e,n){"use strict";function r(t,e,n,r,i,u,a,s){if(o(e),!t){var c;if(void 0===e)c=new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else{var l=[n,r,i,u,a,s],f=0;c=new Error(e.replace(/%s/g,function(){return l[f++]})),c.name="Invariant Violation"}throw c.framesToPop=1,c}}var o=function(t){};e.exports=r},{}],26:[function(t,e,n){"use strict";var r=t(23),o=r;e.exports=o},{23:23}],27:[function(t,e,n){"use strict";function r(t){if(null===t||void 0===t)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(t)}function o(){try{if(!Object.assign)return!1;var t=new String("abc");if(t[5]="de","5"===Object.getOwnPropertyNames(t)[0])return!1;for(var e={},n=0;n<10;n++)e["_"+String.fromCharCode(n)]=n;var r=Object.getOwnPropertyNames(e).map(function(t){return e[t]});if("0123456789"!==r.join(""))return!1;var o={};return"abcdefghijklmnopqrst".split("").forEach(function(t){o[t]=t}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},o)).join("")}catch(t){return!1}}var i=Object.prototype.hasOwnProperty,u=Object.prototype.propertyIsEnumerable;e.exports=o()?Object.assign:function(t,e){for(var n,o,a=r(t),s=1;s<arguments.length;s++){n=Object(arguments[s]);for(var c in n)i.call(n,c)&&(a[c]=n[c]);if(Object.getOwnPropertySymbols){o=Object.getOwnPropertySymbols(n);for(var l=0;l<o.length;l++)u.call(n,o[l])&&(a[o[l]]=n[o[l]])}}return a}},{}]},{},[16])(16)});
\ No newline at end of file
diff --git a/bemani/frontend/static/regions.js b/bemani/frontend/static/regions.js
new file mode 100644
index 0000000..8201d30
--- /dev/null
+++ b/bemani/frontend/static/regions.js
@@ -0,0 +1,56 @@
+var Regions = [
+    null,
+    "北海道",
+    "青森県",
+    "岩手県",
+    "宮城県",
+    "秋田県",
+    "山形県",
+    "福島県",
+    "茨城県",
+    "栃木県",
+    "群馬県",
+    "埼玉県",
+    "千葉県",
+    "東京都",
+    "神奈川県",
+    "新潟県",
+    "富山県",
+    "石川県",
+    "福井県",
+    "山梨県",
+    "長野県",
+    "岐阜県",
+    "静岡県",
+    "愛知県",
+    "三重県",
+    "滋賀県",
+    "京都府",
+    "大阪府",
+    "兵庫県",
+    "奈良県",
+    "和歌山県",
+    "鳥取県",
+    "島根県",
+    "岡山県",
+    "広島県",
+    "山口県",
+    "徳島県",
+    "香川県",
+    "愛媛県",
+    "高知県",
+    "福岡県",
+    "佐賀県",
+    "長崎県",
+    "熊本県",
+    "大分県",
+    "宮崎県",
+    "鹿児島県",
+    "沖縄県",
+    "香港",
+    "韓国",
+    "台湾",
+    "米国 (USA)",
+    "欧州 (Europe)",
+    "海外 (Other)",
+];
diff --git a/bemani/frontend/static/section.css b/bemani/frontend/static/section.css
new file mode 100644
index 0000000..86a03ea
--- /dev/null
+++ b/bemani/frontend/static/section.css
@@ -0,0 +1,183 @@
+div.container div.section:not(:first-child) {
+    padding-top: 20px;
+    clear: both;
+}
+
+div.container div.floating.right {
+    float: right;
+}
+
+span.separator {
+    font-size: large;
+    font-weight: bold;
+    padding-left: 5px;
+    padding-right: 5px;
+}
+
+div.labelledsection.horizontal {
+    display: inline-block;
+    margin: 0px;
+}
+
+div.labelledsection.vertical {
+    display: block;
+    margin-bottom: 5px;
+}
+
+div.labelledsection.horizontal:not(:last-child):not(:only-child) {
+    margin-right: 20px;
+}
+
+div.labelledsection div.label {
+    font-weight: bold;
+}
+
+div.labelledsection div.content {
+    margin: 0px;
+    padding-bottom: 0px;
+    font-size: small;
+}
+
+div.labelledsection.centered div.content, div.labelledsection.centered div.label {
+    text-align: center;
+}
+
+div.labelledsection.padded {
+    text-align: center;
+    width: 150px;
+    padding-top: 20px;
+    padding-bottom: 20px;
+}
+
+div.labelledsection.filled {
+    background-color: #f7f7f7;
+    border: 1px dashed #dddddd;
+}
+
+span.separator {
+    font-size: large;
+    font-weight: bold;
+    padding-left: 5px;
+    padding-right: 5px;
+}
+
+div.labelledsection.iidx.themeoption select {
+    width: 200px;
+}
+
+div.labelledsection.ddr.option select {
+    width: 200px;
+}
+
+div.iidx.menuoption label, div.arcade.menuoption label {
+    position: relative;
+    vertical-align: middle;
+    bottom: 3px;
+    font-size: small;
+}
+
+div.iidx.menuoption, div.arcade.menuoption {
+    padding-bottom: 5px;
+}
+
+div.arcade.menuoption label {
+    display: inline-block;
+    min-width: 200px;
+}
+
+div.score span.label {
+    font-size: smaller;
+    font-weight: bold;
+}
+
+div.score span.status {
+    font-size: smaller;
+    font-weight: bold;
+}
+
+div.score span.score {
+    padding-left: 3px;
+    padding-right: 3px;
+}
+
+div.score span.grade {
+    font-weight: bold;
+    padding-right: 3px;
+}
+
+div.songname {
+    font-weight: bold;
+    font-size: large;
+}
+
+div.songartist, div.songgenre, div.songdifficulty, div.songplays {
+    font-size: small;
+}
+
+span.file {
+    font-family: monospace;
+}
+
+ul.ownerlist {
+    margin: 0px;
+    padding: 0px;
+}
+
+ul.ownerlist li {
+    margin-left: 25px;
+    margin-right: 10px;
+}
+
+div.card {
+    display: inline-block;
+    font-family: monospace;
+}
+
+div.placeholder, span.placeholder {
+    font-style: italic;
+}
+
+div.timestamp {
+    font-style: italic;
+    font-size: small;
+    padding-bottom: 5px;
+}
+
+span.loading {
+    font-size: small;
+}
+
+span.raised {
+    font-style: italic;
+    font-size: small;
+    font-weight: bold;
+}
+
+dl {
+    margin: 0px;
+}
+
+dt {
+    font-weight: bold;
+}
+
+dd {
+    margin: 0px;
+    padding-bottom: 5px;
+}
+
+div.longmessage {
+    margin-bottom: 10px;
+}
+
+div.longmessage pre {
+    border: 1px solid rgba(128, 128, 128, 0.33);
+    background: rgb(232, 232, 232);
+    padding: 5px;
+    margin-bottom: 0px;
+}
+
+span.filter:not(:last-child) {
+    padding-right: 20px;
+}
+
diff --git a/bemani/frontend/static/site.css b/bemani/frontend/static/site.css
new file mode 100644
index 0000000..1901a71
--- /dev/null
+++ b/bemani/frontend/static/site.css
@@ -0,0 +1,269 @@
+body {
+    font-family: Helvetica;
+    margin: 0px;
+    padding-bottom: 30px;
+}
+
+div.messages {
+    padding-top: 0px;
+    padding-bottom: 0px;
+    padding-left: 10px;
+    padding-right: 10px;
+    margin: 0px;
+}
+
+div.container {
+    padding-top: 15px;
+    padding-bottom: 0px;
+    padding-left: 30px;
+    padding-right: 30px;
+    margin: 0px;
+}
+
+div.loading {
+    margin-left: 50%;
+    margin-right: 50%;
+    height: 20px;
+}
+
+div.navigation {
+    background-color: whitesmoke;
+    padding-left: 10px;
+    padding-right: 10px;
+}
+
+.tinynav {
+    display: none;
+}
+
+@media only screen and (max-width: 600px) {
+    .tinynav {
+        display: inline-block;
+        width: 100%;
+        margin-top: 10px;
+        margin-bottom: 10px;
+    }
+    #nav {
+        display: none;
+    }
+}
+
+@media only screen and (hover: none) {
+    .tinynav {
+        display: inline-block;
+        width: 100%;
+        margin-top: 10px;
+        margin-bottom: 10px;
+    }
+    #nav {
+        display: none;
+    }
+}
+
+ul.messages {
+    list-style: none;
+    padding: 0px;
+    margin: 0px;
+}
+
+ul.messages li {
+    padding: 5px;
+    margin-top: 10px;
+    border-radius: 5px;
+    font-size: smaller;
+}
+
+ul.messages div.close {
+    font-size: smaller;
+    text-decoration: none;
+    display: inline-block;
+    color: #000000;
+    float: right;
+    cursor: pointer;
+}
+
+ul.messages li.error {
+    border: 1px solid #e2afb6;
+    background-color: #ffced5;
+}
+
+ul.messages li.warning {
+    border: 1px solid #e6deb4;
+    background-color: #fff7ce;
+}
+
+ul.messages li.success {
+    border: 1px solid #cddcc1;
+    background: #e7ffd4;
+}
+
+ul.messages li.info {
+    border: 1px solid #b0b0d2;
+    background-color: #d0d0ff;
+}
+
+ul.navigation {
+    list-style: none;
+    padding-top: 0px;
+    padding-bottom: 0px;
+    padding-left: 10px;
+    padding-right: 10px;
+    margin: 0px;
+    background-color: whitesmoke;
+    position: relative;
+    text-align: right;
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+ul.navigation li {
+    display: inline-block;
+    padding: 0px;
+}
+
+ul.navigation_sub {
+    display: none;
+    position: absolute;
+    top: 100%;
+    background-color: #e4e4e4;
+    padding: 10px;
+    margin: 0;
+    padding: 0;
+    min-width: 150px;
+    text-align: left;
+}
+
+ul.navigation_sub li {
+    float: none;
+    display: block;
+    position: relative;
+    padding: 0px;
+    margin: 0px;
+}
+
+ul.navigation_sub li a {
+    display: block;
+}
+
+a.cursor {
+    cursor: default;
+}
+
+ul.navigation li:hover ul.navigation_sub {
+    display: block;
+}
+
+ul.navigation li.left {
+    float: left;
+}
+
+ul.navigation div.separator {
+    cursor: default;
+    width: 25px;
+}
+
+ul.navigation li a {
+    border: 0px solid #676767;
+    display: block;
+    text-decoration: none;
+    padding: 10px;
+    color: #676767;
+}
+
+ul.navigation li a:hover {
+    background-color: #d2d2d2;
+}
+
+ul.navigation li a:active {
+    background-color: #d2d2d2;
+}
+
+ul.navigation > li > a.current {
+    border-bottom-width: 2px;
+    border-bottom-style: solid;
+    padding-bottom: 8px;
+}
+
+ul.navigation > li > ul.navigation_sub > li > a.current {
+    border-left-width: 2px;
+    border-left-style: solid;
+    padding-left: 8px;
+}
+
+h1, h2, h3, h4, h5 {
+    padding-top: 0px;
+    margin-top: 0px;
+}
+
+img.loading {
+    vertical-align: text-bottom;
+}
+
+div.tooltip {
+    position: relative;
+    display: inline-block;
+}
+
+button.nav span.alert {
+    padding-left: 5px;
+    color: #459900;
+    font-weight: bold;
+}
+
+div.tooltip span.tooltiptext {
+    visibility: hidden;
+    background-color: #555;
+    color: #fff;
+    text-align: center;
+    padding: 5px 0;
+    border-radius: 6px;
+    width: 300px;
+
+    /* Position the tooltip text */
+    position: absolute;
+    top: -5px;
+    left: 105%;
+    z-index: 1;
+}
+
+div.tooltip span.tooltiptext::after {
+    content: "";
+    position: absolute;
+    top: 15px;
+    right: 100%;
+    margin-top: -5px;
+    border-width: 5px;
+    border-style: solid;
+    border-color: transparent #555 transparent transparent;
+}
+
+div.tooltip:hover span.tooltiptext {
+    visibility: visible;
+}
+
+div.pill {
+    display: inline-block;
+    border: 1px solid red;
+    background: pink;
+    border-radius: 5px;
+    padding-left: 10px;
+    margin-left: 10px;
+    padding-right: 10px;
+}
+
+pre {
+    white-space: pre-wrap;
+}
+
+span.sort {
+    float: right;
+}
+
+span.checkbox {
+    padding-right: 5px;
+    cursor: default;
+}
diff --git a/bemani/frontend/static/table.css b/bemani/frontend/static/table.css
new file mode 100644
index 0000000..099d50e
--- /dev/null
+++ b/bemani/frontend/static/table.css
@@ -0,0 +1,135 @@
+table.list, table.add {
+    border-collapse: collapse;
+}
+
+thead tr th {
+    cursor: default;
+}
+
+table.add th {
+    text-align: left;
+    padding: 5px;
+}
+
+table.list th {
+    background-color: #e7e7e7;
+    font-weight: bold;
+    padding: 10px;
+    text-align: left;
+    border: 1px solid #e0e0e0;
+}
+
+table.list th.action {
+    background-color: #ffffff;
+    border: none;
+}
+
+table.list tbody td, table.add tbody td {
+    padding: 5px;
+    vertical-align: top;
+}
+
+table.list tbody td {
+    border: 1px solid #e0e0e0;
+    padding: 10px;
+}
+
+table td.center {
+    word-break: break-word;
+    text-align: center;
+}
+
+table.list input[type="text"], table.add input[type="text"] {
+    width: 100%;
+}
+
+table.list select, table.add select {
+    width: 100%;
+}
+
+table.list tbody tr:nth-child(odd) td {
+    background-color: #f7f7f7;
+}
+
+table.list tbody tr:nth-child(even) td {
+    background-color: #ffffff;
+}
+
+table td.subheader {
+    background-color: #e7e7e7 ! important;
+    font-weight: bold;
+}
+
+table tfoot td {
+    padding-top: 5px;
+}
+
+table.records, table.attempts, table.topscores, table.players, table.events {
+    width: 100%;
+}
+
+table.records a, table.attempts a, table.topscores a, table.players a {
+    text-decoration: none;
+}
+
+td.edit {
+    background-color: #ffffff ! important;
+    border: none ! important;
+}
+
+td.nochart {
+    background-color: #e7e7e7 ! important;
+}
+
+table.list input[type="checkbox"], table.add input[type="checkbox"] {
+    width: 21px;
+    height: 21px;
+    margin: 0px;
+}
+
+table.events div.circle {
+    width: 16px;
+    height: 16px;
+    -webkit-border-radius: 8px;
+    -moz-border-radius: 8px;
+    border-radius: 8px;
+    display: inline-block;
+    margin-left: 0px;
+    margin-right: 5px;
+    margin-top: 2px;
+    margin-bottom: -2px;
+}
+
+table.events td.details div.inline {
+    display: inline-block;
+    margin-right: 5px;
+}
+
+table.events td.details pre.inline {
+    display: inline-block;
+    margin: 0px;
+}
+
+table.events td.exception div.circle {
+    background-color: rgb(214, 72, 72);
+}
+
+table.events td.unhandled div.circle {
+    background-color: rgb(255, 165, 0);
+}
+
+table.events td.unauthorized div.circle {
+    background-color: rgb(119, 0, 119);
+}
+
+table.events td.scheduled div.circle {
+    background-color: #2d6ccc;
+}
+
+table.events td.pcbevent div.circle {
+    background-color: #26a226;
+}
+
+table.events td.transaction div.circle {
+    background-color: #f9ed00;
+}
diff --git a/bemani/frontend/static/tinynav.js b/bemani/frontend/static/tinynav.js
new file mode 100644
index 0000000..7edcd8c
--- /dev/null
+++ b/bemani/frontend/static/tinynav.js
@@ -0,0 +1,87 @@
+/*! http://tinynav.viljamis.com v1.2 by @viljamis */
+(function ($, window, i) {
+  $.fn.tinyNav = function (options) {
+
+    // Default settings
+    var settings = $.extend({
+      'active' : 'selected', // String: Set the "active" class
+      'header' : '', // String: Specify text for "header" and show header instead of the active item
+      'indent' : '- ', // String: Specify text for indenting sub-items
+      'label'  : '' // String: sets the <label> text for the <select> (if not set, no label will be added)
+    }, options);
+
+    return this.each(function () {
+
+      // Used for namespacing
+      i++;
+
+      var $nav = $(this),
+        // Namespacing
+        namespace = 'tinynav',
+        namespace_i = namespace + i,
+        l_namespace_i = '.l_' + namespace_i,
+        $select = $('<select/>').attr("id", namespace_i).addClass(namespace + ' ' + namespace_i);
+
+      if ($nav.is('ul,ol')) {
+
+        if (settings.header !== '') {
+          $select.append(
+            $('<option/>').text(settings.header)
+          );
+        }
+
+        // Build options
+        var options = '';
+
+        $nav
+          .addClass('l_' + namespace_i)
+          .find('a')
+          .each(function () {
+            if ($(this).attr('href')) {
+                options += '<option value="' + $(this).attr('href') + '">';
+            } else {
+                options += '<option value="__NOT_A_PAGE__" disabled>';
+            }
+            var j;
+            for (j = 0; j < $(this).parents('ul, ol').length - 1; j++) {
+              options += settings.indent;
+            }
+            options += $(this).text() + '</option>';
+          });
+
+        // Append options into a select
+        $select.append(options);
+
+        // Select the active item
+        if (!settings.header) {
+          $select
+            .find(':eq(' + $(l_namespace_i + ' li')
+            .index($(l_namespace_i + ' li.' + settings.active)) + ')')
+            .attr('selected', true);
+        }
+
+        // Change window location
+        $select.change(function () {
+          if ($(this).val() == "__NOT_A_PAGE__") { return; }
+          window.location.href = $(this).val();
+        });
+
+        // Inject select
+        $(l_namespace_i).after($select);
+
+        // Inject label
+        if (settings.label) {
+          $select.before(
+            $("<label/>")
+              .attr("for", namespace_i)
+              .addClass(namespace + '_label ' + namespace_i + '_label')
+              .append(settings.label)
+          );
+        }
+
+      }
+
+    });
+
+  };
+})(jQuery, this, 0);
diff --git a/bemani/frontend/templates/403.html b/bemani/frontend/templates/403.html
new file mode 100644
index 0000000..a73ffbe
--- /dev/null
+++ b/bemani/frontend/templates/403.html
@@ -0,0 +1,4 @@
+{% extends "base.html" %}
+{% block content %}
+    You do not have permission to access this page!
+{% endblock %}
diff --git a/bemani/frontend/templates/404.html b/bemani/frontend/templates/404.html
new file mode 100644
index 0000000..b469c44
--- /dev/null
+++ b/bemani/frontend/templates/404.html
@@ -0,0 +1,4 @@
+{% extends "base.html" %}
+{% block content %}
+    The requested page could not be found!
+{% endblock %}
diff --git a/bemani/frontend/templates/500.html b/bemani/frontend/templates/500.html
new file mode 100644
index 0000000..ab2d215
--- /dev/null
+++ b/bemani/frontend/templates/500.html
@@ -0,0 +1,4 @@
+{% extends "base.html" %}
+{% block content %}
+    Everything is all fucked up!
+{% endblock %}
diff --git a/bemani/frontend/templates/__init__.py b/bemani/frontend/templates/__init__.py
new file mode 100644
index 0000000..786afc8
--- /dev/null
+++ b/bemani/frontend/templates/__init__.py
@@ -0,0 +1,3 @@
+import os
+
+templates_location = os.path.abspath(os.path.dirname(__file__))
diff --git a/bemani/frontend/templates/account/login.html b/bemani/frontend/templates/account/login.html
new file mode 100644
index 0000000..394cb63
--- /dev/null
+++ b/bemani/frontend/templates/account/login.html
@@ -0,0 +1,19 @@
+{% extends "base.html" %}
+{% block content %}
+    <div class="section">
+        <h2>Login</h2>
+        <form action="{{ url_for('account_pages.login') }}" method="post">
+            <dl>
+                <dt>Username</dt>
+                <dd><input type="text" name="username" value="{{ username }}"/></dd>
+                <dt>Password</dt>
+                <dd><input type="password" name="password" /></dd>
+                <dt></dt>
+                <dd><input type="submit" value="login" /></dd>
+            </dl>
+        </form>
+    </div>
+    <div class="section">
+        Don't have an account? <a href="{{ url_for('account_pages.viewregister') }}">Create one!</a>
+    </div>
+{% endblock %}
diff --git a/bemani/frontend/templates/account/register.html b/bemani/frontend/templates/account/register.html
new file mode 100644
index 0000000..8fd3dba
--- /dev/null
+++ b/bemani/frontend/templates/account/register.html
@@ -0,0 +1,27 @@
+{% extends "base.html" %}
+{% block content %}
+    <div class="section">
+        <h2>Register New Account</h2>
+
+        <form action="{{ url_for('account_pages.register') }}" method=post>
+            <dl>
+                <dt>Card Number (found on back of e-AMUSEMENT card)</dt>
+                <dd><input type="text" name="card_number" value="{{ card_number }}" /></dd>
+                <dt>PIN</dt>
+                <dd><input type="password" name="pin" /></dd>
+                <dt>&nbsp;</dt>
+                <dd></dd>
+                <dt>Desired Username</dt>
+                <dd><input type="text" name="username" value="{{ username }}" /></dd>
+                <dt>Email Address (used for password and pin resetting)</dt>
+                <dd><input type="text" name="email" value="{{ email }}" /></dd>
+                <dt>Desired Password</dt>
+                <dd><input type="password" name="password1" /></dd>
+                <dt>Desired Password (again)</dt>
+                <dd><input type="password" name="password2" /></dd>
+                <dt></dt>
+                <dd><input type="submit" value="create account" /></dd>
+            </dl>
+        </form>
+    </div>
+{% endblock %}
diff --git a/bemani/frontend/templates/admin/settings.html b/bemani/frontend/templates/admin/settings.html
new file mode 100644
index 0000000..8d68620
--- /dev/null
+++ b/bemani/frontend/templates/admin/settings.html
@@ -0,0 +1,61 @@
+{% extends "base.html" %}
+{% block content %}
+    <div class="section">
+        To change any of these settings, edit <span class="file">server.yaml</span>.
+    </div>
+    <div class="section">
+        <h3>Database Settings</h3>
+        <dl>
+            <dt>Host</dt>
+            <dd>{{ config['database']['address'] }}</dd>
+            <dt>Database</dt>
+            <dd>{{ config['database']['database'] }}</dd>
+            <dt>User</dt>
+            <dd>{{ config['database']['user'] }}</dd>
+            <dt>Password</dt>
+            <dd>&bull;&bull;&bull;&bull;&bull;&bull;</dd>
+        </dl>
+    </div>
+    <div class="section">
+        <h3>Backend Settings</h3>
+        <dl>
+            <dt>Host</dt>
+            <dd>{{ config['server']['address'] }}</dd>
+            <dt>Port</dt>
+            <dd>{{ config['server']['port'] }}</dd>
+            <dt>HTTPS</dt>
+            <dd>{{ 'active' if config['server']['https'] else 'inactive' }}</dd>
+            <dt>Keepalive Address</dt>
+            <dd>{{ config['server']['keepalive'] }}</dd>
+            <dt>HTTP Get Redirect Address</dt>
+            <dd>{{ config['server']['redirect'] if config['server']['redirect'] else 'disabled' }}</dd>
+        </dl>
+    </div>
+    <div class="section">
+        <h3>Frontend Settings</h3>
+        <dl>
+            <dt>Web Address</dt>
+            <dd>{{ config['server']['uri'] if config['server']['uri'] else 'http://eagate.573.jp' }}</dd>
+            <dt>Network Name</dt>
+            <dd>{{ config.get('name','e-AMUSEMENT Network') }}</dd>
+        </dl>
+    </div>
+    <div class="section">
+        <h3>Data Exchange API Settings</h3>
+        <dl>
+            <dt>Administrative Email</dt>
+            <dd>{{ config.get('email','nobody@nowhere.com') }}</dd>
+        </dl>
+    </div>
+    <div class="section">
+        <h3>Server Settings</h3>
+        <dl>
+            <dt>PCBID Enforcement</dt>
+            <dd>{{ 'active' if config['server']['enforce_pcbid'] else 'inactive' }}</dd>
+            <dt>PASELI Enabled</dt>
+            <dd>{{ 'yes' if config['paseli']['enabled'] else 'no' }} (can be overridden by arcade settings)</dd>
+            <dt>Infinite PASELI Enabled</dt>
+            <dd>{{ 'yes' if config['paseli']['infinite'] else 'no' }} (can be overridden by arcade settings)</dd>
+        </dl>
+    </div>
+{% endblock %}
diff --git a/bemani/frontend/templates/base.html b/bemani/frontend/templates/base.html
new file mode 100644
index 0000000..c001be3
--- /dev/null
+++ b/bemani/frontend/templates/base.html
@@ -0,0 +1,170 @@
+<html>
+    <head>
+		{% if title %}
+		<title>{{ title }}</title>
+		{% endif %}
+        <link rel="icon" type="image/png" href="{{ url_for('static', filename='favicon.png') }}" />
+        <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='site.css') }}" />
+        <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='color.css') }}" />
+        <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='form.css') }}" />
+        <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='section.css') }}" />
+        <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='table.css') }}" />
+        <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='jquery-confirm.css') }}" />
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <script type="text/javascript" src="{{ url_for('static', filename='chart.bundle.min.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='date.format.min.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='jquery-1.12.4.min.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='jquery-confirm.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='jquery.touchSwipe.min.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='tinynav.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='react.min.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='react-dom.min.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='ajax.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='messages.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='history.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='regions.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='iidx-options.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='ddr-options.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='link.js') }}"></script>
+        <script type="text/javascript" src="{{ url_for('static', filename='merge.js') }}"></script>
+        {% for entry in components %}
+        <script type="text/javascript" src="{{ url_for('jsx', filename=entry) }}"></script>
+        {% endfor %}
+        <script type="text/javascript">
+            $(function () {
+                $("#nav").tinyNav();
+            });
+        </script>
+        <script type="text/javascript">
+            window.floaterrors = function(skipheightadjust) {
+                if($(this).scrollTop()>$('div.messages-anchor').position().top){
+                    if (!window.floated) {
+                        var width = $('div.messages').width();
+                        var height = $('div.messages').height();
+                        if (height > 0) {
+                            $('div.messages').css({position:'fixed',top:0, width: width, 'z-index': 1});
+                            if (skipheightadjust) {
+                                $('div.messages-anchor').css({height: ''});
+                            } else {
+                                $('div.messages-anchor').css({height: height + 10});
+                            }
+                            window.floated = true;
+                        }
+                    }
+                } else {
+                    $('div.messages').css({position:'', width: '', top: ''});
+                    $('div.messages-anchor').css({height: ''});
+                    window.floated = false;
+                }
+            };
+            $(window).scroll(function() { window.floaterrors(false); });
+            $(document).on('click', 'div.close', function(event) {
+                $(event.target).parent().hide();
+                if (window.floated) {
+                    var height = $('div.messages').height();
+                    if (height > 0) {
+                        $('div.messages-anchor').css({height: height + 10});
+                    } else {
+                        $('div.messages-anchor').css({height: ''});
+                    }
+                }
+            });
+        </script>
+        <script type="text/javascript">
+            window.uris = {};
+            {% if links is defined %}
+                {% for name, link in links.items() %}
+                    window.uris[{{name|tojson|safe}}] = {{ link|tojson|safe }};
+                {% endfor %}
+            {% endif %}
+            {% if inits is defined %}
+                {% for name, val in inits.items() %}
+                    window.{{name}} = {{ val|tojson|safe }};
+                {% endfor %}
+            {% endif %}
+        </script>
+        <script type="text/javascript">
+            $(function () {
+                if( /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ) {
+                    $(".container").swipe(
+                        {
+                            swipeLeft: function(event) {
+                                $("button.next").trigger("click");
+                                event.preventDefault();
+                            },
+                            swipeRight: function(event) {
+                                $("button.prev").trigger("click");
+                                event.preventDefault();
+                            },
+                            threshold: 30,
+                            fingers: 'all',
+                        }
+                    );
+                }
+            });
+        </script>
+        {% block scripts %}{% endblock %}
+	</head>
+	<body>
+        {% if show_navigation %}
+        <div class="navigation">
+            <ul class="navigation" id="nav">
+                {% for entry in navigation %}
+                <li class="{{ 'right' if entry.get('right_justify') else 'left' }} {{ 'selected' if entry['uri'] == current_path or (((entry.get('base_uri', '/nonexistent') or '/nonexistent') in current_path) and not (any(entry.get('entries'), 'uri', current_path))) else '' }}">
+                        {% with uri = entry.get('uri') %}
+                            {% with label = entry.get('label') %}
+                                {% if label %}
+                                    {% if uri %}
+                                    <a
+                                        class="{{ 'current' if (entry['uri'] == current_path) or (any(entry.get('entries'), 'uri', current_path)) or ((entry.get('base_uri', '/nonexistent') or '/nonexistent') in current_path) else ''}} {{entry['gamecode']}} border"
+                                        href="{{ entry['uri'] }}"
+                                    >{{ entry['label'] }}</a>
+                                    {% else %}
+                                    <a
+                                        class="cursor {{ 'current' if (entry['uri'] == current_path) or (any(entry.get('entries'), 'uri', current_path)) or ((entry.get('base_uri', '/nonexistent') or '/nonexistent') in current_path) else ''}} {{entry['gamecode']}} border"
+                                    >{{ entry['label'] }}</a>
+                                    {% endif %}
+                                {% else %}
+                                    <div class="separator">&nbsp;</div>
+                                {% endif %}
+                            {% endwith %}
+                        {% endwith %}
+                        {% with subentries = entry.get('entries') %}
+                            {% if subentries %}
+                                <ul class="navigation_sub">
+                                    {% for subentry in subentries %}
+                                        <li class="{{ 'selected' if subentry['uri'] == current_path else '' }}">
+                                            <a
+                                                class="{{ 'current' if (subentry['uri'] == current_path) else '' }}"
+                                                href="{{ subentry['uri'] }}"
+                                            >{{ subentry['label'] }}</a>
+                                        </li>
+                                    {% endfor %}
+                                </ul>
+                            {% endif %}
+                        {% endwith %}
+                    </li>
+                {% endfor %}
+            </ul>
+        </div>
+        {% endif %}
+        <div class="messages-anchor"></div>
+        <div class="messages">
+            <ul class="messages">
+                {% with messages = get_flashed_messages(with_categories=true) %}
+                    {% if messages %}
+                        {% for category, message in messages %}
+                        <li class="{{ category }}">
+                            {{ message }}
+                            <div class="close">&#10005;</div>
+                        </li>
+                        {% endfor %}
+                    {% endif %}
+                {% endwith %}
+            </ul>
+        </div>
+        <div class="container">
+    	    {% block content %}{% endblock %}
+        </div>
+	</body>
+</html>
diff --git a/bemani/frontend/templates/react.html b/bemani/frontend/templates/react.html
new file mode 100644
index 0000000..847e174
--- /dev/null
+++ b/bemani/frontend/templates/react.html
@@ -0,0 +1,11 @@
+{% extends "base.html" %}
+{% block scripts %}
+    <script type="text/javascript" defer="defer" src="{{ url_for('jsx', filename=reactbase) }}"></script>
+{% endblock %}
+{% block content %}
+    <div id="content">
+        <div class="loading">
+            <img src="{{ url_for('static', filename='loading-20.gif') }}" />
+        </div>
+    </div>
+{% endblock %}
diff --git a/bemani/protocol/__init__.py b/bemani/protocol/__init__.py
new file mode 100644
index 0000000..ede896f
--- /dev/null
+++ b/bemani/protocol/__init__.py
@@ -0,0 +1,2 @@
+from bemani.protocol.protocol import EAmuseProtocol, EAmuseException
+from bemani.protocol.node import Node
diff --git a/bemani/protocol/binary.py b/bemani/protocol/binary.py
new file mode 100644
index 0000000..f879fea
--- /dev/null
+++ b/bemani/protocol/binary.py
@@ -0,0 +1,779 @@
+import struct
+from typing import Optional, List, Dict, Any
+
+from bemani.protocol.stream import InputStream, OutputStream
+from bemani.protocol.node import Node
+
+
+class BinaryEncodingException(Exception):
+    """
+    Generic exception to be thrown when we encounter an issue decoding a binary stream
+    """
+
+
+class PackedOrdering:
+    """
+    A class that helps us encapsulate Konami's batshit backtracking hole-fill algorithm.
+    Everything is aligned on a boundary appropriate for its data size. Strings and arrays are
+    forced to be aligned to a 4 byte boundary on account of having an integer length field.
+    All of these are padded to 4 bytes in terms of the room they take up in the stream.
+    For the things that are 2 byte or 1 byte aligned, we end up sticking them after each other
+    in 4 byte increments. That is, to say, if we have a unsigned byte to pack, we reserve 4 bytes
+    and stick it in the first byte slot, and if up to three additional bytes come in we will pack
+    them after this in sequential order. It would make sense to not pad out strings and arrays and
+    store bytes/shorts in these unused locations, but that's not what actually happens. Also note
+    that we will never pack bytes after a short or vice versa, even if there is room. This also explains
+    the bizarre behavior of not using spare bytes after strings or arrays. I'll emphasize again:
+    everything is stored aligned, and in a 4 byte chunk, only similarly-sized objects can be packed. If
+    this 4 byte chunk is already partially occupied, we can only add another thing to it if 1) the
+    item being added is the same size as the object that exists and 2) the object can be added with
+    the correct alignment.
+
+    A simple example:
+        [1: byte] [2: byte] [3: integer]
+    Packing would look like this (assuming all locations are a byte):
+        1 2 0 0 3 3 3 3
+
+    An example:
+        [1: byte] [2: string, length 3] [3: short] [4: byte]
+    Packing would look like this (assuming all locations are a byte):
+        1 4 0 0 2 2 2 2 2 2 2 0 3 3 0 0
+    """
+
+    def __init__(self, size: int, allow_expansion: bool=False) -> None:
+        """
+        Initialize with a known size. If this is to be used to create a packing instead of deduce
+        a packing, then allow_expansion should be set to true and new holes will be created when
+        needed. If this is to be used for decoding a current packing, allow_expansion should be set
+        to False to ensure we don't choose locations outside the buffer.
+
+        Parameters:
+            size - Number of bytes to work with as an integer
+            allow_expansion - Boolean describing whether to add to the end of the order when needed
+        """
+        self.order: List[int] = []
+        self.expand = allow_expansion
+
+        for i in range(size):
+            self.order.append(None)
+        self.__orderlen = size
+        self.__lastbyte = 0
+        self.__lastshort = 0
+        self.__lastint = 0
+
+    def __append_empty(self) -> None:
+        self.order.append(None)
+        self.__orderlen = self.__orderlen + 1
+
+    def mark_used(self, size: int, offset: int, round_to: int=1) -> None:
+        """
+        Mark size bytes at offset as being used. If needed, round to the nearest byte/half/integer.
+
+        Parameters:
+            size - Number of bytes to mark
+            offset - Offset into binary chunk to start marking
+            round_to - Optional integer specifying how many bytes to round to. Valid values are 1, 2 and 4
+        """
+        # Round to nearest value if needed
+        while (size & (round_to - 1)) != 0:
+            size = size + 1
+
+        # Expand buffer if needed
+        if self.expand:
+            while self.__orderlen < (size + offset):
+                self.__append_empty()
+
+        # Mark buffer as used
+        for i in range(size):
+            self.order[i + offset] = size
+
+    def get_next_byte(self) -> Optional[int]:
+        """
+        Returns an integer location where the next byte will be found/stored, respecting Konami logic.
+        Will return None if its not possible to find this integer a spot and we aren't expanding.
+        """
+        # If we expand for additions, make sure we've padded to a 4 byte boundary
+        if self.expand:
+            while (self.__orderlen & 3) != 0:
+                self.__append_empty()
+
+        for i in range(self.__lastbyte, self.__orderlen, 4):
+            if self.order[i] is not None:
+                # See if this has room for a byte
+                for j in range(0, 4):
+                    if self.order[i + j] == 1:
+                        # This is okay, we can pack after this
+                        continue
+                    elif self.order[i + j] is None:
+                        # This is open, pack here
+                        self.__lastbyte = i
+                        return i + j
+                    else:
+                        # This is something else, can't pack here
+                        break
+            else:
+                # Couldn't find optimal packing, pack here
+                self.__lastbyte = i
+                return i
+
+        if self.expand:
+            self.__lastbyte = self.__orderlen
+            return self.__orderlen
+        else:
+            return None
+
+    def get_next_short(self) -> Optional[int]:
+        """
+        Returns an integer location where the next short will be found/stored, respecting Konami logic.
+        Will return None if its not possible to find this integer a spot and we aren't expanding.
+        """
+        # If we expand for additions, make sure we've padded to a 4 byte boundary
+        if self.expand:
+            while (self.__orderlen & 3) != 0:
+                self.__append_empty()
+
+        for i in range(self.__lastshort, self.__orderlen, 4):
+            if self.order[i] is not None:
+                for j in range(0, 4, 2):
+                    if self.order[i + j] == 2 and self.order[i + j + 1] == 2:
+                        # This is okay, we can pack after this
+                        continue
+                    elif self.order[i + j] is None and self.order[i + j + 1] is None:
+                        # This is open, pack here
+                        self.__lastshort = i
+                        return i + j
+                    else:
+                        # This is something else, can't pack here
+                        break
+            else:
+                # Couldn't find optimal packing, pack here
+                self.__lastshort = i
+                return i
+
+        if self.expand:
+            self.__lastshort = self.__orderlen
+            return self.__orderlen
+        else:
+            return None
+
+    def get_next_int(self) -> Optional[int]:
+        """
+        Returns an integer location where the next integer will be found/stored, respecting Konami logic.
+        Will return None if its not possible to find this integer a spot and we aren't expanding.
+        """
+        # If we expand for additions, make sure we've padded to a 4 byte boundary
+        if self.expand:
+            while (self.__orderlen & 3) != 0:
+                self.__append_empty()
+
+        for i in range(self.__lastint, self.__orderlen, 4):
+            if self.order[i] is not None:
+                continue
+            if self.order[i + 1] is not None:
+                continue
+            if self.order[i + 2] is not None:
+                continue
+            if self.order[i + 3] is not None:
+                continue
+
+            self.__lastint = i
+            return i
+
+        if self.expand:
+            self.__lastint = self.__orderlen
+            return self.__orderlen
+        else:
+            return None
+
+    @staticmethod
+    def node_to_body_ordering(node: Node, include_children: bool=True, include_void: bool=False) -> List[Dict[str, Any]]:
+        """
+        Walk this node, attributes and children in the correct order to create a node
+        ordering for the purpose of mapping Node objects to their actual data
+        in a binary packet data chunk. We will use this to unpack data to determine the
+        values of nodes, or to create the data that goes with these nodes.
+
+        Paramters:
+            include_children - Whether this ordering should include children. Defaults to True.
+            include_void - Whether this ordering should include positions for void nodes. Defaults
+                           to false.
+
+        Returns:
+            List of dictionary objects:
+                - type - 'attribute' or 'value' to specify that this position in the
+                         node walk is a string attribute or a node value
+                - node - This Node object, for the purpose of assignment
+                - name - The name of the attribute if type is 'attribute' or the name
+                         of the node if type is 'value'
+                - alignment - The alignment that this particular data object requiers
+        """
+        ordering = []
+
+        # Include the node itself if it has a value or we include voids
+        if node.data_length != 0 or include_void:
+            alignment = node.data_length
+            if alignment is None:
+                # Take care of string types
+                alignment = 4
+            if alignment > 4:
+                # Take care of 64 bit integers that are 32 bit aligned
+                alignment = 4
+
+            ordering.append({
+                'type': 'value',
+                'node': node,
+                'name': node.name,
+                'alignment': alignment,
+            })
+
+        order = sorted(node.attributes.keys())
+        for attr in order:
+            ordering.append({
+                'type': 'attribute',
+                'node': node,
+                'name': attr,
+                'alignment': 4,
+            })
+
+        if include_children:
+            for child in node.children:
+                ordering.extend(PackedOrdering.node_to_body_ordering(child))
+
+        return ordering
+
+
+class BinaryDecoder:
+    """
+    A class capable of taking a binary blob and decoding it to a Node tree.
+    """
+
+    def __init__(self, data: bytes, encoding: str) -> None:
+        """
+        Initialize the object.
+
+        Parameters:
+            - data - A binary blob of data to be decoded
+            - encoding - A string representing the text encoding for string elements. Should be either
+                         'shift-jis', 'euc-jp' or 'utf-8'
+        """
+        self.stream = InputStream(data)
+        self.encoding = encoding
+        self.executed = False
+
+    def __read_node_name(self) -> str:
+        """
+        Given the current position in the stream, read the 6-bit-byte packed string name of the
+        node.
+
+        Returns:
+            A string representing the name in ascii
+        """
+        length = self.stream.read_int()
+        binary_length = int(((length * 6) + 7) / 8)
+
+        def int_to_bin(integer: int) -> str:
+            val = bin(integer)[2:]
+            while len(val) < 8:
+                val = '0' + val
+
+            return val
+
+        data = ''
+        for i in range(binary_length):
+            data = data + int_to_bin(self.stream.read_int())
+        data_str = [data[i:(i + 6)] for i in range(0, len(data), 6)]
+        data_int = [int(val, 2) for val in data_str]
+        ret = ''.join([Node.NODE_NAME_CHARS[val] for val in data_int])
+        ret = ret[:length]
+        return ret
+
+    def __read_node(self, node_type: int) -> Node:
+        """
+        Given an integer node type, read the node's name, possible attributes
+        and children. Will return a Node representing this node. Note
+        that calling this on the first node should return a tree of all nodes.
+
+        Returns:
+            Node object
+        """
+        name = self.__read_node_name()
+        node = Node(name=name, type=node_type)
+
+        while True:
+            child_type = self.stream.read_int()
+
+            if child_type == Node.END_OF_NODE:
+                return node
+            elif child_type == Node.ATTR_TYPE:
+                key = self.__read_node_name()
+                node.add_attribute(key)
+            else:
+                child = self.__read_node(child_type)
+                node.add_child(child)
+
+    def get_tree(self) -> Node:
+        """
+        Parse the header and body such that we can return a Node tree
+        representing the data passed to us.
+
+        Returns:
+            Node object
+        """
+        if self.executed:
+            raise Exception("Logic error, should only call this once per instance")
+        self.executed = True
+
+        # Read the header first
+        header_length = self.stream.read_int(4)
+
+        root = self.__read_node(self.stream.read_int())
+
+        eod = self.stream.read_int()
+        if eod != Node.END_OF_DOCUMENT:
+            raise BinaryEncodingException('Unknown node type {} at end of document'.format(eod))
+
+        # Skip by any padding
+        while self.stream.pos < header_length + 4:
+            self.stream.read_byte()
+
+        # Read the body next
+        body_length = self.stream.read_int(4)
+
+        if body_length is not None and body_length > 0:
+            # We have a body
+            body = self.stream.read_blob(body_length)
+            if body is None:
+                raise BinaryEncodingException('Body has insufficient data')
+
+            ordering = PackedOrdering(body_length)
+
+            values = PackedOrdering.node_to_body_ordering(root)
+
+            for value in values:
+                node = value['node']
+
+                if value['type'] == 'attribute':
+                    size = None
+                    enc = 's'
+                    dtype = 'str'
+                    array = False
+                    composite = False
+                else:
+                    size = node.data_length
+                    enc = node.data_encoding
+                    dtype = node.data_type
+                    array = node.is_array
+                    composite = node.is_composite
+
+                if composite and array:
+                    raise Exception('Logic error, no support for composite arrays!')
+
+                if not array:
+                    # Scalar value
+                    alignment = value['alignment']
+
+                    if alignment == 1:
+                        loc = ordering.get_next_byte()
+                    elif alignment == 2:
+                        loc = ordering.get_next_short()
+                    elif alignment == 4:
+                        loc = ordering.get_next_int()
+
+                    if size is None:
+                        # The size should be read from the first 4 bytes
+                        size = struct.unpack('>I', body[loc:(loc + 4)])[0]
+                        ordering.mark_used(size + 4, loc, round_to=4)
+                        loc = loc + 4
+
+                        decode_data = body[loc:(loc + size)]
+                        decode_value = '>{}{}'.format(size, enc)
+                    else:
+                        # The size is built-in
+                        ordering.mark_used(size, loc)
+
+                        decode_data = body[loc:(loc + size)]
+                        decode_value = '>{}'.format(enc)
+
+                    if composite:
+                        val_list = list(struct.unpack(decode_value, decode_data))
+                        if value['type'] == 'attribute':
+                            raise Exception('Logic error, shouldn\'t have composite attribute type!')
+                        node.set_value(val_list)
+                        continue
+
+                    val = struct.unpack(decode_value, decode_data)[0]
+
+                    if dtype == 'str':
+                        # Need to convert this from encoding to standard string.
+                        # Also, need to lob off the trailing null.
+                        try:
+                            val = val[:-1].decode(self.encoding)
+                        except UnicodeDecodeError:
+                            # Nothing we can do here
+                            pass
+
+                    if value['type'] == 'attribute':
+                        node.set_attribute(value['name'], val)
+                    else:
+                        node.set_value(val)
+                else:
+                    # Array value
+                    loc = ordering.get_next_int()
+
+                    # The raw size in bytes
+                    length = struct.unpack('>I', body[loc:(loc + 4)])[0]
+                    elems = int(length / size)
+
+                    ordering.mark_used(length + 4, loc, round_to=4)
+                    loc = loc + 4
+                    decode_data = body[loc:(loc + length)]
+                    decode_value = '>{}'.format(enc * elems)
+
+                    val = struct.unpack(decode_value, decode_data)
+                    node.set_value([v for v in val])
+
+        return root
+
+
+class BinaryEncoder:
+    """
+    A class capable of taking a Node tree and encoding it into a binary format.
+    """
+
+    def __init__(self, tree: Node, encoding: str) -> None:
+        """
+        Initialize the object.
+
+        Parameters:
+            tree - A binary blob of data to be decoded
+            encoding - A string representing the text encoding for string elements. Should be either
+                       'shift-jis', 'euc-jp' or 'utf-8'
+        """
+        self.stream = OutputStream()
+        self.encoding = encoding
+        self.tree = tree
+        self.__body: List[int] = []
+        self.__body_len = 0
+        self.executed = False
+
+        # Generate the characer LUT
+        self.char_lut: Dict[str, int] = {}
+        for i in range(len(Node.NODE_NAME_CHARS)):
+            self.char_lut[Node.NODE_NAME_CHARS[i]] = i
+
+    def __write_node_name(self, name: str) -> None:
+        """
+        Given the current position in the stream, write the 6-bit-byte packed string name of the
+        node.
+
+        Parameters:
+            name - A string name which should be encoded as a node name
+        """
+        def char_to_bin(ch: str) -> str:
+            index = self.char_lut[ch]
+            val = bin(index)[2:]
+
+            while len(val) < 6:
+                val = '0' + val
+
+            return val[-6:]
+
+        # Convert to six bit bytes
+        length = len(name)
+        data = ''.join([char_to_bin(c) for c in name])
+
+        # Pad out the rest with zeros
+        while (len(data) & 0x7) != 0:
+            data = data + '0'
+
+        # Convert to 8-bit bytes
+        data_chunks = [data[i:(i + 8)] for i in range(0, len(data), 8)]
+        data_int = [int(val, 2) for val in data_chunks]
+
+        # Output
+        self.stream.write_int(length)
+        for val in data_int:
+            self.stream.write_int(val)
+
+    def __write_node(self, node: Node) -> None:
+        """
+        Given an integer node type, read the node's name, possible attributes
+        and children. Will return a Node representing this node. Note
+        that calling this on the first node should return a tree of all nodes.
+
+        Parameters:
+            node - A Node which should be encoded.
+        """
+        to_write = PackedOrdering.node_to_body_ordering(node, include_children=False, include_void=True)
+        for thing in to_write:
+            # First, write the type of this node out
+            if thing['type'] == 'value':
+                self.stream.write_int(thing['node'].type)
+            else:
+                self.stream.write_int(Node.ATTR_TYPE)
+            # Now, write the name out
+            self.__write_node_name(thing['name'])
+
+        # Now, write out the children
+        for child in node.children:
+            self.__write_node(child)
+
+        # Now, write out the end of node marker
+        self.stream.write_int(Node.END_OF_NODE)
+
+    def __add_data(self, data: bytes, length: int, offset: int) -> None:
+        """
+        Given some binary data, a length and an offset, add the data to the offset in the
+        output body. This function will ensure that any new bytes that aren't copied are
+        zero'd out. This includes bytes before the offset as well as any pad bytes after
+        the offset + length in order to pad this body to a 4 byte boundary.
+
+        Parameters:
+            data - A blob of binary data which should be copied into the output
+            length - Number of characters of data to copy
+            offset - Offset into the body to start copying
+        """
+        while self.__body_len < (length + offset):
+            self.__body.append(0)
+            self.__body_len = self.__body_len + 1
+
+        # Make sure its padded to 4 bytes
+        while (self.__body_len & 0x3) != 0:
+            self.__body.append(0)
+            self.__body_len = self.__body_len + 1
+
+        for i in range(length):
+            self.__body[offset + i] = data[i]
+
+    def get_data(self) -> bytes:
+        """
+        Encode the header and body into binary formrt.
+
+        Returns:
+            Binary blob of data that can be decoded by a game.
+        """
+        if self.executed:
+            raise Exception("Logic error, should only call this once per instance")
+        self.executed = True
+
+        # Generate the header first
+        self.__write_node(self.tree)
+        self.stream.write_int(Node.END_OF_DOCUMENT)
+        self.stream.write_pad(4)
+
+        header_length = len(self.stream.data)
+        header = self.stream.data[:]
+
+        # Generate the body
+        values = PackedOrdering.node_to_body_ordering(self.tree)
+        if len(values) > 0:
+            ordering = PackedOrdering(0, allow_expansion=True)
+
+            for value in values:
+                node = value['node']
+
+                if value['type'] == 'attribute':
+                    size = None
+                    enc = 's'
+                    dtype = 'str'
+                    array = False
+                    composite = False
+                    val = node.attribute(value['name'])
+                else:
+                    size = node.data_length
+                    enc = node.data_encoding
+                    dtype = node.data_type
+                    array = node.is_array
+                    composite = node.is_composite
+                    val = node.value
+
+                if val is None:
+                    raise BinaryEncodingException(
+                        'Node \'{}\' has invalid value None'.format(value['name']),
+                    )
+
+                if not array:
+                    # Scalar value
+                    alignment = value['alignment']
+
+                    if alignment == 1:
+                        loc = ordering.get_next_byte()
+                    elif alignment == 2:
+                        loc = ordering.get_next_short()
+                    elif alignment == 4:
+                        loc = ordering.get_next_int()
+
+                    if dtype == 'str':
+                        # Need to convert this to encoding from standard string.
+                        # Also, need to lob off the trailing null.
+                        if not isinstance(val, str):
+                            raise BinaryEncodingException(
+                                'Node \'{}\' has non-string value!'.format(value['name']),
+                            )
+
+                        try:
+                            valbytes = val.encode(self.encoding) + b'\0'
+                        except UnicodeEncodeError:
+                            raise BinaryEncodingException(
+                                'Node \'{}\' has un-encodable string value \'{}\''.format(value['name'], val)
+                            )
+                        size = len(valbytes)
+                        self.__add_data(struct.pack('>I', size) + valbytes, size + 4, loc)
+                        ordering.mark_used(size + 4, loc, round_to=4)
+
+                        # We took care of this one
+                        continue
+                    elif dtype == 'bin':
+                        # Store raw binary
+                        size = len(val)
+                        self.__add_data(struct.pack('>I', size) + val, size + 4, loc)
+                        ordering.mark_used(size + 4, loc, round_to=4)
+
+                        # We took care of this one
+                        continue
+                    elif composite:
+                        # Array, but not, somewhat silly
+                        encode_value = '>{}'.format(enc)
+                        self.__add_data(struct.pack(encode_value, *val), size, loc)
+                        ordering.mark_used(size, loc)
+
+                        # We took care of this one
+                        continue
+                    elif dtype == 'bool':
+                        val = 1 if val else 0
+
+                    # The size is built-in, emit it
+                    encode_value = '>{}'.format(enc)
+                    self.__add_data(struct.pack(encode_value, val), size, loc)
+                    ordering.mark_used(size, loc)
+                else:
+                    # Array value
+                    loc = ordering.get_next_int()
+
+                    # The raw size in bytes
+                    elems = len(val)
+                    length = elems * size
+
+                    # Write out the header (number of bytes taken up)
+                    data = struct.pack('>I', length)
+                    encode_value = '>{}'.format(enc)
+
+                    # Write out data one element at a time
+                    for v in val:
+                        if dtype == 'bool':
+                            data = data + struct.pack(encode_value, 1 if v else 0)
+                        else:
+                            data = data + struct.pack(encode_value, v)
+
+                    self.__add_data(data, length + 4, loc)
+                    ordering.mark_used(length + 4, loc, round_to=4)
+
+        return b''.join([
+            struct.pack('>I', header_length),
+            header,
+            struct.pack('>I', self.__body_len),
+            bytes(self.__body),
+        ])
+
+
+class BinaryEncoding:
+    """
+    Wrapper class representing a Binary Encoding.
+    """
+    # The string values should match the constants in EAmuseProtocol.
+    # I have no better way to link these than to write this comment,
+    # as otherwise we would have a circular dependency.
+    MAGIC = {
+        0xA04200FF: "ascii",
+        0xA04220DF: "shift-jis-legacy",
+        0xA042609F: "euc-jp",
+        0xA042807F: "shift-jis",
+        0xA042A05F: "utf-8",
+    }
+
+    def __init__(self) -> None:
+        """
+        Initialize the encoding object.
+        """
+        self.encoding: Optional[str] = None
+
+    def __sanitize_encoding(self, enc: str) -> str:
+        """
+        Convert an internal encoding value from an externally acceptible value.
+
+        Parameters:
+            enc - The encoding as a string as passed from an outside caller
+
+        Returns:
+            An encoding string suitable for internal use.
+        """
+        if enc == "shift-jis-legacy":
+            return "shift-jis"
+        return enc
+
+    def decode(self, data: bytes, skip_on_exceptions: bool=False) -> Optional[Node]:
+        """
+        Given a data blob, decode the data with the current encoding. Will
+        also set the class property value 'encoding' to the encoding used
+        on the last decode.
+
+        Parameters:
+            data - Binary blob representing the data to decode
+
+        Returns:
+            Node object representing the root of the decoded tree, or None
+            if we couldn't decode the object for some reason.
+        """
+        try:
+            data_magic = struct.unpack(">L", data[0:4])[0]
+        except struct.error:
+            # Couldn't even parse magic
+            return None
+        encoding = BinaryEncoding.MAGIC.get(data_magic)
+
+        if encoding is not None:
+            self.encoding = encoding
+            try:
+                decoder = BinaryDecoder(data[4:], self.__sanitize_encoding(encoding))
+                return decoder.get_tree()
+            except BinaryEncodingException:
+                if skip_on_exceptions:
+                    return None
+                else:
+                    raise
+        else:
+            return None
+
+    def encode(self, tree: Node, encoding: str=None) -> bytes:
+        """
+        Given a tree of Node objects, encode the data with the current encoding.
+
+        Parameters:
+            tree - Node tree representing the data to encode
+            encoding - The text encoding to use. If None, will try to use the encoding from
+                       the last successful decode
+
+        Returns:
+            Binary blob representing encoded data
+        """
+        if encoding is None:
+            encoding = self.encoding
+        if encoding is None:
+            raise BinaryEncodingException('Unknown encoding')
+
+        encoding_magic = None
+        for magic in BinaryEncoding.MAGIC:
+            if BinaryEncoding.MAGIC[magic] == encoding:
+                encoding_magic = magic
+                break
+
+        if encoding_magic is None:
+            raise BinaryEncodingException("Invalid text encoding {}".format(encoding))
+
+        encoder = BinaryEncoder(tree, self.__sanitize_encoding(encoding))
+        data = encoder.get_data()
+
+        if data is not None:
+            return struct.pack(">L", encoding_magic) + data
+        else:
+            return None
diff --git a/bemani/protocol/lz77.py b/bemani/protocol/lz77.py
new file mode 100644
index 0000000..3c94208
--- /dev/null
+++ b/bemani/protocol/lz77.py
@@ -0,0 +1,389 @@
+from collections import defaultdict
+from typing import Generator, List, Mapping, Optional, Set, Tuple
+
+
+class LzException(Exception):
+    """
+    An exception thrown when we encounter an error with Lz77 encoding/decoding.
+    """
+
+
+class Lz77Decompress:
+    """
+    A class that can decompress an Lz77 stream of data. Notably, this is a different
+    variant to the Lz77 found in firebeat executables and BIOS. This is used for
+    over-the-wire compression of XML data, as well as compression inside a decent
+    amount of file formats found in various Konami games.
+    """
+    RING_LENGTH = 0x1000
+
+    FLAG_COPY = 1
+    FLAG_BACKREF = 0
+
+    def __init__(self, data: bytes, backref: Optional[int] = None) -> None:
+        """
+        Initialize the object.
+
+        Parameters:
+            data - Binary blob representing the data to be decompressed.
+        """
+        self.eof: bool = False
+        self.data: bytes = data
+        self.read_pos: int = 0
+        self.left: int = len(self.data)
+        self.flags: int = 1
+        self.write_pos: int = 0
+        self.pending_copy_amount: int = 0
+        self.pending_copy_pos: int = 0
+        self.pending_copy_max: int = 0
+        self.ringlength: int = backref or self.RING_LENGTH
+        self.ring: bytes = b'\x00' * self.ringlength
+
+    def __ring_read(self, copy_pos: int, copy_len: int) -> Generator[bytes, None, None]:
+        """
+        Read the next bytes from the backref ring at the current copy position.
+
+        Returns:
+            a generator which yields bytes.
+        """
+        while copy_len > 0:
+            if copy_pos + copy_len > self.ringlength:
+                # Copy first chunk, let subsequent loop handle the next chunks
+                amount = self.ringlength - copy_pos
+            else:
+                # Copy the whole thing out, we have enough space to do so
+                amount = copy_len
+
+            ret = self.ring[copy_pos:(copy_pos + amount)]
+            self.__ring_write(ret)
+            yield ret
+
+            copy_pos = (copy_pos + amount) % self.ringlength
+            copy_len -= amount
+
+    def __ring_write(self, bytedata: bytes) -> None:
+        """
+        Write bytes into the backref ring.
+
+        Parameters:
+            byte - A byte to be written at the current write offset
+        """
+        while True:
+            amount = len(bytedata)
+            if amount == 0:
+                return
+            if amount > (self.ringlength - self.write_pos):
+                amount = self.ringlength - self.write_pos
+
+            self.ring = self.ring[:self.write_pos] + bytedata[:amount] + self.ring[(self.write_pos + amount):]
+            bytedata = bytedata[amount:]
+            self.write_pos = (self.write_pos + amount) % self.ringlength
+
+    def decompress_bytes(self) -> Generator[bytes, None, None]:
+        """
+        Yield the next byte from the decompressed output. If we are
+        in a backref copy, read the next byte from the backref. If
+        we aren't, read the next flag to see if we should decode
+        a byte directly or if we should start another backref read.
+        If we don't have any flags, exit reporting EOF (None). If
+        we hit the end of the stream, stop yielding to signify EOF.
+        In all cases, whatever byte we read should be added back to
+        the backref buffer.
+
+        Returns:
+            a generator that yields bytes.
+        """
+        while not self.eof:
+            if self.pending_copy_amount > 0:
+                # We had a backref that would have copied more data than we had available
+                # in the ringbuffer (because every read, even a backref, adds to the
+                # ringbuffer). So, since we read that last time and wrote it to the backbuffer
+                # we are safe to read again.
+                amount = min(self.pending_copy_amount, self.pending_copy_max)
+                yield from self.__ring_read(self.pending_copy_pos, amount)
+
+                # We read this many bytes and are about to write them to the ringbuffer,
+                # so bookkeep that.
+                self.pending_copy_amount -= amount
+                self.pending_copy_max = amount
+            else:
+                if self.flags == 1:
+                    # Load the next byte for processing
+                    if self.left == 0:
+                        # We have nothing left to read, so skip the
+                        # ringbuffer write below and exit early.
+                        return
+                    else:
+                        self.flags = 0x100 | self.data[self.read_pos]
+                        self.read_pos += 1
+                        self.left -= 1
+
+                # Shift the lowest bit out to be retrieved as a flag
+                flag = self.flags & 1
+                self.flags >>= 1
+
+                if flag == self.FLAG_COPY:
+                    # Figure out how much to pull at once
+                    amount = 1
+                    while self.flags != 1 and (self.flags & 1) == self.FLAG_COPY:
+                        # We would do a copy next time, so pop that flag and just add to our read amount
+                        self.flags >>= 1
+                        amount += 1
+
+                    # Grab chunk right out of the data source
+                    b = self.data[self.read_pos:(self.read_pos + amount)]
+                    self.__ring_write(b)
+                    yield b
+
+                    self.read_pos += amount
+                    self.left -= amount
+                elif flag == self.FLAG_BACKREF:
+                    yield from self.__read_backref()
+                else:
+                    raise Exception("Logic error!")
+
+    def __read_backref(self) -> Generator[bytes, None, None]:
+        """
+        Read a backref chunk. Grab the copy length and copy position
+        from the first two bytes and then read the first byte from
+        the backref. Sets up variables such that Lz77Decompress.__read()
+        can finish copying out of the backref on subsequent calls. Should
+        only be called by Lz77Decompress.__read(). If we discover the end
+        of stream, we don't generate any bytes and instead set the eof
+        flag which terminates the main decompression loop above.
+
+        Returns:
+            a generator that yields bytes.
+        """
+        if self.left == 0:
+            self.eof = True
+            return
+        if self.left == 1:
+            raise LzException('Unexpected EOF mid-backref')
+
+        hi = self.data[self.read_pos]
+        lo = self.data[self.read_pos + 1]
+        self.read_pos += 2
+        self.left -= 2
+
+        copy_len = lo & 0xF
+        copy_pos = (hi << 4) | (lo >> 4)
+
+        if copy_pos > 0:
+            copy_len += 3
+            if copy_len > copy_pos:
+                # Remember what we have to do left, and the safe
+                # amount to copy next time (which is our length,
+                # since we are about to write that many butes to
+                # the ringbuffer right after reading them).
+                self.pending_copy_amount = copy_len - copy_pos
+                self.pending_copy_pos = self.write_pos
+                self.pending_copy_max = copy_pos
+
+                # Only copy the available bytes
+                copy_len = copy_pos
+
+            copy_pos = (self.write_pos - copy_pos)
+            while copy_pos < 0:
+                copy_pos += self.ringlength
+            copy_pos = copy_pos % self.ringlength
+            yield from self.__ring_read(copy_pos, copy_len)
+        else:
+            self.eof = True
+            return
+
+
+class Lz77Compress:
+    """
+    A class that can compress arbitrary binary data using the Lz77 protocol.
+    Note that this does support overlapped backtracks, so for instance the
+    string "abcabcabc" will be compressed properly (see unit tests for examples).
+    Great care has been taken in optimizing this and then we further optimize
+    by using Cython to build, netting us another 40% speed-up. This is important
+    because for any given packet we are decompressing and compressing at least
+    once, and if we use a proxy to direct traffic, possibly a second time.
+    """
+
+    RING_LENGTH = 0x1000
+
+    FLAG_COPY = 1
+    FLAG_BACKREF = 0
+
+    def __init__(self, data: bytes, backref: Optional[int] = None) -> None:
+        """
+        Initialize the object.
+
+        Parameters:
+            data - Binary blob representing the data to be decompressed.
+        """
+        self.data: bytes = data
+        self.read_pos: int = 0
+        self.left: int = len(self.data)
+        self.eof: bool = False
+        self.bytes_written: int = 0
+        self.ringlength: int = backref or self.RING_LENGTH
+        self.locations: Mapping[int, Set[int]] = defaultdict(set)
+        self.starts: Mapping[bytes, Set[int]] = defaultdict(set)
+        self.last_start: Tuple[int, int, int] = (0, 0, 0)
+
+    def __ring_write(self, bytedata: bytes) -> None:
+        """
+        Write bytes into the backref ring.
+
+        Parameters:
+            byte - A byte to be written at the current write offset
+        """
+        for byte in bytedata:
+            # Update the start locations hashmap if we're past the beginning
+            self.last_start = (self.last_start[1], self.last_start[2], byte)
+            if self.bytes_written >= 2:
+                self.starts[bytes(self.last_start)].add(self.bytes_written - 2)
+
+            # Update the rest of the location hashmaps
+            self.locations[byte].add(self.bytes_written)
+            self.bytes_written += 1
+
+    def compress_bytes(self) -> Generator[bytes, None, None]:
+        """
+        Given the current stream, go through and assemble the next flag byte
+        followed by the next chunk of compressed data.
+        """
+        while not self.eof:
+            if self.left == 0:
+                # Output a dummy flag and an end of stream marker.
+                self.eof = True
+                yield b"\x00\x00\x00"
+            else:
+                # Need to assemble and return the next chunk, which is a flag
+                # byte and then 8 instructions.
+                flags = 0x0
+                flagpos = -1
+                data: List[bytes] = [b"\x00"] * 8
+
+                for _ in range(8):
+                    # Track what flag we're generating data for
+                    flagpos += 1
+
+                    if self.left == 0:
+                        # Output the end of stream marker, set EOF since we've succeeded
+                        # in outputting all flags.
+                        flags |= self.FLAG_BACKREF << flagpos
+                        data[flagpos] = b"\x00\x00"
+                        self.eof = True
+                        break
+                    elif self.left < 3 or self.bytes_written < 3:
+                        # We either don't have enough data written to backref, or we
+                        # don't have enough data in the stream that could be made into
+                        # a backref.
+                        flags |= self.FLAG_COPY << flagpos
+
+                        chunk = self.data[self.read_pos:(self.read_pos + 1)]
+                        data[flagpos] = chunk
+                        self.__ring_write(chunk)
+
+                        self.read_pos += 1
+                        self.left -= 1
+                        continue
+
+                    # Figure out the maximum backref we can attempt to find
+                    backref_amount = min(self.left, 18)
+
+                    # Iterate over all spots where the first byte equals, and is in range.
+                    earliest = max(0, self.bytes_written - self.ringlength)
+                    possible_backref_locations: List[int] = [
+                        absolute_pos for absolute_pos in self.starts[self.data[self.read_pos:(self.read_pos + 3)]]
+                        if absolute_pos >= earliest
+                    ]
+
+                    # Output the data as a copy if we couldn't find a backref
+                    if not possible_backref_locations:
+                        flags |= self.FLAG_COPY << flagpos
+
+                        chunk = self.data[self.read_pos:(self.read_pos + 1)]
+                        data[flagpos] = chunk
+                        self.__ring_write(chunk)
+
+                        self.read_pos += 1
+                        self.left -= 1
+                        continue
+
+                    # Now, find the longest actual backref of our possibilities. We know
+                    # we're going to write at least these three bytes, so append it to the
+                    # output buffer.
+                    start_write_size = self.bytes_written
+                    self.__ring_write(self.data[self.read_pos:(self.read_pos + 3)])
+                    copy_amount = 3
+                    for _ in range(backref_amount - 3):
+                        # Check our existing locations to figure out if we still have
+                        # longest prefixes.
+                        locations = self.locations[self.data[self.read_pos + copy_amount]]
+                        new_backref_locations: List[int] = [
+                            absolute_pos for absolute_pos in possible_backref_locations
+                            if absolute_pos + copy_amount in locations
+                        ]
+
+                        # If we have no longest prefixes, that means that any of the
+                        # previous prefixes are good enough.
+                        if not new_backref_locations:
+                            break
+
+                        # Mark that we're copying an extra byte from the backref.
+                        self.__ring_write(self.data[(self.read_pos + copy_amount):(self.read_pos + copy_amount + 1)])
+                        copy_amount += 1
+                        possible_backref_locations = new_backref_locations
+
+                    # Now that we have a list of candidates, arbitrarily pick the
+                    # first one as our candidate and output it.
+                    absolute_pos = possible_backref_locations[0]
+                    backref_pos = start_write_size - absolute_pos
+
+                    lo = (copy_amount - 3) & 0xF | ((backref_pos & 0xF) << 4)
+                    hi = (backref_pos >> 4) & 0xFF
+                    flags |= self.FLAG_BACKREF << flagpos
+                    data[flagpos] = bytes([hi, lo])
+                    self.read_pos += copy_amount
+                    self.left -= copy_amount
+
+                yield bytes([flags]) + b"".join(data[:(flagpos + 1)])
+
+
+class Lz77:
+    """
+    A wrapper class encapsulating Lz77 encoding and decoding.
+    """
+
+    # The point at which we consider it better to trade off smaller data
+    # sent over the wire for a more computationally expensive compression.
+    REAL_COMPRESSION_THRESHOLD = 10 * 1024
+
+    def __init__(self, backref: Optional[int] = None) -> None:
+        """
+        Initialize the object.
+        """
+        self.backref = backref
+
+    def decompress(self, data: bytes) -> bytes:
+        """
+        Given a binary blob, return a new binary blob representing the decompressed data.
+
+        Parameters:
+            data - Lz77-compressed binary data
+
+        Returns:
+            Raw binary data.
+        """
+        lz = Lz77Decompress(data, backref=self.backref)
+        return b''.join(lz.decompress_bytes())
+
+    def compress(self, data: bytes) -> bytes:
+        """
+        Given a binary blob, return a new binary blob representing the compressed data.
+
+        Parameters:
+            data - Raw binary data.
+
+        Returns:
+            L7zz-compressed binary data.
+        """
+        lz = Lz77Compress(data, backref=self.backref)
+        return b''.join(lz.compress_bytes())
diff --git a/bemani/protocol/node.py b/bemani/protocol/node.py
new file mode 100644
index 0000000..7b73a7b
--- /dev/null
+++ b/bemani/protocol/node.py
@@ -0,0 +1,877 @@
+import copy
+import struct
+from typing import Any, Dict, List, Optional
+
+
+class NodeException(Exception):
+    """
+    An exception thrown when we encounter an issue with a property node.
+    """
+
+
+class Node:
+    """
+    An object representing one node in the tree structure of a packet. Nodes can have a number of
+    string attributes, and either a value or zero or more children. Note that it is possible and
+    supported for a node to not have a value or children. This also includes a decent amount of
+    constructor helper classmethods to make constructing a tree from source code easier.
+    """
+    NODE_NAME_CHARS = "0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
+
+    NODE_TYPE_VOID = 1
+    NODE_TYPE_S8 = 2
+    NODE_TYPE_U8 = 3
+    NODE_TYPE_S16 = 4
+    NODE_TYPE_U16 = 5
+    NODE_TYPE_S32 = 6
+    NODE_TYPE_U32 = 7
+    NODE_TYPE_S64 = 8
+    NODE_TYPE_U64 = 9
+    NODE_TYPE_BIN = 10
+    NODE_TYPE_STR = 11
+    NODE_TYPE_IP4 = 12
+    NODE_TYPE_TIME = 13
+    NODE_TYPE_FLOAT = 14
+    NODE_TYPE_2U16 = 19
+    NODE_TYPE_3S32 = 30
+    NODE_TYPE_4U8 = 37
+    NODE_TYPE_4U16 = 39
+    NODE_TYPE_BOOL = 52
+
+    NODE_TYPES = {
+        NODE_TYPE_VOID: {
+            'name': 'void',
+            'enc': '',
+            'len': 0,
+            'int': False,
+            'composite': False,
+        },
+        NODE_TYPE_S8: {
+            'name': 's8',
+            'enc': 'b',
+            'len': 1,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_U8: {
+            'name': 'u8',
+            'enc': 'B',
+            'len': 1,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_S16: {
+            'name': 's16',
+            'enc': 'h',
+            'len': 2,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_U16: {
+            'name': 'u16',
+            'enc': 'H',
+            'len': 2,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_S32: {
+            'name': 's32',
+            'enc': 'i',
+            'len': 4,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_U32: {
+            'name': 'u32',
+            'enc': 'I',
+            'len': 4,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_S64: {
+            'name': 's64',
+            'enc': 'q',
+            'len': 8,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_U64: {
+            'name': 'u64',
+            'enc': 'Q',
+            'len': 8,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_BIN: {
+            'name': 'bin',
+            'enc': 's',
+            'len': None,
+            'int': False,
+            'composite': False,
+        },
+        NODE_TYPE_STR: {
+            'name': 'str',
+            'enc': 's',
+            'len': None,
+            'int': False,
+            'composite': False,
+        },
+        NODE_TYPE_IP4: {
+            'name': 'ip4',
+            'enc': '4s',
+            'len': 4,
+            'int': False,
+            'composite': False,
+        },
+        NODE_TYPE_TIME: {
+            'name': 'time',
+            'enc': 'I',
+            'len': 4,
+            'int': True,
+            'composite': False,
+        },
+        NODE_TYPE_FLOAT: {
+            'name': 'float',
+            'enc': 'f',
+            'len': 4,
+            'int': False,
+            'composite': False,
+        },
+        NODE_TYPE_2U16: {
+            'name': '2u16',
+            'enc': 'HH',
+            'len': 4,
+            'int': True,
+            'composite': True,
+        },
+        NODE_TYPE_3S32: {
+            'name': '3s32',
+            'enc': 'iii',
+            'len': 12,
+            'int': True,
+            'composite': True,
+        },
+        NODE_TYPE_4U8: {
+            'name': '4u8',
+            'enc': 'BBBB',
+            'len': 4,
+            'int': True,
+            'composite': True,
+        },
+        NODE_TYPE_4U16: {
+            'name': '4u16',
+            'enc': 'HHHH',
+            'len': 8,
+            'int': True,
+            'composite': True,
+        },
+        NODE_TYPE_BOOL: {
+            'name': 'bool',
+            'enc': 'b',
+            'len': 1,
+            'int': False,
+            'composite': False,
+        },
+    }
+    ARRAY_BIT = 0x40
+    ATTR_TYPE = 0x2E
+    END_OF_NODE = 0xFE
+    END_OF_DOCUMENT = 0xFF
+
+    @staticmethod
+    def typename_to_type(typename: str) -> Optional[int]:
+        """
+        Given a string typename as would be output in an XML conversion or found
+        in the above NODE_TYPES table, return an integer node type that would be
+        valid for a binary node.
+
+        Parameters:
+            typename - String corresponding to a node type.
+
+        Returns:
+            An integer specifying the node type or None if not found.
+        """
+        for nodetype in Node.NODE_TYPES:
+            if typename.lower() == Node.NODE_TYPES[nodetype]['name']:
+                return nodetype
+
+        return None
+
+    @staticmethod
+    def void(name: str) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_VOID)
+
+    @staticmethod
+    def string(name: str, value: str) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_STR, value=value)
+
+    @staticmethod
+    def binary(name: str, value: bytes) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_BIN, value=value)
+
+    @staticmethod
+    def __float(name: str, value: float) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_FLOAT, value=value)
+
+    @staticmethod
+    def __bool(name: str, value: bool) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_BOOL, value=value)
+
+    @staticmethod
+    def ipv4(name: str, value: str) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_IP4, value=value)
+
+    @staticmethod
+    def time(name: str, value: int) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_TIME, value=value)
+
+    @staticmethod
+    def fouru8(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_U8, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_4U8, value=values)
+
+    @staticmethod
+    def __validate(nodetype: int, name: str, value: int) -> None:
+        if nodetype == Node.NODE_TYPE_U8:
+            if value < 0 or value > 255:
+                raise NodeException('Invalid value {} for u8 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_S8:
+            if value < -128 or value > 127:
+                raise NodeException('Invalid value {} for s8 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_U16:
+            if value < 0 or value > 65535:
+                raise NodeException('Invalid value {} for u16 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_S16:
+            if value < -32768 or value > 32767:
+                raise NodeException('Invalid value {} for s16 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_U32:
+            if value < 0 or value > 4294967295:
+                raise NodeException('Invalid value {} for u32 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_S32:
+            if value < -2147483648 or value > 2147483647:
+                raise NodeException('Invalid value {} for s32 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_U64:
+            if value < 0 or value > 18446744073709551615:
+                raise NodeException('Invalid value {} for u64 {}'.format(value, name))
+        elif nodetype == Node.NODE_TYPE_S64:
+            if value < -9223372036854775808 or value > 9223372036854775807:
+                raise NodeException('Invalid value {} for s32 {}'.format(value, name))
+
+    @staticmethod
+    def u8(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_U8, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U8, value=value)
+
+    @staticmethod
+    def s8(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_S8, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S8, value=value)
+
+    @staticmethod
+    def u16(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_U16, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U16, value=value)
+
+    @staticmethod
+    def s16(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_S16, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S16, value=value)
+
+    @staticmethod
+    def u32(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_U32, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U32, value=value)
+
+    @staticmethod
+    def s32(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_S32, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S32, value=value)
+
+    @staticmethod
+    def u64(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_U64, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U64, value=value)
+
+    @staticmethod
+    def s64(name: str, value: int) -> 'Node':
+        Node.__validate(Node.NODE_TYPE_S64, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S64, value=value)
+
+    @staticmethod
+    def time_array(name: str, values: List[int]) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_TIME, array=True, value=values)
+
+    @staticmethod
+    def float_array(name: str, values: List[float]) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_FLOAT, array=True, value=values)
+
+    @staticmethod
+    def bool_array(name: str, values: List[bool]) -> 'Node':
+        return Node(name=name, type=Node.NODE_TYPE_BOOL, array=True, value=values)
+
+    @staticmethod
+    def u8_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_U8, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U8, array=True, value=values)
+
+    @staticmethod
+    def s8_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_S8, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S8, array=True, value=values)
+
+    @staticmethod
+    def u16_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_U16, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U16, array=True, value=values)
+
+    @staticmethod
+    def s16_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_S16, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S16, array=True, value=values)
+
+    @staticmethod
+    def u32_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_U32, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U32, array=True, value=values)
+
+    @staticmethod
+    def s32_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_S32, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S32, array=True, value=values)
+
+    @staticmethod
+    def u64_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_U64, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_U64, array=True, value=values)
+
+    @staticmethod
+    def s64_array(name: str, values: List[int]) -> 'Node':
+        for value in values:
+            Node.__validate(Node.NODE_TYPE_S64, name, value)
+        return Node(name=name, type=Node.NODE_TYPE_S64, array=True, value=values)
+
+    def __init__(self, name: Optional[str]=None, type: Optional[int]=None, array: Optional[bool]=None, value: Optional[Any]=None) -> None:
+        """
+        Initialize a node, with an optional name and type.
+
+        Parameters:
+            name - A string specifying the name of the node
+            type - An integer specifying the type of the node. Should be
+                   a valid type as found in Node.NODE_TYPES with
+                   an optional Node.ARRAY_BIT set.
+            array - A boolean specifying whether or not this node is an array.
+                    If not provided, will extract the array bit flag from the
+                    type.
+            value - A mixed value corresponding to the type that this node should
+                    be initialized with.
+        """
+        self.__name: Optional[str] = None
+        self.__array = False
+        self.__translated_type: Optional[Dict[str, Any]] = None
+        self.__type: Optional[int] = None
+        self.__attrs: Dict[str, str] = {}
+        self.__value: Any = None
+        self.__children: List[Node] = []
+
+        if name is not None:
+            self.set_name(name)
+        if type is not None:
+            self.set_type(type, array=array)
+        if value is not None:
+            self.set_value(value)
+
+    def set_name(self, name: str) -> None:
+        """
+        Set the name of the node to a new string.
+
+        Parameters:
+            name - A string specifying the node name. Should be made up of only
+                NODE_NAME_CHARS characters.
+        """
+        # Ensure it isn't a violation
+        for char in name:
+            if char not in Node.NODE_NAME_CHARS:
+                raise NodeException('Invalid node name {}'.format(name))
+
+        self.__name = name
+
+    @property
+    def name(self) -> str:
+        """
+        Get the name of the node as a string.
+
+        Returns:
+            A string node name.
+        """
+        if self.__name is None:
+            raise Exception('Logic error, tried to fetch name before setting!')
+        return self.__name
+
+    def set_type(self, type: int, array: Optional[bool]=None) -> None:
+        """
+        Set the type of the node to a new integer type, as specified in Node.NODE_TYPES.
+
+        Parameters:
+            type - An integer type to set the node type as.
+            array - A boolean specifying whether this node is an array or not. If not provided
+                    this function will extract the array bit from the provided type integer.
+        """
+        if array is not None:
+            if array:
+                type = type | Node.ARRAY_BIT
+            else:
+                type = type & (~Node.ARRAY_BIT)
+
+        if (type & Node.ARRAY_BIT) != 0:
+            self.__array = True
+
+        try:
+            self.__translated_type = Node.NODE_TYPES[type & (~Node.ARRAY_BIT)]
+            self.__type = type
+        except KeyError:
+            raise NodeException('Unknown node type {}'.format(type))
+
+    @property
+    def type(self) -> int:
+        """
+        Returns the underlying data type for this node.
+
+        Returns:
+            An integer node type. Should correspond with node types, but note that the array
+            bit ARRAY_BIT might be set.
+        """
+        if self.__type is None:
+            raise Exception('Logic error, tried to fetch type before setting!')
+        return self.__type
+
+    @property
+    def data_type(self) -> str:
+        """
+        Returns the data type name based on the node's type.
+
+        Returns:
+            A string data type name. This string can be fed to typename_to_type to get the original type back.
+        """
+        if self.__type is None:
+            raise Exception('Logic error, tried to fetch data type before setting type!')
+        return self.__translated_type['name']
+
+    @property
+    def data_length(self) -> int:
+        """
+        Returns the number of bytes used by the encoding, based on the node's type. If this is a binary blob
+        or a string, returns None. For array types, this represents the size of one element in bytes.
+
+        Returns:
+            An integer data length, or None if this node's element has variable length.
+        """
+        if self.__type is None:
+            raise Exception('Logic error, tried to fetch data length before setting type!')
+        return self.__translated_type['len']
+
+    @property
+    def data_encoding(self) -> str:
+        """
+        Returns the python struct encoding character used to encode/decode this type.
+
+        Returns:
+            A character that can be passed to struct.encode or struct.decode.
+        """
+        if self.__type is None:
+            raise Exception('Logic error, tried to fetch data encoding before setting type!')
+        return self.__translated_type['enc']
+
+    def add_attribute(self, attr: str) -> None:
+        """
+        Add a new attribute to this node.
+
+        Parameters:
+            attr - A string attribute to set on the node. Will set to a blank string.
+        """
+        self.__attrs[attr] = ''
+
+    def set_attribute(self, attr: str, val: str) -> None:
+        """
+        Set an attribute to a particular string value on this node.
+
+        Parameters:
+            attr - A string attribute to set on the node.
+            val - The string value to set the attribute value to.
+        """
+        self.__attrs[attr] = val
+
+    def attribute(self, attr: str, default: Optional[str]=None) -> Optional[str]:
+        """
+        Get an attribute based on a string, or None if nonexistent.
+
+        Parameters:
+            attr - A string attribute to look up.
+
+        Returns:
+            The attribute value as a string.
+        """
+        return self.__attrs.get(attr, default)
+
+    def add_child(self, child: 'Node') -> None:
+        """
+        Add a child Node to this node.
+
+        Parameters:
+            child - A Node to set as a child to this node.
+        """
+        if not isinstance(child, Node):
+            raise NodeException('Invalid child')
+
+        self.__children.append(child)
+
+    def child(self, name: str) -> Optional['Node']:
+        """
+        Find a child by name.
+
+        Parameters:
+            name - String name of the child to find. If one or more
+                   slashes is included, traverses each name, looking
+                   up that child.
+
+        Returns:
+            A Node if a child was found by name, or None if not.
+        """
+        tree = name.split('/', 1)
+        for child in self.__children:
+            if child.name == tree[0]:
+                if len(tree) == 1:
+                    # We don't have any more nodes to traverse.
+                    return child
+                else:
+                    # We have more nodes, try to get the next.
+                    return child.child(tree[1])
+
+        # There was no child by this name, return None.
+        return None
+
+    def child_value(self, name: str) -> Optional[Any]:
+        """
+        Find a child by name, and look up its value.
+
+        Parameters:
+            name - String name of child to find. Supports slashes similarly
+                   to the above child() method.
+
+        Returns:
+            A value of the child node if the child was found, or None if not.
+            Also returns None if the child is a void node.
+        """
+        child = self.child(name)
+        if child is None:
+            return None
+        return child.value
+
+    @property
+    def children(self) -> List['Node']:
+        """
+        Wrapper for accessing children.
+
+        Returns:
+            A list of Node instances which are children of this Node.
+        """
+        return self.__children
+
+    @property
+    def attributes(self) -> Dict[str, str]:
+        """
+        Wrapper for accessing attributes.
+
+        Returns:
+            A dictionary keyed by attribute name whose values are strings.
+        """
+        return self.__attrs
+
+    @property
+    def is_array(self) -> bool:
+        """
+        Wrapper for accessing array type.
+
+        Returns:
+            True if this Node is an array, False otherwise.
+        """
+        return self.__array
+
+    @property
+    def is_composite(self) -> bool:
+        """
+        Returns whether or not this element is a composite type (basically
+        an array, but packed differently).
+
+        Returns:
+            True if this Node is a composite type, False otherwise.
+        """
+        return self.__translated_type['composite']
+
+    def set_value(self, val: Any) -> None:
+        """
+        Sets the value of this node. If this node is an array type (see Node.array boolean), expects an array. If
+        not, expects a scalar value.
+
+        Paramters:
+            val - A mixed value to set the node to.
+        """
+        is_array = isinstance(val, list)
+        # Handle composite types
+        if self.__translated_type['composite']:
+            if not is_array:
+                raise NodeException('Input is not array, expected array')
+            if len(val) != len(self.__translated_type['enc']):
+                raise NodeException('Input array for {} expected to be {} elements!'.format(
+                    self.__translated_type['name'],
+                    len(self.__translated_type['enc']),
+                ))
+            is_array = False
+        if is_array != self.__array:
+            raise NodeException('Input {} array, expected {}'.format('is' if is_array else 'is not', 'array' if self.__array else 'scalar'))
+
+        def val_to_str(val: Any) -> str:
+            if self.__translated_type['name'] == 'bool':
+                # Support user-built boolean types
+                if val is True:
+                    return 'true'
+                if val is False:
+                    return 'false'
+
+                # Support construction from binary
+                return 'true' if val != 0 else 'false'
+            elif self.__translated_type['name'] == 'float':
+                return str(val)
+            elif self.__translated_type['name'] == 'ip4':
+                try:
+                    # Support construction from binary
+                    ip = struct.unpack('BBBB', val)
+                    return '{}.{}.{}.{}'.format(ip[0], ip[1], ip[2], ip[3])
+                except (struct.error, TypeError):
+                    # Assume that its user-built string?
+                    if isinstance(val, str):
+                        if len(val.split('.')) == 4:
+                            return val
+
+                    raise NodeException('Invalid value {} for IP4 type'.format(val))
+            elif self.__translated_type['int']:
+                return str(val)
+            else:
+                return val
+
+        if is_array or self.__translated_type['composite']:
+            self.__value = [val_to_str(v) for v in val]
+        else:
+            self.__value = val_to_str(val)
+
+    @property
+    def value(self) -> Any:
+        """
+        Gets the value of this node. If this node is an array type, returns an array. If no, returns a scalar.
+
+        Returns:
+            A mixed value corresponding to this node's value. The returned value will be of the correct data type.
+        """
+        def str_to_val(string: str) -> Any:
+            if self.__translated_type['name'] == 'bool':
+                return True if string == 'true' else False
+            elif self.__translated_type['name'] == 'float':
+                return float(string)
+            elif self.__translated_type['name'] == 'ip4':
+                ip = [int(tup) for tup in string.split('.')]
+                return struct.pack('BBBB', ip[0], ip[1], ip[2], ip[3])
+            elif self.__translated_type['int']:
+                return int(string)
+            else:
+                return string
+
+        if self.__array or self.__translated_type['composite']:
+            return [str_to_val(v) for v in self.__value]
+        else:
+            return str_to_val(self.__value)
+
+    def __to_xml(self, depth: int) -> str:
+        """
+        Convert this node, attributes and all children to an XML-like representation of the tree.
+
+        Parameters:
+            depth - Number of levels deep into the tree we currently are. If we shouldn't output
+                    any depth, this should be set to None.
+
+        Returns:
+            A string representing the XML-like data for this node and all children.
+        """
+        attrs_dict = copy.deepcopy(self.__attrs)
+        order = sorted(attrs_dict.keys())
+        if self.__translated_type['len'] != 0:
+            # Represent type and length
+            if self.__array:
+                if self.__value is None:
+                    attrs_dict['__count'] = '0'
+                else:
+                    attrs_dict['__count'] = str(len(self.__value))
+                order.insert(0, '__count')
+            attrs_dict['__type'] = self.__translated_type['name']
+            order.insert(0, '__type')
+
+        def escape(val: Any, attr: bool=False) -> str:
+            if isinstance(val, str):
+                val = val.replace('&', '&amp;')
+                val = val.replace('<', '&lt;')
+                val = val.replace('>', '&gt;')
+                val = val.replace('\'', '&apos;')
+                val = val.replace('\"', '&quot;')
+                if attr:
+                    val = val.replace('\r', '&#13;')
+                    val = val.replace('\n', '&#10;')
+
+                return val
+            else:
+                return str(val)
+
+        if attrs_dict:
+            attrs = ' ' + ' '.join(['{name}="{val}"'.format(name=attr, val=escape(attrs_dict[attr], attr=True)) for attr in order])
+        else:
+            attrs = ''
+
+        def get_val() -> str:
+            if self.__array or self.__translated_type['composite']:
+                if self.__value is None:
+                    vals = ''
+                else:
+                    vals = ' '.join([val for val in self.__value])
+            elif self.__translated_type['name'] == 'str':
+                vals = escape(self.__value)
+            elif self.__translated_type['name'] == 'bin':
+                # Convert to a hex string
+                def bin_to_hex(binary: int) -> str:
+                    val = hex(binary)[2:]
+                    while len(val) < 2:
+                        val = '0' + val
+                    return val
+
+                vals = ''.join([bin_to_hex(v) for v in self.__value])
+            else:
+                vals = str(self.__value)
+            return vals
+
+        if self.__children:
+            # Has children nodes
+            children = [child.__to_xml(depth=depth + 1) for child in self.__children]
+
+            if self.__translated_type['len'] != 0:
+                # Has children and a value
+                children = [
+                    '{depth}{vals}\n'.format(
+                        depth=' ' * ((depth + 1) * 4),
+                        vals=get_val(),
+                    ),
+                ] + children
+
+            string = '{depth}<{name}{attrs}>\n{children}{depth}</{name}>\n'.format(
+                depth=' ' * (depth * 4),
+                name=self.__name,
+                attrs=attrs,
+                children=''.join(children),
+            )
+        else:
+            # Doesn't have children nodes
+            if self.__translated_type['len'] == 0:
+                # Void node
+                string = '{depth}<{name}{attrs} />\n'.format(
+                    depth=' ' * (depth * 4),
+                    name=self.__name,
+                    attrs=attrs,
+                )
+            else:
+                # Node with values
+                string = '{depth}<{name}{attrs}>{vals}</{name}>\n'.format(
+                    depth=' ' * (depth * 4),
+                    name=self.__name,
+                    attrs=attrs,
+                    vals=get_val(),
+                )
+
+        return string
+
+    def __str__(self) -> str:
+        """
+        Convenience function to auto-convert this node and children to XML if printed.
+
+        Returns:
+            A string that is parseable as valid XML, pretty printed.
+        """
+        return self.__to_xml(0)
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Convenience function for comparing two nodes.
+
+        Parameters:
+            other - Another property node to compare this to.
+
+        Returns:
+            True if the name, value, all attributes and children match this node, False otherwise.
+        """
+        if not isinstance(other, Node):
+            return False
+
+        try:
+            if self.__name != other.__name:
+                return False
+            if self.__array != other.__array:
+                return False
+            if self.__type != other.__type:
+                return False
+
+            if not self.__array:
+                if self.__value != other.__value:
+                    return False
+            else:
+                if len(self.__value) != len(other.__value):
+                    return False
+
+                for i in range(len(self.__value)):
+                    if self.__value[i] != other.__value[i]:
+                        return False
+
+            for attr in self.__attrs:
+                if other.attribute(attr) != self.attribute(attr):
+                    return False
+            for attr in other.__attrs:
+                if self.attribute(attr) != other.attribute(attr):
+                    return False
+
+            if len(self.__children) != len(other.__children):
+                return False
+
+            for i in range(len(self.__children)):
+                if self.__children[i] != other.__children[i]:
+                    return False
+
+            return True
+        except Exception as e:
+            return False
+
+    def __ne__(self, other: object) -> bool:
+        """
+        Convenience function for comparing two nodes.
+
+        Parameters:
+            other - Another Node to compare to.
+
+        Returns:
+            True if this node doesn't equal the other node, False if it does equal.
+        """
+        return not self.__eq__(other)
+
+    # Nasty hack to get around mypy's lack of scoping
+    float = __float
+    bool = __bool
diff --git a/bemani/protocol/protocol.py b/bemani/protocol/protocol.py
new file mode 100644
index 0000000..8789a75
--- /dev/null
+++ b/bemani/protocol/protocol.py
@@ -0,0 +1,300 @@
+import binascii
+import hashlib
+from typing import Optional
+
+from bemani.protocol.lz77 import Lz77
+from bemani.protocol.binary import BinaryEncoding
+from bemani.protocol.xml import XmlEncoding
+from bemani.protocol.node import Node
+
+
+class EAmuseException(Exception):
+    """
+    An exception thrown when we encounter an error with E-Amusement encapsulation.
+    """
+
+
+class EAmuseProtocol:
+    """
+    A wrapper object that encapsulates encoding/decoding the E-Amusement protocol by Konami.
+    """
+    SHARED_SECRET = b'\x69\xD7\x46\x27\xD9\x85\xEE\x21\x87\x16\x15\x70\xD0\x8D\x93\xB1\x24\x55\x03\x5B\x6D\xF0\xD8\x20\x5D\xF5'
+
+    XML = 1
+    BINARY = 2
+
+    SHIFT_JIS_LEGACY = "shift-jis-legacy"
+    SHIFT_JIS = "shift-jis"
+    EUC_JP = "euc-jp"
+    UTF_8 = "utf-8"
+
+    def __init__(self) -> None:
+        """
+        Initialize the object.
+        """
+        self.last_text_encoding: Optional[str] = None
+        self.last_packet_encoding: Optional[int] = None
+
+    def __rc4_crypt(self, data: bytes, key: bytes) -> bytes:
+        """
+        Given a data blob and a key blob, perform RC4 encryption/decryption.
+
+        Parameters:
+            data - Binary string representing data to be encrypted/decrypted
+            key - Binary string representing the key to use
+
+        Returns:
+            binary string representing the encrypted/decrypted data
+        """
+        S = list(range(256))
+        j = 0
+        out = []
+
+        # KSA Phase
+        for i in range(256):
+            j = (j + S[i] + key[i % len(key)]) & 0xFF
+            S[i], S[j] = S[j], S[i]
+
+        # PRGA Phase
+        i = j = 0
+        for char in data:
+            i = (i + 1) & 0xFF
+            j = (j + S[i]) & 0XFF
+            S[i], S[j] = S[j], S[i]
+            out.append(char ^ S[(S[i] + S[j]) & 0xFF])
+
+        return bytes(out)
+
+    def __decrypt(self, encryption_key: str, data: bytes) -> bytes:
+        """
+        Given data and an optional encryption key, decrypt the data.
+
+        Parameters:
+            encryption_key - A string encryption key as returned from a HTTP request.
+                             Should be in the form 1-xxyyzzww-aabb. If it is None, this
+                             performs a null decrypt.
+            data - Binary string representing data to transform.
+
+        Returns:
+            binary string representing transformed data
+        """
+        if data is None:
+            return None
+
+        if encryption_key:
+            # Key is concatenated with the shared secret above
+            version, first, second = encryption_key.split('-')
+            key = binascii.unhexlify((first + second).encode('ascii')) + EAmuseProtocol.SHARED_SECRET
+
+            # Next, key is sent through MD5 to derive the real key
+            m = hashlib.md5()
+            m.update(key)
+            key = m.digest()
+        else:
+            key = None
+
+        if key:
+            # This is an encrypted old-style packet
+            return self.__rc4_crypt(data, key)
+
+        # No encryption
+        return data
+
+    def __encrypt(self, encryption_key: str, data: bytes) -> bytes:
+        """
+        Given data and an optional encryption key, encrypt the data.
+
+        Parameters:
+            encryption_key - A string encryption key as returned from a HTTP request.
+                             Should be in the form 1-xxyyzzww-aabb. If it is None, this
+                             performs a null decrypt.
+            data - Binary string representing data to transform.
+
+        Returns:
+            binary string representing transformed data
+        """
+        # RC4 is symmetric
+        return self.__decrypt(encryption_key, data)
+
+    def __decompress(self, compression: str, data: bytes) -> bytes:
+        """
+        Given data and an optional compression scheme, decompress the data.
+
+        Parameters:
+            compression - A string specifying the compression used. Should
+                          be of the form 'l7zz' or 'none'. You can also pass in
+                          the python value None.
+            data - Binary string representing data to transform.
+
+        Returns:
+            binary string representing transformed data
+        """
+        if data is None:
+            return None
+
+        if compression:
+            if compression is None or compression == 'none':
+                # This isn't compressed
+                return data
+            elif compression == 'lz77':
+                # This is a compressed new-style packet
+                lz = Lz77()
+                return lz.decompress(data)
+            else:
+                raise EAmuseException('Unknown compression {}'.format(compression))
+
+        # No compression
+        return data
+
+    def __compress(self, compression: str, data: bytes) -> bytes:
+        """
+        Given data and an optional compression scheme, compress the data.
+
+        Parameters:
+            compression - A string specifying the compression used. Should
+                          be of the form 'l7zz' or 'none'. The python value
+                          None will also be recognized as 'none'.
+            data - Binary string representing data to transform.
+
+        Returns:
+            binary string representing transformed data
+        """
+        if data is None:
+            return None
+
+        if compression:
+            if compression is None or compression == 'none':
+                # This isn't compressed
+                return data
+            elif compression == 'lz77':
+                # This is a compressed new-style packet
+                lz = Lz77()
+                return lz.compress(data)
+            else:
+                raise EAmuseException('Unknown compression {}'.format(compression))
+
+        # No compression
+        return data
+
+    def __decode(self, data: bytes) -> Node:
+        """
+        Given data, decode the data into a Node tree.
+
+        Parameters:
+            data - Binary string representing data to decode.
+
+        Returns:
+            Node tree on success or None on failure.
+        """
+        # Assume it's a binary page
+        binary = BinaryEncoding()
+        ret = binary.decode(data, skip_on_exceptions=True)
+
+        if ret is not None:
+            # We got a result, it was binary
+            self.last_text_encoding = binary.encoding
+            self.last_packet_encoding = EAmuseProtocol.BINARY
+
+            return ret
+
+        # Assume its XML
+        xml = XmlEncoding()
+        ret = xml.decode(data, skip_on_exceptions=True)
+
+        if ret is not None:
+            # We got a result, it was XML
+            self.last_text_encoding = xml.encoding
+            self.last_packet_encoding = EAmuseProtocol.XML
+
+            return ret
+
+        # Couldn't decode
+        raise EAmuseException('Unknown packet encoding')
+
+    def __encode(self, tree: Node, text_encoding: str, packet_encoding: int) -> bytes:
+        """
+        Given a Node tree, encode the data into the given packet encoding.
+
+        Parameters:
+            tree - A Node object representing the root of the tree to encode.
+            text_encoding - The text encoding for any strings that will be encoded.
+                            Should be EAmuseProtocol.SHIFT_JIS, EAmuseProtocol.EUC_JP or
+                            EAmuseProtocol.UTF8.
+            packet_encoding - The encoding used for the packet. Should be EAmuseProtocol.XML
+                              or EAmuseProtocol.BINARY.
+
+        Returns:
+            A string blob representing the encoded packet.
+        """
+        if packet_encoding == EAmuseProtocol.BINARY:
+            # It's binary, encode it
+            binary = BinaryEncoding()
+            return binary.encode(tree, encoding=text_encoding)
+        elif packet_encoding == EAmuseProtocol.XML:
+            # It's XML, encode it
+            xml = XmlEncoding()
+            return xml.encode(tree, encoding=text_encoding)
+        else:
+            raise EAmuseException("Invalid packet encoding {}".format(packet_encoding))
+
+    def decode(self, compression: Optional[str], encryption: Optional[str], data: bytes) -> Node:
+        """
+        Given a request with optional compression and encryption set, decrypt,
+        decompress and decode the data, returning a parsed tree.
+
+        Parameters:
+            compression - A string specifying the compression type, should be 'lz77' or 'none'.
+                          The python value None can also be passed in.
+            encryption - A string specifying the encryption key, or None if no encryption.
+            data - A binary string of data to parse.
+
+        Returns:
+            A Node tree structure representing the parsed request, or None on failure.
+        """
+        data = self.__decrypt(encryption, data)
+        data = self.__decompress(compression, data)
+        return self.__decode(data)
+
+    def encode(
+        self,
+        compression: Optional[str],
+        encryption: Optional[str],
+        tree: Node,
+        text_encoding: Optional[str]=None,
+        packet_encoding: Optional[int]=None,
+    ) -> bytes:
+        """
+        Given a response with optional compression and encryption set, encode, compress
+        and encrypt the data, returning a binary blob suitable for forwarding on a network.
+
+        Parameters:
+            compression - A string specifying the compression type, should be 'lz77' or 'none'.
+                          The python value None can also be passed in.
+            encryption - A string specifying the encryption key, or None if no encryption.
+            data - A binary string of data to parse.
+            text_encoding - A text encoding to use. If not provided, uses the text encoding of the
+                            last decoded packet. See __encode for values.
+            packet_encpding - A packet encoding to use. If not provided, uses the packet encoding
+                              of the last decoded packet. See __encode for values.
+
+        Returns:
+            A blob of data representing the encoded packet.
+        """
+        # Either auto-set response based on request, or explicitly override in parameters
+        if text_encoding is None:
+            text_encoding = self.last_text_encoding
+        if text_encoding is None:
+            raise EAmuseException("Unknown text encoding")
+
+        if packet_encoding is None:
+            packet_encoding = self.last_packet_encoding
+        if packet_encoding is None:
+            raise EAmuseException("Unknown packet encoding")
+
+        # Clear last packet since we sent a response
+        self.last_text_encoding = None
+        self.last_packet_encoding = None
+
+        data = self.__encode(tree, text_encoding, packet_encoding)
+        data = self.__compress(compression, data)
+        return self.__encrypt(encryption, data)
diff --git a/bemani/protocol/stream.py b/bemani/protocol/stream.py
new file mode 100644
index 0000000..83c8a4a
--- /dev/null
+++ b/bemani/protocol/stream.py
@@ -0,0 +1,188 @@
+import struct
+from typing import List, Optional
+
+
+class StreamError(Exception):
+    """
+    An exception thrown when something goes wrong with the stream.
+    """
+
+
+class InputStream:
+    """
+    A class that treats a binary blob as a stream of bytes to be emitted.
+    Makes stream-like algorithms much easier to implement. All accessor
+    functions that read data will advance the current position. It is not
+    rewindable.
+    """
+
+    def __init__(self, data: bytes) -> None:
+        """
+        Initialize the object. Given a data blob, will set this as the stream
+        and set the location to the beginning of the data blob.
+
+        Parameters:
+            data - A binary blob to read from.
+        """
+        self.data = data
+        self.pos = 0
+        self.left = len(self.data)
+
+    def read_blob(self, blob_size: int) -> Optional[bytes]:
+        """
+        Given a blob size, read the next blob_size bytes as a binary blob.
+
+        Parameters:
+            blob_size - An integer representing the number of bytes to read.
+
+        Returns:
+            a binary string representing blob_size bytes from the current location, or None
+            if there wasn't enough bytes to satisfy this request.
+        """
+        if blob_size <= 0:
+            return None
+        if blob_size <= self.left:
+            bytedata = self.data[self.pos:(self.pos + blob_size)]
+            self.pos += blob_size
+            self.left -= blob_size
+            return bytedata
+        return None
+
+    def read_byte(self) -> bytes:
+        """
+        Grab the next byte at the current position. If no byte is available,
+        return None.
+
+        Returns:
+            a raw byte
+        """
+        return self.read_blob(1)
+
+    def read_int(self, size: int=1, is_unsigned: bool=True) -> int:
+        """
+        Grab the next integer of size 'size' at the current position. If not enough
+        bytes are available to decode this integer, return None.
+
+        Parameters:
+            size - Integer representing the integer size to decode. Valid values are
+                   1, 2 and 4 for char, short and int respectively.
+            is_unsigned - An optional boolean specifying whether the integer read should be
+                          unsigned. Defaults to True.
+
+        Returns:
+            a python integer representing the big-endian decoding of the current
+            position
+        """
+        if size == 1:
+            data = self.read_blob(1)
+            if data is None:
+                return None
+
+            if is_unsigned:
+                # Fastpath, just use python's own decoder
+                return data[0]
+            else:
+                return struct.unpack('>b', data)[0]
+        elif size == 2:
+            data = self.read_blob(2)
+            if data is None:
+                return None
+
+            if is_unsigned:
+                return struct.unpack('>H', data)[0]
+            else:
+                return struct.unpack('>h', data)[0]
+        elif size == 4:
+            data = self.read_blob(4)
+            if data is None:
+                return None
+
+            if is_unsigned:
+                return struct.unpack('>I', data)[0]
+            else:
+                return struct.unpack('>i', data)[0]
+        else:
+            raise StreamError('Unsupported size {}'.format(size))
+
+
+class OutputStream:
+    """
+    A class that treats a binary blob as a stream of bytes to be constructed.
+    Makes stream-like algorithms much easier to implement. All accessor
+    functions that write data will advance the current position. It is not
+    rewindable. When finished writing, access the finished blob by copying from
+    data.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initialize the object.
+        """
+        self.__data: List[bytes] = []
+        self.__data_len = 0
+        self.__formatted_data: Optional[bytes] = None
+
+    @property
+    def data(self) -> bytes:
+        if self.__formatted_data is None:
+            self.__formatted_data = b''.join(self.__data)
+        return self.__formatted_data
+
+    def write_byte(self, byte: bytes) -> None:
+        """
+        Write a raw byte to the end of the output stream.
+
+        Parameters:
+            A byte that should be appended to the current stream.
+        """
+        self.__data.append(byte)
+        self.__data_len = self.__data_len + 1
+        self.__formatted_data = None
+
+    def write_int(self, integer: int, size: int=1, is_unsigned: bool=True) -> None:
+        """
+        Write an integer to the end of the output stream.
+
+        Parameters:
+            integer - The integer that should be written to the stream.
+            size - The byte size of the integer. Supports 1, 2 and 4 byte
+                   integer types.
+            is_unsigned - Whether the integer should be written unsigned or
+                         signed. Defaults to True.
+        """
+        if size == 1:
+            if is_unsigned:
+                self.__data.append(struct.pack('>B', integer))
+            else:
+                self.__data.append(struct.pack('>b', integer))
+            self.__data_len = self.__data_len + 1
+        elif size == 2:
+            if is_unsigned:
+                self.__data.append(struct.pack('>H', integer))
+            else:
+                self.__data.append(struct.pack('>h', integer))
+            self.__data_len = self.__data_len + 2
+        elif size == 4:
+            if is_unsigned:
+                self.__data.append(struct.pack('>I', integer))
+            else:
+                self.__data.append(struct.pack('>i', integer))
+            self.__data_len = self.__data_len + 4
+        else:
+            raise StreamError('Unsupported size {}'.format(size))
+        self.__formatted_data = None
+
+    def write_pad(self, pad_to: int) -> None:
+        """
+        Pad the current stream to a byte boundary specified by pad_to.
+
+        Parameters:
+            pad_to - An integer specifying the byte alignment that should be present
+            after padding is complete. Supports 1, 2, 4, 8, 16 or any other power of
+            two padding. After calling this, the next write_byte or write_int will
+            be placed on a boundary compatible with the pad_to parameter.
+        """
+        while (self.__data_len & (pad_to - 1)) != 0:
+            self.__data.append(b'\0')
+            self.__data_len = self.__data_len + 1
+        self.__formatted_data = None
diff --git a/bemani/protocol/xml.py b/bemani/protocol/xml.py
new file mode 100644
index 0000000..bd29821
--- /dev/null
+++ b/bemani/protocol/xml.py
@@ -0,0 +1,546 @@
+import copy
+import struct
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+from bemani.protocol.stream import InputStream
+from bemani.protocol.node import Node
+
+
+class XmlEncodingException(Exception):
+    """
+    An exception that is thrown when we encounter an error encoding to or decoding from XML.
+    """
+
+
+class XmlDecoder:
+    """
+    A hand-rolled XML parser, suitable for parsing old-style XML documents in
+    game data or from legacy game traffic. I did consider using lxml and other
+    data stores, but they insist on mangling data inside binary/string blobs
+    making them unsuitable for a protocol with exact specifications.
+    """
+
+    def __init__(self, data: bytes, encoding: str) -> None:
+        """
+        Initialize the XML decoder.
+
+        Parameters:
+            data - String XML data which should be decoded into Nodes.
+            encoding - The expected encoding of the XML.
+        """
+        self.stream = InputStream(data)
+        self.root: Optional[Node] = None
+        self.current: List[Node] = []
+        self.encoding = encoding
+
+    def __start_element(self, tag: bytes, attributes: Dict[str, str]) -> None:
+        """
+        Called when we encounter an element open tag. Also called when we encounter
+        an empty element. Creates a new node with the specified name and attributes.
+
+        Parameters:
+            tag - The string tag name.
+            attributes - A dictionary keyed by attribute name and whose values are the string
+                         attribute values. This attribute values should already be decoded from
+                         the XML's encoding.
+        """
+        data_type = attributes.get('__type')
+
+        array_str = attributes.get('__count')
+        if array_str is not None:
+            array = True
+        else:
+            array = False
+
+        if data_type is None:
+            # Special case for nodes that don't have a type
+            node = Node(name=tag.decode('ascii'), type=Node.NODE_TYPE_VOID)
+        else:
+            # Get the data value
+            type_int = Node.typename_to_type(data_type)
+            if type_int is None:
+                raise XmlEncodingException('Invalid node type {} for node {}'.format(data_type, tag.decode('ascii')))
+
+            node = Node(name=tag.decode('ascii'), type=type_int, array=array)
+
+        # Now, do the attributes
+        for attr in attributes:
+            if attr == '__type' or attr == '__count':
+                # Skip these, handled
+                continue
+            else:
+                node.set_attribute(attr, attributes.get(attr))
+
+        self.current.append(node)
+
+    def __end_element(self, tag: bytes) -> None:
+        """
+        Called when we encounter an element close tag. Also called when we encounter an empty element,
+        after __start_element is called. Does bookkeeping related to element order.
+
+        Parameters:
+            tag - The string tag name.
+        """
+        node = self.current.pop()
+
+        if node.name != tag.decode('ascii'):
+            raise Exception('Logic error, expected {} but got {}'.format(tag.decode('ascii'), node.name))
+
+        if len(self.current) == 0:
+            self.root = node
+        else:
+            parent = self.current[-1]
+            parent.add_child(node)
+
+    def __yield_values(self, text: str) -> Iterator[str]:
+        value = ''
+
+        for c in text:
+            if c.isspace():
+                if len(value) > 0:
+                    yield value
+                    value = ''
+            else:
+                value = value + c
+
+        if len(value) > 0:
+            yield value
+
+    def __text(self, text: bytes) -> None:
+        """
+        Called when we finish parsing arbitrary non-element text. Note that the text passed in is in
+        the XML document's encoding and it is this function's responsibility to decode it.
+
+        Parameters:
+            text - String text value of the node, as encoded by the XML document's encoding.
+        """
+        try:
+            value = text.decode(self.encoding)
+        except UnicodeDecodeError:
+            raise XmlEncodingException('Failed to decode text node with given encoding')
+
+        if len(self.current) > 0:
+            data_type = self.current[-1].data_type
+            composite = self.current[-1].is_composite
+            array = self.current[-1].is_array
+
+            if data_type == 'void':
+                # We can't handle this
+                return
+
+            if data_type == 'str':
+                # Do nothing, already fine
+                value = value.replace('&amp;', '&')
+                value = value.replace('&lt;', '<')
+                value = value.replace('&gt;', '>')
+                value = value.replace('&apos;', '\'')
+                value = value.replace('&quot;', '\"')
+                if self.current[-1].value is None:
+                    self.current[-1].set_value(value)
+                else:
+                    self.current[-1].set_value(self.current[-1].value + value)
+            elif data_type == 'bin':
+                # Convert from a hex string
+                def hex_to_bin(hexval: str) -> bytes:
+                    intval = int(hexval, 16)
+                    return struct.pack('>B', intval)
+
+                # Remove any spaces first
+                value = ''.join([c for c in value if not c.isspace()])
+                if self.current[-1].value is None:
+                    self.current[-1].set_value(b''.join([hex_to_bin(value[i:(i + 2)]) for i in range(0, len(value), 2)]))
+                else:
+                    self.current[-1].set_value(self.current[-1].value + b''.join([hex_to_bin(value[i:(i + 2)]) for i in range(0, len(value), 2)]))
+            elif data_type == 'ip4':
+                # Do nothing, already fine
+                self.current[-1].set_value(value)
+            elif data_type == 'bool':
+                def conv_bool(val: str) -> bool:
+                    if val and val.lower() in ['0', 'false']:
+                        return False
+                    else:
+                        return True
+
+                if array or composite:
+                    self.current[-1].set_value([conv_bool(v) for v in self.__yield_values(value)])
+                else:
+                    self.current[-1].set_value(conv_bool(value))
+            elif data_type == 'float':
+                if array or composite:
+                    self.current[-1].set_value([float(v) for v in self.__yield_values(value)])
+                else:
+                    self.current[-1].set_value(float(value))
+            else:
+                if array or composite:
+                    self.current[-1].set_value([int(v) for v in self.__yield_values(value)])
+                else:
+                    self.current[-1].set_value(int(value))
+
+    def __parse_attributes(self, attributes: bytes) -> Dict[str, str]:
+        """
+        Given a string representing zero or more possible attributes, parse them into
+        a dictionary.
+
+        Returns:
+            A dictionary keyed by the attribute name and who's values are unescaped strings.
+            If no attributes exist, this returns an empty dictionary.
+        """
+        attr_stream = InputStream(attributes)
+        parsed_attrs: Dict[str, str] = {}
+        state = 'space'
+        attr = b''
+        val = b''
+
+        def unescape(value: bytes) -> str:
+            val = value.decode(self.encoding)
+            val = val.replace('&amp;', '&')
+            val = val.replace('&lt;', '<')
+            val = val.replace('&gt;', '>')
+            val = val.replace('&apos;', '\'')
+            val = val.replace('&quot;', '\"')
+            val = val.replace('&#13;', '\r')
+            return val.replace('&#10;', '\n')
+
+        while True:
+            c = attr_stream.read_byte()
+
+            if c is None:
+                return parsed_attrs
+            if state == 'space':
+                if not c.isspace():
+                    state = 'attr'
+                    attr = c
+            elif state == 'attr':
+                if c == b'=':
+                    attr = attr.strip()
+                    state = 'valstart'
+                else:
+                    attr = attr + c
+            elif state == 'valstart':
+                if c == b'"':
+                    state = 'valdouble'
+                    val = b''
+                elif c == b'\'':
+                    state = 'valsingle'
+                    val = b''
+            elif state == 'valdouble':
+                if c == b'"':
+                    state = 'space'
+                    parsed_attrs[attr.decode('ascii')] = unescape(val)
+                else:
+                    val = val + c
+            elif state == 'valsingle':
+                if c == b'\'':
+                    state = 'space'
+                    parsed_attrs[attr.decode('ascii')] = unescape(val)
+                else:
+                    val = val + c
+
+    def __split_node(self, content: bytes) -> Tuple[bytes, bytes]:
+        node_stream = InputStream(content)
+        tag = b''
+        attributes = b''
+        state = "tag"
+
+        while True:
+            c = node_stream.read_byte()
+
+            if c is None:
+                break
+            if state == "tag":
+                if c.isspace():
+                    state = "space"
+                else:
+                    tag = tag + c
+            elif state == "space":
+                if not c.isspace():
+                    attributes = c
+                    state = "attributes"
+            elif state == "attributes":
+                attributes = attributes + c
+
+        return (tag, attributes)
+
+    def __handle_node(self, content: bytes) -> None:
+        """
+        Called whenever we encounter any node type. Filters out special nodes,
+        determines whether this is a start, end or empty node, and fires off
+        calls to the respective __start_element and __end_element functions.
+
+        Parameters:
+            The node contents, minus the < and > characters. This will be encoded
+            in the XML document's encoding.
+        """
+        if content[:1] == b'?' and content[-1:] == b'?':
+            # Special node, parse to get the encoding.
+            tag, attributes = self.__split_node(content[1:-1])
+            if tag == b'xml':
+                attributes_dict = self.__parse_attributes(attributes)
+                if 'encoding' in attributes_dict:
+                    self.encoding = attributes_dict['encoding']
+            return
+
+        if content[:1] == b'/':
+            # We got an element end
+            self.__end_element(content[1:])
+        else:
+            # We got a start element
+            if content[-1:] == b'/':
+                # This is an empty element
+                empty = True
+                content = content[:-1]
+            else:
+                # This node has subnodes or text
+                empty = False
+
+            tag, attributes = self.__split_node(content)
+            self.__start_element(tag, self.__parse_attributes(attributes))
+            if empty:
+                self.__end_element(tag)
+
+    def get_tree(self) -> Node:
+        """
+        Walk the XML document and parse into nodes.
+
+        Returns:
+            A Node object representing the root of the XML document.
+        """
+        state = 'text'
+        text = b''
+        node = b''
+
+        while True:
+            c = self.stream.read_byte()
+
+            if c is None:
+                return self.root
+            elif state == 'text':
+                if c == b'<':
+                    self.__text(text)
+                    state = 'node'
+                    node = b''
+                else:
+                    text = text + c
+            elif state == 'node':
+                if c == b'>':
+                    self.__handle_node(node)
+                    state = 'text'
+                    text = b''
+                else:
+                    node = node + c
+
+
+class XmlEncoder:
+    def __init__(self, tree: Node, encoding: str) -> None:
+        """
+        Initialize the XML encoder.
+
+        Parameters:
+            tree - A binary blob of data to be decoded
+            encoding - A string representing the text encoding for string elements. Should be either
+                       'shift-jis', 'euc-jp' or 'utf-8'
+        """
+        self.tree = tree
+        self.encoding = encoding
+
+    def get_data(self) -> bytes:
+        magic = '<?xml version="1.0" encoding="{}"?>'.format(self.encoding).encode('ascii')
+        payload = self.to_xml(self.tree)
+
+        return magic + payload
+
+    def to_xml(self, node: Node) -> bytes:
+        """
+        Convert this node, attributes and all children to an XML-like representation of the tree.
+
+        Parameters:
+            node: A Node representing the root of the tree to be encoded.
+
+        Returns:
+            Bytes representing the XML-like data for this node and all children.
+        """
+        attrs_dict = copy.deepcopy(node.attributes)
+        order = sorted(attrs_dict.keys())
+        if node.data_length != 0:
+            # Represent type and length
+            if node.is_array:
+                if node.value is None:
+                    attrs_dict['__count'] = '0'
+                else:
+                    attrs_dict['__count'] = str(len(node.value))
+                order.insert(0, '__count')
+            attrs_dict['__type'] = node.data_type
+            order.insert(0, '__type')
+
+        def escape(val: Any, attr: bool=False) -> bytes:
+            if isinstance(val, str):
+                val = val.replace('&', '&amp;')
+                val = val.replace('<', '&lt;')
+                val = val.replace('>', '&gt;')
+                val = val.replace('\'', '&apos;')
+                val = val.replace('\"', '&quot;')
+                if attr:
+                    val = val.replace('\r', '&#13;')
+                    val = val.replace('\n', '&#10;')
+
+                return val.encode(self.encoding)
+            else:
+                return str(val).encode('ascii')
+
+        if attrs_dict:
+            attrs = b' ' + b' '.join([b''.join([attr.encode('ascii'), b'="', escape(attrs_dict[attr], attr=True), b'"']) for attr in order])
+        else:
+            attrs = b''
+
+        if node.children:
+            # Has children nodes
+            children = [self.to_xml(child) for child in node.children]
+            string = b''.join([
+                b'<',
+                node.name.encode('ascii'),
+                attrs,
+                b'>',
+                b''.join(children),
+                b'</',
+                node.name.encode('ascii'),
+                b'>',
+            ])
+        else:
+            # Doesn't have children nodes
+            if node.data_length == 0:
+                # Void node
+                string = b''.join([
+                    b'<',
+                    node.name.encode('ascii'),
+                    attrs,
+                    b'/>',
+                ])
+            else:
+                # Node with values
+                if node.is_array or node.is_composite:
+                    if node.value is None:
+                        vals = ''
+                    else:
+                        if node.data_type == 'bool':
+                            vals = ' '.join([('1' if val else '0') for val in node.value])
+                        else:
+                            vals = ' '.join([str(val) for val in node.value])
+                    binary = vals.encode('ascii')
+                elif node.data_type == 'str':
+                    binary = escape(node.value)
+                elif node.data_type == 'bool':
+                    binary = b'1' if node.value else b'0'
+                elif node.data_type == 'ip4':
+                    vals = '.'.join([str(val) for val in node.value])
+                    binary = vals.encode('ascii')
+                elif node.data_type == 'bin':
+                    # Convert to a hex string
+                    def bin_to_hex(binary: int) -> str:
+                        val = hex(binary)[2:]
+                        while len(val) < 2:
+                            val = '0' + val
+                        return val
+
+                    vals = ''.join([bin_to_hex(v) for v in node.value])
+                    binary = vals.encode('ascii')
+                else:
+                    vals = str(node.value)
+                    binary = vals.encode('ascii')
+
+                string = b''.join([
+                    b'<',
+                    node.name.encode('ascii'),
+                    attrs,
+                    b'>',
+                    binary,
+                    b'</',
+                    node.name.encode('ascii'),
+                    b'>',
+                ])
+
+        return string
+
+
+class XmlEncoding:
+    """
+    Wrapper class representing an XML encoding.
+    """
+    # The string values should match the constants in EAmuseProtocol.
+    # I have no better way to link these than to write this comment,
+    # as otherwise we would have a circular dependency.
+    ACCEPTED_ENCODINGS = ['shift-jis', 'euc-jp', 'utf-8', 'ascii']
+
+    def __init__(self) -> None:
+        """
+        Initialize the encoding object.
+        """
+        self.encoding: Optional[str] = None
+
+    def __fix_encoding(self, encoding: str) -> str:
+        """
+        Given an encoding, try to normalize it, looking for specific ways that
+        older games might send it back.
+
+        Parameters:
+            encoding - The encoding we want to normalize.
+
+        Returns:
+            A new encoding string that is equivalent but normalized.
+        """
+        encoding = encoding.lower()
+        encoding = encoding.replace('_', '-')
+        return encoding
+
+    def decode(self, data: bytes, skip_on_exceptions: bool=False) -> Optional[Node]:
+        """
+        Given a data blob, decode the data with the current encoding. Will set
+        the class property value 'encoding' to the encoding used on the last
+        decode.
+
+        Parameters:
+            data - Blob of text representing the data to decode.
+
+        Returns:
+            Node object representing the root of the decoded tree, or None
+            if we couldn't decode the object for some reason.
+        """
+        # Always assume this, unless we get told otherwise in the XML
+        self.encoding = 'shift-jis'
+
+        # Decode property/value
+        try:
+            xml = XmlDecoder(data, self.encoding)
+            tree = xml.get_tree()
+            self.encoding = xml.encoding
+            return tree
+        except XmlEncodingException:
+            if skip_on_exceptions:
+                return None
+            else:
+                raise
+
+    def encode(self, tree: Node, encoding: Optional[str]=None) -> bytes:
+        """
+        Given a tree of Node objects, encode the data with the current encoding.
+
+        Parameters:
+            tree - Node tree representing the data to encode
+            encoding - The text encoding to use. If None, will try to use the encoding from
+                       the last successful decode
+
+        Returns:
+            String blob representing encoded data as XML.
+        """
+        # Ensure we got the right encoding
+        if encoding is None:
+            encoding = self.encoding
+        if encoding is None:
+            raise XmlEncodingException('Unknown encoding')
+
+        encoding = self.__fix_encoding(encoding)
+        if encoding not in XmlEncoding.ACCEPTED_ENCODINGS:
+            # XML pages only support shift-jis
+            raise XmlEncodingException("Invalid text encoding {}".format(encoding))
+
+        xml = XmlEncoder(tree, encoding)
+        return xml.get_data()
diff --git a/bemani/sniff/__init__.py b/bemani/sniff/__init__.py
new file mode 100644
index 0000000..8f90993
--- /dev/null
+++ b/bemani/sniff/__init__.py
@@ -0,0 +1 @@
+from bemani.sniff.sniff import Sniffer
diff --git a/bemani/sniff/sniff.py b/bemani/sniff/sniff.py
new file mode 100644
index 0000000..f2081b6
--- /dev/null
+++ b/bemani/sniff/sniff.py
@@ -0,0 +1,495 @@
+import socket
+import struct
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class InvalidPacketException(Exception):
+    """
+    Exception thrown when a packet has invalid information in it that doesn't
+    confirm to the spec.
+    """
+
+
+class UnknownPacketException(Exception):
+    """
+    Exception thrown when a packet is valid, but we don't include support for
+    decoding it.
+    """
+
+
+class TCPStream:
+    """
+    A very rudimentary TCP stream reassembler. Assumes well-formed TCP streams with a
+    SYN -> SYNACK -> ACK flow followed by some data followed by a FIN -> FINACK -> ACK
+    flow. Luckily, this is exactly what most HTTP requests look like.
+    """
+    INBOUND = 'inbound'
+    OUTBOUND = 'outbound'
+
+    def __init__(self, packet: Dict[str, Any]) -> None:
+        """
+        Initialize a new stream with a packet that belongs in this stream. Expects a packet
+        dictionary as returned by Sniffer.recv_raw().
+        """
+        self.source_address = packet['ip_header']['source_address']
+        self.source_port = packet['tcp_header']['source_port']
+        self.destination_address = packet['ip_header']['destination_address']
+        self.destination_port = packet['tcp_header']['destination_port']
+
+        self.packets = [(TCPStream.INBOUND, packet)]
+
+    def add_packet(self, packet: Dict[str, Any]) -> bool:
+        """
+        Add a packet that potentially belongs to this stream. Expects a packet dictionary as
+        returned by Sniffer.recv_raw().
+
+        Returns:
+            True - If this packet indeed belonged and was added.
+            False - If this packet doesn't belong and should go elsewhere.
+        """
+        if (
+            packet['tcp_header']['source_port'] == self.source_port and
+            packet['tcp_header']['destination_port'] == self.destination_port and
+            packet['ip_header']['source_address'] == self.source_address and
+            packet['ip_header']['destination_address'] == self.destination_address
+        ):
+            self.packets.append((TCPStream.INBOUND, packet))
+            return True
+
+        if (
+            packet['tcp_header']['source_port'] == self.destination_port and
+            packet['tcp_header']['destination_port'] == self.source_port and
+            packet['ip_header']['source_address'] == self.destination_address and
+            packet['ip_header']['destination_address'] == self.source_address
+
+        ):
+            self.packets.append((TCPStream.OUTBOUND, packet))
+            return True
+
+        return False
+
+    def reassemble(self) -> Optional[Dict[str, Any]]:
+        """
+        Attempt to reassemble this stream. If this was successful, you should receive a dictionary containing the
+        following keys. If it was not successful, you should receive None. When there is overlapping data, packets
+        that were received later will take precidence over packets received earlier.
+
+        Returns:
+            None - This stream can't be reassembled.
+            Dictionary:
+                - source_address - A string representing the IPv4 address of the source
+                - destination_address - A string representing the IPv4 address of the destination
+                - source_port - An integer representing the TCP source address
+                - destination_port - An integer representing the TCP destination address
+                - inbound - A binary blob representing inbound traffic, reassembled
+                - outbound - A binary blob representing outbound traffic, reassembled
+        """
+        # This is really crude, just make sure that we get a SYN -> SYN/AC -> ACK, then a FIN -> FIN/ACK -> ACK
+        state: Dict[str, Dict[str, Optional[str]]] = {
+            TCPStream.INBOUND: {
+                'syn': None,
+                'fin': None,
+            },
+            TCPStream.OUTBOUND: {
+                'syn': None,
+                'fin': None,
+            }
+        }
+        sequence = {
+            TCPStream.INBOUND: 0,
+            TCPStream.OUTBOUND: 0,
+        }
+
+        def other_direction(direction: str) -> str:
+            if direction == TCPStream.INBOUND:
+                return TCPStream.OUTBOUND
+            else:
+                return TCPStream.INBOUND
+
+        # Crude state machine to ensure that every SYN was ack'd and every FIN was ack'd. Should probably
+        # also check that SYNs are ack'd before FINs but whatever, it works well enough for now.
+        for packet in self.packets:
+            direction = packet[0]
+            other = other_direction(direction)
+            syn = packet[1]['tcp_header']['flags']['syn']
+            fin = packet[1]['tcp_header']['flags']['fin']
+            ack = packet[1]['tcp_header']['flags']['ack']
+            seq = packet[1]['tcp_header']['sequence']
+
+            if syn:
+                if state[direction]['syn'] is None:
+                    state[direction]['syn'] = 'sent'
+                    sequence[direction] = seq
+            if fin:
+                if state[direction]['fin'] is None:
+                    state[direction]['fin'] = 'sent'
+            if ack:
+                if state[other]['syn'] == 'sent':
+                    state[other]['syn'] = 'ackd'
+                if state[other]['fin'] == 'sent':
+                    state[other]['fin'] = 'ackd'
+
+        if (
+            state[TCPStream.INBOUND]['syn'] == 'ackd' and
+            state[TCPStream.INBOUND]['fin'] == 'ackd' and
+            state[TCPStream.OUTBOUND]['syn'] == 'ackd' and
+            state[TCPStream.OUTBOUND]['fin'] == 'ackd'
+        ):
+            # This stream is finished, can be reassembled
+            data = {
+                TCPStream.INBOUND: b'',
+                TCPStream.OUTBOUND: b'',
+            }
+
+            def add_data(packet: bytes, data: bytes, offset: int) -> bytes:
+                length = len(data)
+
+                if len(packet) < offset:
+                    # Pad out, then add
+                    packet = packet + b'\0' * (offset - len(packet))
+                    return packet + data
+                if len(packet) == offset:
+                    # Add to end
+                    return packet + data
+                if len(packet) > offset and len(packet) <= (offset + length):
+                    # Truncate, then add
+                    packet = packet[:offset]
+                    return packet + data
+                if len(packet) > (offset + length):
+                    before = packet[:offset]
+                    after = packet[offset + length:]
+                    return before + data + after
+
+                raise Exception('Logic error!')
+
+            for packet in self.packets:
+                dir = packet[0]
+                syn = packet[1]['tcp_header']['flags']['syn']
+                fin = packet[1]['tcp_header']['flags']['fin']
+                ack = packet[1]['tcp_header']['flags']['ack']
+                seq = packet[1]['tcp_header']['sequence']
+
+                if syn:
+                    continue
+
+                # Figure out what this packet has
+                length = len(packet[1]['data'])
+                position = seq - sequence[dir] - 1
+
+                if length > 0:
+                    data[dir] = add_data(data[dir], packet[1]['data'], position)
+
+            return {
+                'source_address': self.source_address,
+                'destination_address': self.destination_address,
+                'source_port': self.source_port,
+                'destination_port': self.destination_port,
+                TCPStream.INBOUND: data[TCPStream.INBOUND],
+                TCPStream.OUTBOUND: data[TCPStream.OUTBOUND],
+            }
+
+        return None
+
+
+class Sniffer:
+    """
+    A generic python sniffer. Listens to all raw traffic on the machine and parses packets
+    down to TCP chunks to be reassembled.
+    """
+    RECEIVE_SIZE = 1048576
+    ETH_HEADER_LENGTH = 14
+    IP_HEADER_LENGTH = 20
+    TCP_HEADER_LENGTH = 20
+
+    def __init__(self, address: Optional[str]=None, port: Optional[int]=None) -> None:
+        """
+        Initialize the sniffer. Can be told to filter by address, port or both. If address or
+        port is not provided, it defaults to all addresses or ports.
+
+        Parameters:
+            address - A string representing an IPv4 address to filter on.
+            port - An integer representing a port to filter on.
+        """
+        self.address = address
+        self.port = port
+        self.streams: List[TCPStream] = []
+
+        self.sock = socket.socket(
+            socket.AF_PACKET,
+            socket.SOCK_RAW,
+            socket.ntohs(0x0003),
+        )
+
+    def __process_ethframe(self, eth_header: bytes) -> Dict[str, Any]:
+        """
+        Given a raw binary packet, extract the ethernet frame header and return as a dictionary.
+
+        Parameters:
+            eth_header - Raw bytes to be parsed, should include at least ETH_HEADER_LENGTH bytes.
+
+        Returns:
+            Dictionary:
+                - header_length - The actual length in bytes of this header as an integer
+                - protocol - An integer representing the protocol encapsulated in this header
+        """
+        eth = struct.unpack('!6s6sH', eth_header)
+        eth_protocol = socket.ntohs(eth[2])
+
+        return {
+            'header_length': Sniffer.ETH_HEADER_LENGTH,
+            'protocol': eth_protocol,
+        }
+
+    def __process_ipframe(self, ip_header: bytes) -> Dict[str, Any]:
+        """
+        Given a raw binary packet, extract the IP header and return as a dictionary.
+
+        Parameters:
+            ip_header - Raw bytes to be parsed, should include at least IP_HEADER_LENGTH bytes.
+
+        Returns:
+            Dictionary:
+                - header_length - The actual length in bytes of this header as an integer
+                - version - Integer IP version, should always be 4
+                - length - Integer length of packet including this header
+                - ttl - Integer time to live for packet
+                - protocol - An integer representing the protocol encapsulated in this header
+                - source_address - A string representing the source IPv4 address
+                - destination_address - A string representing the destination IPv4 address
+        """
+        # Extract the 20 bytes IP header, ignoring the IP options
+        iph = struct.unpack('!BBHHHBBH4s4s', ip_header)
+        version = (iph[0] >> 4) & 0xF
+        length = iph[2]
+        ihl = (iph[0] & 0xF) * 4
+        ttl = iph[5]
+        proto = iph[6]
+
+        if ihl < Sniffer.IP_HEADER_LENGTH:
+            raise InvalidPacketException(
+                'Invalid IP length {}'.format(ihl),
+            )
+
+        if version != 4:
+            raise UnknownPacketException(
+                'Unknown IP version {}'.format(version),
+            )
+
+        s_addr = socket.inet_ntoa(iph[8])
+        d_addr = socket.inet_ntoa(iph[9])
+
+        return {
+            'header_length': ihl,
+            'version': version,
+            'length': length,
+            'ttl': ttl,
+            'protocol': proto,
+            'source_address': s_addr,
+            'destination_address': d_addr,
+        }
+
+    def __process_flags(self, flags: int) -> Dict[str, bool]:
+        """
+        Given an integer bitmask, parse as a TCP flag set, returning a dictionary keyed
+        by the flag name who's value is True if set and False otherwise.
+        """
+        return {
+            'ns': True if flags & 0x100 else False,
+            'cwr': True if flags & 0x080 else False,
+            'ece': True if flags & 0x040 else False,
+            'urg': True if flags & 0x020 else False,
+            'ack': True if flags & 0x010 else False,
+            'psh': True if flags & 0x008 else False,
+            'rst': True if flags & 0x004 else False,
+            'syn': True if flags & 0x002 else False,
+            'fin': True if flags & 0x001 else False,
+        }
+
+    def __process_address(self, address: Tuple[int, int, int, int, int]) -> Dict[str, int]:
+        """
+        Given an address tuple from Linux's recvfrom syscall, return a dict which represents this
+        address.
+
+        Parameters:
+            address - A tuple as returned by recvfrom()
+
+        Returns:
+            Dictionary:
+                - interface - The eth interface that this packet was received on
+                - protocol - The protocol used to receive this packet
+                - type - The packet type, as defined by linux kernel headers
+                - hardware_Type - The hardware that received this as an integer
+                - address - The hardware address that received this
+        """
+        return {
+            'interface': address[0],
+            'protocol': address[1],
+            'type': address[2],
+            'hardware_type': address[3],
+            'address': address[4],
+        }
+
+    def __process_tcpframe(self, tcp_header: bytes) -> Dict[str, Any]:
+        """
+        Given a raw binary packet, extract the TCP header and return as a dictionary.
+
+        Parameters:
+            tcp_header - Raw bytes to be parsed, should include at least TCP_HEADER_LENGTH bytes.
+
+        Returns:
+            Dictionary:
+                - header_length - The actual length in bytes of this header as an integer
+                - source_port - An integer representing the source port of this packet
+                - destination_port - An integer respresenting the destination port of this packet
+                - sequence - An integer representing the current sequence number of this packet
+                - acknowledgement - An integer representing the current acknowledgement of this packet
+                - flags - A dictionary as defined in Sniffer.__process_flags()
+        """
+        tcph = struct.unpack('!HHLLBBHHH', tcp_header)
+
+        # Normal stuff
+        source_port = tcph[0]
+        dest_port = tcph[1]
+        sequence = tcph[2]
+        acknowledgement = tcph[3]
+        tcphl = (tcph[4] >> 4) * 4
+
+        # TCP flags
+        flags = ((tcph[4] & 1) << 8) | tcph[5]
+
+        return {
+            'header_length': tcphl,
+            'source_port': source_port,
+            'destination_port': dest_port,
+            'sequence': sequence,
+            'acknowledgement': acknowledgement,
+            'flags': self.__process_flags(flags),
+        }
+
+    def __recv_frame(self) -> Dict[str, Any]:
+        """
+        Grab a packet from the kernel, parse it and return a dictionary representing the parsed
+        packet.
+
+        Returns:
+            Dictionary:
+                - ip_header - A dictionary defined by Sniffer.__process_ipframe()
+                - tcp_header - A dictionary defined by Sniffer.__process_tcipframe()
+                - data - Raw bytes representing payload of this packet
+                - address - A dictionary defined by Sniffer.__process_address()
+        """
+        # Grab a packet
+        packets = self.sock.recvfrom(Sniffer.RECEIVE_SIZE)
+        address = self.__process_address(packets[1])
+        packet = packets[0]
+        offset = 0
+
+        # Make sure its a valid packet
+        eth_header = self.__process_ethframe(packet[offset:(offset + Sniffer.ETH_HEADER_LENGTH)])
+        offset = offset + eth_header['header_length']
+
+        if eth_header['protocol'] != 8:
+            # Not IP
+            raise UnknownPacketException(
+                'Unknown frame {}'.format(eth_header['protocol'])
+            )
+
+        # Get the IP header
+        ip_header = self.__process_ipframe(packet[offset:(offset + Sniffer.IP_HEADER_LENGTH)])
+        offset = offset + ip_header['header_length']
+
+        if ip_header['protocol'] != 6:
+            # Not TCP
+            raise UnknownPacketException(
+                'Unknown protocol {}'.format(ip_header['protocol']),
+            )
+
+        # Get TCP header
+        tcp_header = self.__process_tcpframe(packet[offset:(offset + Sniffer.TCP_HEADER_LENGTH)])
+        offset = offset + tcp_header['header_length']
+
+        # Get payload length
+        payload_length = ip_header['length'] - ip_header['header_length'] - tcp_header['header_length']
+
+        # Get payload
+        data = packet[offset:offset + payload_length]
+
+        return {
+            'ip_header': ip_header,
+            'tcp_header': tcp_header,
+            'data': data,
+            'address': address,
+        }
+
+    def recv_raw(self) -> Dict[str, Any]:
+        """
+        Receive the next packet that fits the filter criteria defined by the Sniffer constructor.
+
+        Returns:
+            Dictionary defined by Sniffer.__recv_frame()
+        """
+        while True:
+            try:
+                packet = self.__recv_frame()
+            except UnknownPacketException:
+                continue
+
+            # Hack for sniffing on localhost
+            if packet['address']['interface'] == 'lo' and packet['address']['type'] != 4:
+                continue
+
+            if self.address and self.port:
+                if (
+                    packet['ip_header']['source_address'] == self.address and
+                    packet['tcp_header']['source_port'] == self.port
+                ):
+                    return packet
+                if (
+                    packet['ip_header']['destination_address'] == self.address and
+                    packet['tcp_header']['destination_port'] == self.port
+                ):
+                    return packet
+            elif self.address:
+                if (
+                    packet['ip_header']['source_address'] == self.address or
+                    packet['ip_header']['destination_address'] == self.address
+                ):
+                    return packet
+            elif self.port:
+                if (
+                    packet['tcp_header']['source_port'] == self.port or
+                    packet['tcp_header']['destination_port'] == self.port
+                ):
+                    return packet
+            else:
+                return packet
+
+    def recv_stream(self) -> Dict[str, Any]:
+        """
+        Receive the next TCP stream that fits the filter criteria defined by the Sniffer constructor.
+
+        Returns:
+            Dictionary defined by TCPStream.reassemble()
+        """
+        while True:
+            # Try to reassemble and return a stream
+            for i in range(len(self.streams)):
+                tcp = self.streams[i].reassemble()
+
+                if tcp:
+                    del self.streams[i]
+                    return tcp
+
+            # Receive the next packet
+            packet = self.recv_raw()
+
+            # Add to the correct stream
+            new = True
+            for stream in self.streams:
+                if stream.add_packet(packet):
+                    new = False
+                    break
+
+            # See if this is a new TCP stream
+            if new:
+                self.streams.append(TCPStream(packet))
diff --git a/bemani/tests/__init__.py b/bemani/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/bemani/tests/declaration.txt b/bemani/tests/declaration.txt
new file mode 100644
index 0000000..afb496b
--- /dev/null
+++ b/bemani/tests/declaration.txt
@@ -0,0 +1,63 @@
+When in the Course of human events it becomes necessary for one people to dissolve the political bands which have connected them with another and to assume among the powers of the earth, the separate and equal station to which the Laws of Nature and of Nature's God entitle them, a decent respect to the opinions of mankind requires that they should declare the causes which impel them to the separation.
+
+We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable Rights, that among these are Life, Liberty and the pursuit of Happiness. — That to secure these rights, Governments are instituted among Men, deriving their just powers from the consent of the governed, — That whenever any Form of Government becomes destructive of these ends, it is the Right of the People to alter or to abolish it, and to institute new Government, laying its foundation on such principles and organizing its powers in such form, as to them shall seem most likely to effect their Safety and Happiness. Prudence, indeed, will dictate that Governments long established should not be changed for light and transient causes; and accordingly all experience hath shewn that mankind are more disposed to suffer, while evils are sufferable than to right themselves by abolishing the forms to which they are accustomed. But when a long train of abuses and usurpations, pursuing invariably the same Object evinces a design to reduce them under absolute Despotism, it is their right, it is their duty, to throw off such Government, and to provide new Guards for their future security. — Such has been the patient sufferance of these Colonies; and such is now the necessity which constrains them to alter their former Systems of Government. The history of the present King of Great Britain is a history of repeated injuries and usurpations, all having in direct object the establishment of an absolute Tyranny over these States. To prove this, let Facts be submitted to a candid world.
+
+He has refused his Assent to Laws, the most wholesome and necessary for the public good.
+
+He has forbidden his Governors to pass Laws of immediate and pressing importance, unless suspended in their operation till his Assent should be obtained; and when so suspended, he has utterly neglected to attend to them.
+
+He has refused to pass other Laws for the accommodation of large districts of people, unless those people would relinquish the right of Representation in the Legislature, a right inestimable to them and formidable to tyrants only.
+
+He has called together legislative bodies at places unusual, uncomfortable, and distant from the depository of their Public Records, for the sole purpose of fatiguing them into compliance with his measures.
+
+He has dissolved Representative Houses repeatedly, for opposing with manly firmness his invasions on the rights of the people.
+
+He has refused for a long time, after such dissolutions, to cause others to be elected, whereby the Legislative Powers, incapable of Annihilation, have returned to the People at large for their exercise; the State remaining in the mean time exposed to all the dangers of invasion from without, and convulsions within.
+
+He has endeavoured to prevent the population of these States; for that purpose obstructing the Laws for Naturalization of Foreigners; refusing to pass others to encourage their migrations hither, and raising the conditions of new Appropriations of Lands.
+
+He has obstructed the Administration of Justice by refusing his Assent to Laws for establishing Judiciary Powers.
+
+He has made Judges dependent on his Will alone for the tenure of their offices, and the amount and payment of their salaries.
+
+He has erected a multitude of New Offices, and sent hither swarms of Officers to harass our people and eat out their substance.
+
+He has kept among us, in times of peace, Standing Armies without the Consent of our legislatures.
+
+He has affected to render the Military independent of and superior to the Civil Power.
+
+He has combined with others to subject us to a jurisdiction foreign to our constitution, and unacknowledged by our laws; giving his Assent to their Acts of pretended Legislation:
+
+For quartering large bodies of armed troops among us:
+
+For protecting them, by a mock Trial from punishment for any Murders which they should commit on the Inhabitants of these States:
+
+For cutting off our Trade with all parts of the world:
+
+For imposing Taxes on us without our Consent:
+
+For depriving us in many cases, of the benefit of Trial by Jury:
+
+For transporting us beyond Seas to be tried for pretended offences:
+
+For abolishing the free System of English Laws in a neighbouring Province, establishing therein an Arbitrary government, and enlarging its Boundaries so as to render it at once an example and fit instrument for introducing the same absolute rule into these Colonies
+
+For taking away our Charters, abolishing our most valuable Laws and altering fundamentally the Forms of our Governments:
+
+For suspending our own Legislatures, and declaring themselves invested with power to legislate for us in all cases whatsoever.
+
+He has abdicated Government here, by declaring us out of his Protection and waging War against us.
+
+He has plundered our seas, ravaged our coasts, burnt our towns, and destroyed the lives of our people.
+
+He is at this time transporting large Armies of foreign Mercenaries to compleat the works of death, desolation, and tyranny, already begun with circumstances of Cruelty & Perfidy scarcely paralleled in the most barbarous ages, and totally unworthy the Head of a civilized nation.
+
+He has constrained our fellow Citizens taken Captive on the high Seas to bear Arms against their Country, to become the executioners of their friends and Brethren, or to fall themselves by their Hands.
+
+He has excited domestic insurrections amongst us, and has endeavoured to bring on the inhabitants of our frontiers, the merciless Indian Savages whose known rule of warfare, is an undistinguished destruction of all ages, sexes and conditions.
+
+In every stage of these Oppressions We have Petitioned for Redress in the most humble terms: Our repeated Petitions have been answered only by repeated injury. A Prince, whose character is thus marked by every act which may define a Tyrant, is unfit to be the ruler of a free people.
+
+Nor have We been wanting in attentions to our British brethren. We have warned them from time to time of attempts by their legislature to extend an unwarrantable jurisdiction over us. We have reminded them of the circumstances of our emigration and settlement here. We have appealed to their native justice and magnanimity, and we have conjured them by the ties of our common kindred to disavow these usurpations, which would inevitably interrupt our connections and correspondence. They too have been deaf to the voice of justice and of consanguinity. We must, therefore, acquiesce in the necessity, which denounces our Separation, and hold them, as we hold the rest of mankind, Enemies in War, in Peace Friends.
+
+We, therefore, the Representatives of the united States of America, in General Congress, Assembled, appealing to the Supreme Judge of the world for the rectitude of our intentions, do, in the Name, and by Authority of the good People of these Colonies, solemnly publish and declare, That these united Colonies are, and of Right ought to be Free and Independent States, that they are Absolved from all Allegiance to the British Crown, and that all political connection between them and the State of Great Britain, is and ought to be totally dissolved; and that as Free and Independent States, they have full Power to levy War, conclude Peace, contract Alliances, establish Commerce, and to do all other Acts and Things which Independent States may of right do. — And for the support of this Declaration, with a firm reliance on the protection of Divine Providence, we mutually pledge to each other our Lives, our Fortunes, and our sacred Honor.
diff --git a/bemani/tests/helpers.py b/bemani/tests/helpers.py
new file mode 100644
index 0000000..3a5bb8f
--- /dev/null
+++ b/bemani/tests/helpers.py
@@ -0,0 +1,17 @@
+# vim: set fileencoding=utf-8
+from typing import List, Dict, Any
+
+
+class FakeCursor():
+
+    def __init__(self, rows: List[Dict[str, Any]]) -> None:
+        self.__rows = rows
+        self.rowcount = len(rows)
+
+    def fetchone(self) -> Dict[str, Any]:
+        if len(self.__rows) != 1:
+            raise Exception('Tried to fetch one row and there are {} rows!'.format(len(self.__rows)))
+        return self.__rows[0]
+
+    def fetchall(self) -> List[Dict[str, Any]]:
+        return self.__rows
diff --git a/bemani/tests/lorem.txt b/bemani/tests/lorem.txt
new file mode 100644
index 0000000..1b37687
--- /dev/null
+++ b/bemani/tests/lorem.txt
@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
diff --git a/bemani/tests/test_AES.py b/bemani/tests/test_AES.py
new file mode 100644
index 0000000..118e194
--- /dev/null
+++ b/bemani/tests/test_AES.py
@@ -0,0 +1,25 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.common import AESCipher
+
+
+class TestAESCipher(unittest.TestCase):
+
+    def test_pad(self) -> None:
+        aes = AESCipher('a wonderful key')
+        self.assertEqual(aes._AESCipher__pad(''), '0.--------------')
+        self.assertEqual(aes._AESCipher__unpad(aes._AESCipher__pad('')), '')
+        self.assertEqual(aes._AESCipher__pad('1337'), '4.1337----------')
+        self.assertEqual(aes._AESCipher__unpad(aes._AESCipher__pad('1337')), '1337')
+        self.assertEqual(aes._AESCipher__pad('aaaaaaaaaaaaaaaa'), '16.aaaaaaaaaaaaaaaa-------------')
+        self.assertEqual(aes._AESCipher__unpad(aes._AESCipher__pad('aaaaaaaaaaaaaaaa')), 'aaaaaaaaaaaaaaaa')
+        self.assertEqual(aes._AESCipher__pad('aaaaaaaaaaaaa'), '13.aaaaaaaaaaaaa')
+        self.assertEqual(aes._AESCipher__unpad(aes._AESCipher__pad('aaaaaaaaaaaaa')), 'aaaaaaaaaaaaa')
+
+    def test_crypto(self) -> None:
+        aes = AESCipher('a wonderful key')
+        ciphertext = aes.encrypt('testing')
+        plaintext = aes.decrypt(ciphertext)
+        self.assertEqual(plaintext, 'testing')
+        self.assertNotEqual(ciphertext, plaintext)
diff --git a/bemani/tests/test_BaseData.py b/bemani/tests/test_BaseData.py
new file mode 100644
index 0000000..85ea92b
--- /dev/null
+++ b/bemani/tests/test_BaseData.py
@@ -0,0 +1,48 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.data.mysql.base import BaseData
+
+
+class TestBaseData(unittest.TestCase):
+
+    def test_basic_serialize(self) -> None:
+        data = BaseData({}, None)
+
+        testdict = {
+            'test1': 1,
+            'test2': '2',
+            'test3': 3.3,
+            'test4': [1, 2, 3, 4],
+            'test5': {
+                'a': 'b',
+            },
+            'testempty': [],
+        }
+
+        self.assertEqual(data.deserialize(data.serialize(testdict)), testdict)
+
+    def test_basic_byte_serialize(self) -> None:
+        data = BaseData({}, None)
+
+        testdict = {
+            'bytes': b'\x01\x02\x03\x04\x05',
+        }
+
+        serialized = data.serialize(testdict)
+        self.assertEqual(serialized, '{"bytes": ["__bytes__", 1, 2, 3, 4, 5]}')
+        self.assertEqual(data.deserialize(serialized), testdict)
+
+    def test_deep_byte_serialize(self) -> None:
+        data = BaseData({}, None)
+
+        testdict = {
+            'sentinal': True,
+            'test': {
+                'sentinal': False,
+                'bytes': b'\x01\x02\x03\x04\x05',
+                'bytes2': b'',
+            }
+        }
+
+        self.assertEqual(data.deserialize(data.serialize(testdict)), testdict)
diff --git a/bemani/tests/test_CardCipher.py b/bemani/tests/test_CardCipher.py
new file mode 100644
index 0000000..bc50087
--- /dev/null
+++ b/bemani/tests/test_CardCipher.py
@@ -0,0 +1,35 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.common import CardCipher
+
+
+class TestCardCipher(unittest.TestCase):
+
+    def test_internal_cipher(self) -> None:
+        test_ciphers = [
+            ([0x68, 0xFC, 0xA5, 0x27, 0x00, 0x01, 0x04, 0xE0], [0xC7, 0xD0, 0xB3, 0x85, 0xAD, 0x1F, 0xD9, 0x49]),
+            ([0x2C, 0x10, 0xA6, 0x27, 0x00, 0x01, 0x04, 0xE0], [0x33, 0xC6, 0xE6, 0x2E, 0x6E, 0x33, 0x38, 0x74]),
+        ]
+
+        for pair in test_ciphers:
+            inp = bytes(pair[0])
+            out = bytes(pair[1])
+            encoded = CardCipher._CardCipher__encode(inp)  # type: ignore
+            self.assertEqual(encoded, out, "Card encode {} doesn't match expected {}".format(encoded, out))
+            decoded = CardCipher._CardCipher__decode(out)  # type: ignore
+            self.assertEqual(decoded, inp, "Card decode {} doesn't match expected {}".format(decoded, inp))
+
+    def test_external_cipher(self) -> None:
+        test_cards = [
+            ("S6E523E30ZK7ML1P", "E004010027A5FC68"),
+            ("78B592HZSM9E6712", "E004010027A6102C"),
+        ]
+
+        for card in test_cards:
+            back = card[0]
+            db = card[1]
+            decoded = CardCipher.decode(back)
+            self.assertEqual(decoded, db, "Card DB {} doesn't match expected {}".format(decoded, db))
+            encoded = CardCipher.encode(db)
+            self.assertEqual(encoded, back, "Card back {} doesn't match expected {}".format(encoded, back))
diff --git a/bemani/tests/test_GameData.py b/bemani/tests/test_GameData.py
new file mode 100644
index 0000000..87e03b8
--- /dev/null
+++ b/bemani/tests/test_GameData.py
@@ -0,0 +1,32 @@
+# vim: set fileencoding=utf-8
+import unittest
+from unittest.mock import Mock
+
+from bemani.data.mysql.game import GameData
+from bemani.tests.helpers import FakeCursor
+
+
+class TestGameData(unittest.TestCase):
+
+    def test_put_time_sensitive_settings(self) -> None:
+        game = GameData({}, None)
+
+        # Verify that we catch incorrect input order
+        with self.assertRaises(Exception) as context:
+            game.put_time_sensitive_settings('game', 1, 'work', {'start_time': 12345, 'end_time': 12340})
+        self.assertTrue('Start time is greater than end time!' in str(context.exception))
+
+        # Verify that we catch events spanning no time
+        with self.assertRaises(Exception) as context:
+            game.put_time_sensitive_settings('game', 1, 'work', {'start_time': 12345, 'end_time': 12345})
+        self.assertTrue('This setting spans zero seconds!' in str(context.exception))
+
+        # Verify that we ignore finding ourselves before updating
+        game.execute = Mock(return_value=FakeCursor([{'start_time': 12345, 'end_time': 12346}]))
+        game.put_time_sensitive_settings('game', 1, 'work', {'start_time': 12345, 'end_time': 12346})
+
+        # Verify that we catch events overlapping other events in the DB
+        game.execute = Mock(return_value=FakeCursor([{'start_time': 12345, 'end_time': 12350}]))
+        with self.assertRaises(Exception) as context:
+            game.put_time_sensitive_settings('game', 1, 'work', {'start_time': 12347, 'end_time': 12355})
+        self.assertTrue('This event overlaps an existing one with start time 12345 and end time 12350' in str(context.exception))
diff --git a/bemani/tests/test_ID.py b/bemani/tests/test_ID.py
new file mode 100644
index 0000000..a9932b5
--- /dev/null
+++ b/bemani/tests/test_ID.py
@@ -0,0 +1,19 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.common import ID
+
+
+class TestID(unittest.TestCase):
+
+    def test_format_extid(self) -> None:
+        self.assertEqual(ID.format_extid(12345678), '1234-5678')
+        self.assertEqual(ID.parse_extid('1234-5678'), 12345678)
+        self.assertEqual(ID.parse_extid('bla'), None)
+        self.assertEqual(ID.parse_extid('blah-blah'), None)
+
+    def test_format_machine_id(self) -> None:
+        self.assertEqual(ID.format_machine_id(123), 'US-123')
+        self.assertEqual(ID.parse_machine_id('US-123'), 123)
+        self.assertEqual(ID.parse_machine_id('bla'), None)
+        self.assertEqual(ID.parse_machine_id('US-blah'), None)
diff --git a/bemani/tests/test_IIDXPendual.py b/bemani/tests/test_IIDXPendual.py
new file mode 100644
index 0000000..1033707
--- /dev/null
+++ b/bemani/tests/test_IIDXPendual.py
@@ -0,0 +1,72 @@
+# vim: set fileencoding=utf-8
+import struct
+import unittest
+import random
+from unittest.mock import Mock
+from typing import List
+
+from bemani.backend.iidx.pendual import IIDXPendual
+from bemani.data import Score
+
+
+class TestIIDXPendual(unittest.TestCase):
+
+    def __make_score(self, ghost: List[int]) -> Score:
+        return Score(
+            0,
+            0,
+            0,
+            sum(ghost),
+            1234567890,
+            1234567890,
+            0,
+            1,
+            {
+                'ghost': bytes(ghost),
+            },
+        )
+
+    def test_average_no_scores(self) -> None:
+        base = IIDXPendual(Mock(), {}, Mock())
+        self.assertEqual(
+            base.delta_score([], 3),
+            (None, None),
+        )
+
+    def test_average_identity(self) -> None:
+        base = IIDXPendual(Mock(), {}, Mock())
+        self.assertEqual(
+            base.delta_score([
+                self.__make_score([10, 20, 30]),
+            ], 3),
+            (60, struct.pack('bbb', *[-10, 0, 10])),
+        )
+
+    def test_average_basic(self) -> None:
+        base = IIDXPendual(Mock(), {}, Mock())
+        self.assertEqual(
+            base.delta_score([
+                self.__make_score([10, 20, 30]),
+                self.__make_score([0, 0, 0]),
+            ], 3),
+            (30, struct.pack('bbb', *[-5, 0, 5])),
+        )
+
+    def test_average_complex(self) -> None:
+        base = IIDXPendual(Mock(), {}, Mock())
+        self.assertEqual(
+            base.delta_score([
+                self.__make_score([10, 20, 30]),
+                self.__make_score([20, 30, 40]),
+                self.__make_score([30, 40, 50]),
+            ], 3),
+            (90, struct.pack('bbb', *[-10, 0, 10])),
+        )
+
+    def test_average_always_zero(self) -> None:
+        base = IIDXPendual(Mock(), {}, Mock())
+        ex_score, ghost = base.delta_score([
+            self.__make_score([random.randint(0, 10) for _ in range(64)]),
+            self.__make_score([random.randint(0, 10) for _ in range(64)]),
+        ], 64)
+        self.assertEqual(sum(struct.unpack('b' * 64, ghost)), 0)
diff --git a/bemani/tests/test_JubeatProp.py b/bemani/tests/test_JubeatProp.py
new file mode 100644
index 0000000..3a56eb0
--- /dev/null
+++ b/bemani/tests/test_JubeatProp.py
@@ -0,0 +1,433 @@
+# vim: set fileencoding=utf-8
+import unittest
+from unittest.mock import Mock
+
+from bemani.backend.jubeat.prop import JubeatProp
+from bemani.common import ValidatedDict
+from bemani.data.types import Achievement, UserID
+
+
+class TestJubeatProp(unittest.TestCase):
+
+    def test_increment_class(self) -> None:
+        # Verify normal increase
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(1, 5), (1, 4))
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(1, 4), (1, 3))
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(3, 3), (3, 2))
+
+        # Verify bumping class when minor class is at max
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(1, 1), (2, 5))
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(2, 1), (3, 5))
+
+        # Verify bumping class to legend which only has one subclass
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(3, 1), (4, 1))
+
+        # Verify bumping when already at max
+        self.assertEqual(JubeatProp._JubeatProp__increment_class(4, 1), (4, 1))
+
+    def test_decrement_class(self) -> None:
+        # Verify normal decrease
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(1, 3), (1, 4))
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(1, 4), (1, 5))
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(3, 2), (3, 3))
+
+        # Verify demoting class when minor class is at min
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(2, 5), (1, 1))
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(3, 5), (2, 1))
+
+        # Verify demoting class when starting at legend
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(4, 1), (3, 1))
+
+        # Verify decrease when already at min
+        self.assertEqual(JubeatProp._JubeatProp__decrement_class(1, 5), (1, 5))
+
+    def test_get_league_buckets(self) -> None:
+        # Verify correct behavior with empty input
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_buckets(
+                [],
+            ),
+            (
+                [],
+                [],
+                [],
+            ),
+        )
+
+        # Verify correct behavior with only one entrant (should be promoted)
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_buckets(
+                [
+                    (5, 12345),
+                ],
+            ),
+            (
+                [
+                    5,
+                ],
+                [],
+                [],
+            ),
+        )
+
+        # Verify correct behavior with two entrants (should be one promotion, one demotion)
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_buckets(
+                [
+                    (5, 12345),
+                    (7, 54321),
+                ],
+            ),
+            (
+                [
+                    7,
+                ],
+                [],
+                [
+                    5,
+                ],
+            ),
+        )
+
+        # Verify correct behavior with three entrants (should be one promotion, one demotion, one same)
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_buckets(
+                [
+                    (5, 12345),
+                    (7, 54321),
+                    (9, 33333),
+                ],
+            ),
+            (
+                [
+                    7,
+                ],
+                [
+                    9,
+                ],
+                [
+                    5,
+                ],
+            ),
+        )
+
+        # Verify correct behavior with ten entrants (should be 3 promotions, 3 demotions, 4 same)
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_buckets(
+                [
+                    (5, 55555),
+                    (7, 77777),
+                    (9, 99999),
+                    (1, 11111),
+                    (6, 66666),
+                    (8, 88888),
+                    (2, 22222),
+                    (3, 33333),
+                    (10, 100000),
+                    (4, 44444),
+                ],
+            ),
+            (
+                [
+                    10,
+                    9,
+                    8,
+                ],
+                [
+                    7,
+                    6,
+                    5,
+                    4,
+                ],
+                [
+                    3,
+                    2,
+                    1,
+                ],
+            ),
+        )
+
+    def test_get_league_scores(self) -> None:
+        data = Mock()
+        data.local = Mock()
+        data.local.user = Mock()
+
+        # Test correct behavior on empty input
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_scores(
+                None,
+                999,
+                []
+            ),
+            (
+                [],
+                [],
+            ),
+        )
+
+        # Test that we can load last week's score if it exists for a user
+        data.local.user.get_achievement = Mock(return_value={'score': [123, 456, 789]})
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_scores(
+                data,
+                999,
+                [(UserID(1337), {})],
+            ),
+            (
+                [(1337, 1368)],
+                [],
+            ),
+        )
+        data.local.user.get_achievement.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+            998,
+            'league',
+        )
+        data.local.user.get_achievement.reset_mock()
+
+        # Test that if it doesn't exist last week they get marked as absent
+        data.local.user.get_achievement = Mock(return_value=None)
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_scores(
+                data,
+                999,
+                [(UserID(1337), {})],
+            ),
+            (
+                [],
+                [1337],
+            ),
+        )
+        data.local.user.get_achievement.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+            998,
+            'league',
+        )
+        data.local.user.get_achievement.reset_mock()
+
+    def test_get_league_absentees(self) -> None:
+        data = Mock()
+        data.local = Mock()
+        data.local.user = Mock()
+
+        # Test that we do the right thing with empty input
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_absentees(
+                None,
+                999,
+                [],
+            ),
+            [],
+        )
+
+        # Test that a user who never played doesn't get flagged absentee
+        data.local.user.get_achievements = Mock(return_value=[])
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_absentees(
+                data,
+                999,
+                [1337],
+            ),
+            [],
+        )
+        data.local.user.get_achievements.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+        )
+        data.local.user.get_achievements.reset_mock()
+
+        # Test that a user who only skipped last week doesn't get flagged absentee
+        data.local.user.get_achievements = Mock(return_value=[
+            Achievement(997, 'league', None, {}),
+        ])
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_absentees(
+                data,
+                999,
+                [1337],
+            ),
+            [],
+        )
+        data.local.user.get_achievements.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+        )
+        data.local.user.get_achievements.reset_mock()
+
+        # Test that a user who skipped last two week gets flagged absentee
+        data.local.user.get_achievements = Mock(return_value=[
+            Achievement(996, 'league', None, {}),
+        ])
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_absentees(
+                data,
+                999,
+                [1337],
+            ),
+            [1337],
+        )
+        data.local.user.get_achievements.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+        )
+        data.local.user.get_achievements.reset_mock()
+
+        # Test that a user who skipped last three week doesn't get flagged
+        # (they got flagged last week)
+        data.local.user.get_achievements = Mock(return_value=[
+            Achievement(995, 'league', None, {}),
+        ])
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_absentees(
+                data,
+                999,
+                [1337],
+            ),
+            [],
+        )
+        data.local.user.get_achievements.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+        )
+        data.local.user.get_achievements.reset_mock()
+
+        # Test that a user who skipped last four week gets flagged absentee
+        data.local.user.get_achievements = Mock(return_value=[
+            Achievement(994, 'league', None, {}),
+        ])
+        self.assertEqual(
+            JubeatProp._JubeatProp__get_league_absentees(
+                data,
+                999,
+                [1337],
+            ),
+            [1337],
+        )
+        data.local.user.get_achievements.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+        )
+        data.local.user.get_achievements.reset_mock()
+
+    def test_modify_profile(self) -> None:
+        data = Mock()
+        data.local = Mock()
+        data.local.user = Mock()
+
+        # Test demoting a user at the bottom does nothing.
+        data.local.user.get_profile = Mock(return_value=ValidatedDict({
+            'league_class': 1,
+            'league_subclass': 5,
+        }))
+        JubeatProp._JubeatProp__modify_profile(
+            data,
+            1337,
+            'demote',
+        )
+        self.assertFalse(data.local.user.put_profile.called)
+
+        # Test promoting a user at the top does nothing.
+        data.local.user.get_profile = Mock(return_value=ValidatedDict({
+            'league_class': 4,
+            'league_subclass': 1,
+        }))
+        JubeatProp._JubeatProp__modify_profile(
+            data,
+            1337,
+            'promote',
+        )
+        self.assertFalse(data.local.user.put_profile.called)
+
+        # Test regular promotion updates profile properly
+        data.local.user.get_profile = Mock(return_value=ValidatedDict({
+            'league_class': 1,
+            'league_subclass': 5,
+            'league_is_checked': True,
+        }))
+        JubeatProp._JubeatProp__modify_profile(
+            data,
+            1337,
+            'promote',
+        )
+        data.local.user.put_profile.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+            {
+                'league_class': 1,
+                'league_subclass': 4,
+                'league_is_checked': False,
+                'last': {
+                    'league_class': 1,
+                    'league_subclass': 5,
+                },
+            },
+        )
+        data.local.user.put_profile.reset_mock()
+
+        # Test regular demote updates profile properly
+        data.local.user.get_profile = Mock(return_value=ValidatedDict({
+            'league_class': 1,
+            'league_subclass': 3,
+            'league_is_checked': True,
+        }))
+        JubeatProp._JubeatProp__modify_profile(
+            data,
+            1337,
+            'demote',
+        )
+        data.local.user.put_profile.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+            {
+                'league_class': 1,
+                'league_subclass': 4,
+                'league_is_checked': False,
+                'last': {
+                    'league_class': 1,
+                    'league_subclass': 3,
+                },
+            },
+        )
+        data.local.user.put_profile.reset_mock()
+
+        # Test demotion after not checking doesn't update old values
+        data.local.user.get_profile = Mock(return_value=ValidatedDict({
+            'league_class': 1,
+            'league_subclass': 4,
+            'league_is_checked': False,
+            'last': {
+                'league_class': 1,
+                'league_subclass': 3,
+            },
+        }))
+        JubeatProp._JubeatProp__modify_profile(
+            data,
+            1337,
+            'demote',
+        )
+        data.local.user.put_profile.assert_called_once_with(
+            JubeatProp.game,
+            JubeatProp.version,
+            1337,
+            {
+                'league_class': 1,
+                'league_subclass': 5,
+                'league_is_checked': False,
+                'last': {
+                    'league_class': 1,
+                    'league_subclass': 3,
+                },
+            },
+        )
+        data.local.user.put_profile.reset_mock()
diff --git a/bemani/tests/test_NetworkData.py b/bemani/tests/test_NetworkData.py
new file mode 100644
index 0000000..1af7609
--- /dev/null
+++ b/bemani/tests/test_NetworkData.py
@@ -0,0 +1,51 @@
+# vim: set fileencoding=utf-8
+import unittest
+from unittest.mock import Mock
+from freezegun import freeze_time
+
+from bemani.data.mysql.network import NetworkData
+from bemani.tests.helpers import FakeCursor
+
+
+class TestNetworkData(unittest.TestCase):
+
+    def test_get_schedule_type(self) -> None:
+        network = NetworkData({}, None)
+
+        with freeze_time('2016-01-01 12:00'):
+            # Check daily schedule
+            self.assertEqual(
+                # 2016-01-01 -> 2016-01-02
+                (1451606400, 1451692800),
+                network.get_schedule_duration('daily'),
+            )
+
+            # Check weekly schedule (weeks start on monday in python lol)
+            self.assertEqual(
+                # 2015-12-27 -> 2916-01-03
+                (1451260800, 1451865600),
+                network.get_schedule_duration('weekly'),
+            )
+
+    def test_should_schedule(self) -> None:
+        network = NetworkData({}, None)
+
+        with freeze_time('2016-01-01'):
+            # Check for should schedule if nothing in DB
+            network.execute = Mock(return_value=FakeCursor([]))
+            self.assertTrue(network.should_schedule('game', 1, 'work', 'daily'))
+            self.assertTrue(network.should_schedule('game', 1, 'work', 'weekly'))
+
+            # Check for don't schedule if DB time is our current time
+            network.execute = Mock(return_value=FakeCursor([{'year': 2016, 'day': 1}]))
+            self.assertFalse(network.should_schedule('game', 1, 'work', 'daily'))
+
+            network.execute = Mock(return_value=FakeCursor([{'year': None, 'day': 16797}]))
+            self.assertFalse(network.should_schedule('game', 1, 'work', 'weekly'))
+
+            # Check for do schedule if DB time is older than our current time
+            network.execute = Mock(return_value=FakeCursor([{'year': 2015, 'day': 365}]))
+            self.assertTrue(network.should_schedule('game', 1, 'work', 'daily'))
+
+            network.execute = Mock(return_value=FakeCursor([{'year': None, 'day': 16790}]))
+            self.assertTrue(network.should_schedule('game', 1, 'work', 'weekly'))
diff --git a/bemani/tests/test_Parallel.py b/bemani/tests/test_Parallel.py
new file mode 100644
index 0000000..f64957d
--- /dev/null
+++ b/bemani/tests/test_Parallel.py
@@ -0,0 +1,95 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.common import Parallel
+
+
+class TestParallel(unittest.TestCase):
+
+    def test_empty(self) -> None:
+        results = Parallel.execute([])
+        self.assertEqual(results, [])
+        results = Parallel.map(lambda x: x, [])
+        self.assertEqual(results, [])
+        results = Parallel.call([])
+        self.assertEqual(results, [])
+        results = Parallel.flatten([])
+        self.assertEqual(results, [])
+
+    def test_basic(self) -> None:
+        results = Parallel.execute([
+            lambda: 1,
+            lambda: 2,
+            lambda: 3,
+            lambda: 4,
+            lambda: 5,
+        ])
+        self.assertEqual(results, [1, 2, 3, 4, 5])
+
+    def test_function(self) -> None:
+        def fun(x: int) -> int:
+            return -x
+
+        results = Parallel.execute([
+            lambda: fun(1),
+            lambda: fun(2),
+            lambda: fun(3),
+            lambda: fun(4),
+            lambda: fun(5),
+        ])
+        self.assertEqual(results, [-1, -2, -3, -4, -5])
+
+    def test_map(self) -> None:
+        def fun(x: int) -> int:
+            return x * 2
+
+        results = Parallel.map(fun, [1, 2, 3, 4, 5])
+        self.assertEqual(results, [2, 4, 6, 8, 10])
+
+    def test_call(self) -> None:
+        def fun1(x: int) -> int:
+            return x * 10
+
+        def fun2(x: int) -> int:
+            return -x * 10
+
+        def fun3(x: int) -> int:
+            return x * 2
+
+        def fun4(x: int) -> int:
+            return -x * 2
+
+        def fun5(x: int) -> int:
+            return x
+
+        results = Parallel.call([fun1, fun2, fun3, fun4, fun5], 2)
+        self.assertEqual(results, [20, -20, 4, -4, 2])
+
+    def test_class(self) -> None:
+        class A:
+            def fun(self, x: int) -> int:
+                return x * 10
+
+        class B:
+            def fun(self, x: int) -> int:
+                return x * 20
+
+        class C:
+            def fun(self, x: int) -> int:
+                return x * 30
+
+        class D:
+            def fun(self, x: int) -> int:
+                return x * 40
+
+        class E:
+            def fun(self, x: int) -> int:
+                return x * 50
+
+        classes = [A(), B(), C(), D(), E()]
+        results = Parallel.call([c.fun for c in classes], 2)
+        self.assertEqual(results, [20, 40, 60, 80, 100])
+
+    def test_flatten(self) -> None:
+        results = Parallel.flatten([[1, 2, 3], [4, 5, 6], [7, 8, 9], []])
+        self.assertEqual(results, [1, 2, 3, 4, 5, 6, 7, 8, 9])
diff --git a/bemani/tests/test_RC4.py b/bemani/tests/test_RC4.py
new file mode 100644
index 0000000..c5c3a3b
--- /dev/null
+++ b/bemani/tests/test_RC4.py
@@ -0,0 +1,42 @@
+# vim: set fileencoding=utf-8
+import random
+import unittest
+
+from bemani.protocol.protocol import EAmuseProtocol
+
+
+class TestRC4Cipher(unittest.TestCase):
+
+    def test_crypto(self) -> None:
+        key = b'12345'
+        data = b'This is a wonderful text string to cypher.'
+        encrypted = b'\x04]Q\x11\x0cw\x7fO\xfa\x03\xa3\xdf\xb6\x02\xb7d\x9f\x13U\x19\xc9-j\x96\x15yl\x98\xee_<\xfa\x9b\x8f\xbe}\xf4\x05l5\x0e\xd6'
+        proto = EAmuseProtocol()
+
+        cyphertext = proto._EAmuseProtocol__rc4_crypt(data, key)
+        self.assertEqual(encrypted, cyphertext)
+
+        plaintext = proto._EAmuseProtocol__rc4_crypt(cyphertext, key)
+        self.assertEqual(data, plaintext)
+
+    def test_small_data_random(self) -> None:
+        data = bytes([random.randint(0, 255) for _ in range(1 * 1024)])
+        key = bytes([random.randint(0, 255) for _ in range(16)])
+        proto = EAmuseProtocol()
+
+        cyphertext = proto._EAmuseProtocol__rc4_crypt(data, key)
+        self.assertNotEqual(data, cyphertext)
+
+        plaintext = proto._EAmuseProtocol__rc4_crypt(cyphertext, key)
+        self.assertEqual(data, plaintext)
+
+    def test_large_data_random(self) -> None:
+        data = bytes([random.randint(0, 255) for _ in range(100 * 1024)])
+        key = bytes([random.randint(0, 255) for _ in range(16)])
+        proto = EAmuseProtocol()
+
+        cyphertext = proto._EAmuseProtocol__rc4_crypt(data, key)
+        self.assertNotEqual(data, cyphertext)
+
+        plaintext = proto._EAmuseProtocol__rc4_crypt(cyphertext, key)
+        self.assertEqual(data, plaintext)
diff --git a/bemani/tests/test_RemoteUser.py b/bemani/tests/test_RemoteUser.py
new file mode 100644
index 0000000..d7ca307
--- /dev/null
+++ b/bemani/tests/test_RemoteUser.py
@@ -0,0 +1,22 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.data.remoteuser import RemoteUser
+from bemani.data.types import UserID
+
+
+class TestRemoteUser(unittest.TestCase):
+
+    def test_id_mangling(self) -> None:
+        card = "E0040100DEADBEEF"
+        userid = RemoteUser.card_to_userid(card)
+        self.assertTrue(userid > (2**32 - 1))
+        newcard = RemoteUser.userid_to_card(userid)
+        self.assertEqual(card, newcard)
+
+    def test_is_remote(self) -> None:
+        self.assertTrue(RemoteUser.is_remote(UserID(2**64 - 1)))
+        self.assertTrue(RemoteUser.is_remote(UserID(2**32)))
+        self.assertFalse(RemoteUser.is_remote(UserID(2**32 - 1)))
+        self.assertFalse(RemoteUser.is_remote(UserID(0)))
+        self.assertFalse(RemoteUser.is_remote(UserID(1)))
diff --git a/bemani/tests/test_Time.py b/bemani/tests/test_Time.py
new file mode 100644
index 0000000..6e228ea
--- /dev/null
+++ b/bemani/tests/test_Time.py
@@ -0,0 +1,41 @@
+# vim: set fileencoding=utf-8
+import unittest
+from freezegun import freeze_time
+
+from bemani.common.time import Time
+
+
+class TestTime(unittest.TestCase):
+
+    def test_days_since_epoch(self) -> None:
+        # Verify that we just get the right number of days.
+        with freeze_time('2016-01-01'):
+            self.assertEqual(16797, Time.week_in_days_since_epoch())
+
+        # Verify that adding a day doesn't change the value, because it rounds to nearest week.
+        with freeze_time('2016-01-02'):
+            self.assertEqual(16797, Time.week_in_days_since_epoch())
+
+        # Verify that adding a week makes the value go up by 7 days.
+        with freeze_time('2016-01-08'):
+            self.assertEqual(16804, Time.week_in_days_since_epoch())
+
+    def test_end_of_this_week(self) -> None:
+        # Verify that we can detect the end of the month properly
+        with freeze_time('2017-10-16'):
+            self.assertEqual(1508716800, Time.end_of_this_week())
+
+    def test_beginning_of_this_week(self) -> None:
+        # Verify that we can detect the end of the month properly
+        with freeze_time('2017-10-16'):
+            self.assertEqual(1508112000, Time.beginning_of_this_week())
+
+    def test_end_of_this_month(self) -> None:
+        # Verify that we can detect the end of the month properly
+        with freeze_time('2017-10-16'):
+            self.assertEqual(1509494400, Time.end_of_this_month())
+
+    def test_beginning_of_this_month(self) -> None:
+        # Verify that we can detect the end of the month properly
+        with freeze_time('2017-10-16'):
+            self.assertEqual(1506816000, Time.beginning_of_this_month())
diff --git a/bemani/tests/test_ValidatedDict.py b/bemani/tests/test_ValidatedDict.py
new file mode 100644
index 0000000..c806960
--- /dev/null
+++ b/bemani/tests/test_ValidatedDict.py
@@ -0,0 +1,256 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.common import ValidatedDict, intish
+
+
+class TestIntish(unittest.TestCase):
+
+    def test_none(self) -> None:
+        self.assertEqual(intish(None), None)
+
+    def test_int(self) -> None:
+        self.assertEqual(intish('3'), 3)
+
+    def test_str(self) -> None:
+        self.assertEqual(intish('str'), None)
+
+
+class TestValidatedDict(unittest.TestCase):
+
+    def test_empty_dict(self) -> None:
+        # Empty dictionary gets
+        validict = ValidatedDict()
+
+        self.assertEqual(validict.get_int('int'), 0)
+        self.assertEqual(validict.get_int('int', 2), 2)
+        self.assertEqual(validict.get_float('float'), 0.0)
+        self.assertEqual(validict.get_float('float', 2.0), 2.0)
+        self.assertEqual(validict.get_bool('bool'), False)
+        self.assertEqual(validict.get_bool('bool', True), True)
+        self.assertEqual(validict.get_str('str'), '')
+        self.assertEqual(validict.get_str('str', 'test'), 'test')
+        self.assertEqual(validict.get_bytes('bytes'), b'')
+        self.assertEqual(validict.get_bytes('bytes', b'test'), b'test')
+        self.assertEqual(validict.get_int_array('int_array', 3), [0, 0, 0])
+        self.assertEqual(validict.get_int_array('int_array', 3, [1, 2, 3]), [1, 2, 3])
+        self.assertEqual(validict.get_bool_array('bool_array', 2), [False, False])
+        self.assertEqual(validict.get_bool_array('bool_array', 2, [False, True]), [False, True])
+        self.assertEqual(validict.get_str_array('str_array', 3), ['', '', ''])
+        self.assertEqual(validict.get_str_array('str_array', 3, ['1', '2', '3']), ['1', '2', '3'])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'', b'', b''])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3, [b'1', b'2', b'3']), [b'1', b'2', b'3'])
+        self.assertTrue(isinstance(validict.get_dict('dict'), dict))
+        self.assertEqual(validict.get_dict('dict').get_int('test'), 0)
+
+    def test_normal_dict(self) -> None:
+        # Existing info gets
+        validict = ValidatedDict({
+            'int': 5,
+            'float': 5.5,
+            'bool': True,
+            'str': 'foobar',
+            'bytes': b'foobar',
+            'int_array': [3, 2, 1],
+            'bool_array': [True, False],
+            'str_array': ['3', '4', '5'],
+            'bytes_array': [b'3', b'5', b'7'],
+            'dict': {'test': 123},
+        })
+        self.assertEqual(validict.get_int('int'), 5)
+        self.assertEqual(validict.get_int('int', 2), 5)
+        self.assertEqual(validict.get_float('float'), 5.5)
+        self.assertEqual(validict.get_float('float', 2.0), 5.5)
+        self.assertEqual(validict.get_bool('bool'), True)
+        self.assertEqual(validict.get_bool('bool', False), True)
+        self.assertEqual(validict.get_str('str'), 'foobar')
+        self.assertEqual(validict.get_str('str', 'test'), 'foobar')
+        self.assertEqual(validict.get_bytes('bytes'), b'foobar')
+        self.assertEqual(validict.get_bytes('bytes', b'test'), b'foobar')
+        self.assertEqual(validict.get_int_array('int_array', 3), [3, 2, 1])
+        self.assertEqual(validict.get_int_array('int_array', 3, [1, 2, 3]), [3, 2, 1])
+        self.assertEqual(validict.get_bool_array('bool_array', 2), [True, False])
+        self.assertEqual(validict.get_bool_array('bool_array', 2, [False, True]), [True, False])
+        self.assertEqual(validict.get_str_array('str_array', 3), ['3', '4', '5'])
+        self.assertEqual(validict.get_str_array('str_array', 3, ['1', '2', '3']), ['3', '4', '5'])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'3', b'5', b'7'])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3, [b'1', b'2', b'3']), [b'3', b'5', b'7'])
+        self.assertTrue(isinstance(validict.get_dict('dict'), dict))
+        self.assertEqual(validict.get_dict('dict').get_int('test'), 123)
+
+    def test_default_on_invalid(self) -> None:
+        # Default on invalid info stored
+        validict = ValidatedDict({
+            'int': 'five',
+            'float': 'five',
+            'bool': 'true',
+            'str': 123,
+            'bytes': 'str',
+            'int_array': [3, 2, 1, 0],
+            'bool_array': [True, False],
+            'str_array': ['3', '2', '1', '0'],
+            'bytes_array': [b'3', b'2', b'1', b'0'],
+            'dict': 'not_a_dict',
+        })
+        self.assertEqual(validict.get_int('int'), 0)
+        self.assertEqual(validict.get_int('int', 2), 2)
+        self.assertEqual(validict.get_float('float'), 0.0)
+        self.assertEqual(validict.get_float('float', 2.0), 2.0)
+        self.assertEqual(validict.get_bool('bool'), False)
+        self.assertEqual(validict.get_bool('bool', True), True)
+        self.assertEqual(validict.get_str('str'), '')
+        self.assertEqual(validict.get_str('str', 'test'), 'test')
+        self.assertEqual(validict.get_bytes('bytes'), b'')
+        self.assertEqual(validict.get_bytes('bytes', b'test'), b'test')
+        self.assertEqual(validict.get_int_array('int_array', 3), [0, 0, 0])
+        self.assertEqual(validict.get_int_array('int_array', 3, [1, 2, 3]), [1, 2, 3])
+        self.assertEqual(validict.get_bool_array('bool_array', 3), [False, False, False])
+        self.assertEqual(validict.get_bool_array('bool_array', 3, [False, True, True]), [False, True, True])
+        self.assertEqual(validict.get_str_array('str_array', 3), ['', '', ''])
+        self.assertEqual(validict.get_str_array('str_array', 3, ['1', '2', '3']), ['1', '2', '3'])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'', b'', b''])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3, [b'1', b'2', b'3']), [b'1', b'2', b'3'])
+        self.assertTrue(isinstance(validict.get_dict('dict'), dict))
+        self.assertEqual(validict.get_dict('dict').get_int('test'), 0)
+
+    def test_replace_int(self) -> None:
+        # Verify replace int
+        validict = ValidatedDict({
+            'int': 5,
+        })
+        validict.replace_int('int', 3)
+        self.assertEqual(validict.get_int('int'), 3)
+        validict.replace_int('int', None)
+        self.assertEqual(validict.get_int('int'), 3)
+        validict.replace_int('int', 'three')
+        self.assertEqual(validict.get_int('int'), 3)
+
+    def test_replace_float(self) -> None:
+        # Verify replace float
+        validict = ValidatedDict({
+            'float': 5.0,
+        })
+        validict.replace_float('float', 3.0)
+        self.assertEqual(validict.get_float('float'), 3.0)
+        validict.replace_float('float', None)
+        self.assertEqual(validict.get_float('float'), 3.0)
+        validict.replace_float('float', 'three')
+        self.assertEqual(validict.get_float('float'), 3.0)
+
+    def test_replace_bool(self) -> None:
+        # Verify replace bool
+        validict = ValidatedDict({
+            'bool': False,
+        })
+        validict.replace_bool('bool', True)
+        self.assertEqual(validict.get_bool('bool'), True)
+        validict.replace_bool('bool', None)
+        self.assertEqual(validict.get_bool('bool'), True)
+        validict.replace_bool('bool', 'three')
+        self.assertEqual(validict.get_bool('bool'), True)
+
+    def test_replace_str(self) -> None:
+        # Verify replace str
+        validict = ValidatedDict({
+            'str': 'blah',
+        })
+        validict.replace_str('str', 'foobar')
+        self.assertEqual(validict.get_str('str'), 'foobar')
+        validict.replace_str('str', None)
+        self.assertEqual(validict.get_str('str'), 'foobar')
+        validict.replace_str('str', 5)
+        self.assertEqual(validict.get_str('str'), 'foobar')
+
+    def test_replace_bytes(self) -> None:
+        # Verify replace bytes
+        validict = ValidatedDict({
+            'bytes': 'blah',
+        })
+        validict.replace_bytes('bytes', b'foobar')
+        self.assertEqual(validict.get_bytes('bytes'), b'foobar')
+        validict.replace_bytes('bytes', None)
+        self.assertEqual(validict.get_bytes('bytes'), b'foobar')
+        validict.replace_bytes('bytes', 5)
+        self.assertEqual(validict.get_bytes('bytes'), b'foobar')
+
+    def test_replace_int_array(self) -> None:
+        # Verify replace int_array
+        validict = ValidatedDict({
+            'int_array': [1, 2, 3]
+        })
+        validict.replace_int_array('int_array', 3, [3, 2, 1])
+        self.assertEqual(validict.get_int_array('int_array', 3), [3, 2, 1])
+        validict.replace_int_array('int_array', 3, None)
+        self.assertEqual(validict.get_int_array('int_array', 3), [3, 2, 1])
+        validict.replace_int_array('int_array', 3, 'bla')
+        self.assertEqual(validict.get_int_array('int_array', 3), [3, 2, 1])
+        validict.replace_int_array('int_array', 3, [3, 2, 1, 0])
+        self.assertEqual(validict.get_int_array('int_array', 3), [3, 2, 1])
+
+    def test_replace_bool_array(self) -> None:
+        # Verify replace bool_array
+        validict = ValidatedDict({
+            'bool_array': [False, True],
+        })
+        validict.replace_bool_array('bool_array', 2, [True, False])
+        self.assertEqual(validict.get_bool_array('bool_array', 2), [True, False])
+        validict.replace_bool_array('bool_array', 2, None)
+        self.assertEqual(validict.get_bool_array('bool_array', 2), [True, False])
+        validict.replace_bool_array('bool_array', 2, 'bla')
+        self.assertEqual(validict.get_bool_array('bool_array', 2), [True, False])
+        validict.replace_bool_array('bool_array', 2, [True, True, True])
+        self.assertEqual(validict.get_bool_array('bool_array', 2), [True, False])
+
+    def test_replace_str_array(self) -> None:
+        # Verify replace str_array
+        validict = ValidatedDict({
+            'str_array': ['1', '2', '3']
+        })
+        validict.replace_str_array('str_array', 3, ['3', '2', '1'])
+        self.assertEqual(validict.get_str_array('str_array', 3), ['3', '2', '1'])
+        validict.replace_str_array('str_array', 3, None)
+        self.assertEqual(validict.get_str_array('str_array', 3), ['3', '2', '1'])
+        validict.replace_str_array('str_array', 3, 'bla')
+        self.assertEqual(validict.get_str_array('str_array', 3), ['3', '2', '1'])
+        validict.replace_str_array('str_array', 3, ['3', '2', '1', '0'])
+        self.assertEqual(validict.get_str_array('str_array', 3), ['3', '2', '1'])
+
+    def test_replace_bytes_array(self) -> None:
+        # Verify replace bytes_array
+        validict = ValidatedDict({
+            'bytes_array': [b'1', b'2', b'3']
+        })
+        validict.replace_bytes_array('bytes_array', 3, [b'3', b'2', b'1'])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'3', b'2', b'1'])
+        validict.replace_bytes_array('bytes_array', 3, None)
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'3', b'2', b'1'])
+        validict.replace_bytes_array('bytes_array', 3, 'bla')
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'3', b'2', b'1'])
+        validict.replace_bytes_array('bytes_array', 3, [b'3', b'2', b'1', b'0'])
+        self.assertEqual(validict.get_bytes_array('bytes_array', 3), [b'3', b'2', b'1'])
+
+    def test_replace_dict(self) -> None:
+        # Verify replace dict
+        validict = ValidatedDict({
+            'dict': {},
+        })
+        validict.replace_dict('dict', {'yay': 'bla'})
+        self.assertTrue(isinstance(validict.get_dict('dict'), dict))
+        self.assertEqual(validict.get_dict('dict').get_str('yay'), 'bla')
+        validict.replace_dict('dict', None)
+        self.assertEqual(validict.get_dict('dict').get_str('yay'), 'bla')
+        validict.replace_dict('dict', 'three')
+        self.assertEqual(validict.get_dict('dict').get_str('yay'), 'bla')
+
+    def test_increment_int(self) -> None:
+        # Verify increment_int
+        validict = ValidatedDict({
+            'int': 5,
+            'int2': 'str',
+        })
+        validict.increment_int('int')
+        self.assertEqual(validict.get_int('int'), 6)
+        validict.increment_int('int2')
+        self.assertEqual(validict.get_int('int2'), 1)
+        validict.increment_int('int3')
+        self.assertEqual(validict.get_int('int3'), 1)
diff --git a/bemani/tests/test_XmlDecoder.py b/bemani/tests/test_XmlDecoder.py
new file mode 100644
index 0000000..1fdab5c
--- /dev/null
+++ b/bemani/tests/test_XmlDecoder.py
@@ -0,0 +1,114 @@
+# vim: set fileencoding=utf-8
+import unittest
+
+from bemani.protocol.xml import XmlDecoder
+
+
+class TestXmlDecoder(unittest.TestCase):
+
+    def test_detect_encoding(self) -> None:
+        xml = XmlDecoder(b'<?xml version="1.0" encoding="utf-8"?>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(xml.encoding, 'utf-8')
+        self.assertEqual(tree, None)
+
+        xml = XmlDecoder(b'<?xml\nversion = "1.0"\tencoding   =   "utf-8"?>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(xml.encoding, 'utf-8')
+        self.assertEqual(tree, None)
+
+    def test_decode_void(self) -> None:
+        xml = XmlDecoder(b'<node></node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'void')
+        self.assertEqual(tree.value, None)
+
+        xml = XmlDecoder(b'<node />', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'void')
+        self.assertEqual(tree.value, None)
+
+    def test_decode_attributes(self) -> None:
+        xml = XmlDecoder(b'<node attr1="foo" attr2="bar"></node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {'attr1': 'foo', 'attr2': 'bar'})
+        self.assertEqual(tree.data_type, 'void')
+        self.assertEqual(tree.value, None)
+
+        xml = XmlDecoder(b'<node attr1="foo" attr2="bar" />', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {'attr1': 'foo', 'attr2': 'bar'})
+        self.assertEqual(tree.data_type, 'void')
+        self.assertEqual(tree.value, None)
+
+        xml = XmlDecoder(b'<node\nattr1="foo"\tattr2="bar"/>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {'attr1': 'foo', 'attr2': 'bar'})
+        self.assertEqual(tree.data_type, 'void')
+        self.assertEqual(tree.value, None)
+
+    def test_decode_bin(self) -> None:
+        xml = XmlDecoder(b'<node __type="bin">DEADBEEF</node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'bin')
+        self.assertEqual(tree.value, b'\xDE\xAD\xBE\xEF')
+
+        xml = XmlDecoder(b'<node __type="bin">\nDEADBEEF\n</node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'bin')
+        self.assertEqual(tree.value, b'\xDE\xAD\xBE\xEF')
+
+        xml = XmlDecoder(b'<node __type="bin"> D E A D B E E F </node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'bin')
+        self.assertEqual(tree.value, b'\xDE\xAD\xBE\xEF')
+
+    def test_decode_array(self) -> None:
+        xml = XmlDecoder(b'<node __type="u32" __count="4">1 2 3 4</node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'u32')
+        self.assertEqual(tree.value, [1, 2, 3, 4])
+
+        xml = XmlDecoder(b'<node __type="u32" __count="4">\n1\n2\n3\n4\n</node>', 'ascii')
+        tree = xml.get_tree()
+
+        self.assertEqual(tree.children, [])
+        self.assertEqual(tree.name, 'node')
+        self.assertEqual(tree.attributes, {})
+        self.assertEqual(tree.data_type, 'u32')
+        self.assertEqual(tree.value, [1, 2, 3, 4])
diff --git a/bemani/tests/test_lz77.py b/bemani/tests/test_lz77.py
new file mode 100644
index 0000000..366be95
--- /dev/null
+++ b/bemani/tests/test_lz77.py
@@ -0,0 +1,89 @@
+# vim: set fileencoding=utf-8
+import os
+import random
+import unittest
+
+from bemani.protocol.lz77 import Lz77, Lz77Decompress
+
+
+class TestLZ77Decompressor(unittest.TestCase):
+    def test_ringbuffer_fuzz(self) -> None:
+        dec = Lz77Decompress(b'')
+
+        for _ in range(100):
+            amount = random.randint(1, Lz77Decompress.RING_LENGTH)
+            data = bytes([random.randint(0, 255) for _ in range(amount)])
+
+            # Save our ring position, write a chunk of data
+            readpos = dec.write_pos
+            dec._Lz77Decompress__ring_write(data)
+
+            # Read a chunk of data back from that buffer, see its the same
+            newdata = b''.join(dec._Lz77Decompress__ring_read(readpos, amount))
+            self.assertEqual(data, newdata)
+
+            # Verify integrity of ringbuffer
+            self.assertEqual(len(dec.ring), Lz77Decompress.RING_LENGTH)
+
+
+def get_fixture(name: str) -> bytes:
+    location = os.path.dirname(os.path.abspath(__file__))
+    with open(os.path.join(location, name), "rb") as fp:
+        return fp.read()
+
+
+class TestLz77RealCompressor(unittest.TestCase):
+    def test_small_data_random(self) -> None:
+        lz77 = Lz77()
+        data = bytes([random.randint(0, 255) for _ in range(1 * 1024)])
+
+        compresseddata = lz77.compress(data)
+        self.assertNotEqual(data, compresseddata)
+
+        decompresseddata = lz77.decompress(compresseddata)
+        self.assertEqual(data, decompresseddata)
+
+    def test_large_data_random(self) -> None:
+        lz77 = Lz77()
+        data = bytes([random.randint(0, 255) for _ in range(100 * 1024)])
+
+        compresseddata = lz77.compress(data)
+        self.assertNotEqual(data, compresseddata)
+
+        decompresseddata = lz77.decompress(compresseddata)
+        self.assertEqual(data, decompresseddata)
+
+    def test_declaration(self) -> None:
+        lz77 = Lz77()
+        data = get_fixture("declaration.txt")
+
+        compresseddata = lz77.compress(data)
+        self.assertNotEqual(data, compresseddata)
+        self.assertTrue(len(compresseddata) < len(data))
+
+        decompresseddata = lz77.decompress(compresseddata)
+        self.assertEqual(data, decompresseddata)
+
+    def test_lorem_ipsum(self) -> None:
+        lz77 = Lz77()
+        data = get_fixture("lorem.txt")
+
+        compresseddata = lz77.compress(data)
+        self.assertNotEqual(data, compresseddata)
+        self.assertTrue(len(compresseddata) < len(data))
+
+        decompresseddata = lz77.decompress(compresseddata)
+        self.assertEqual(data, decompresseddata)
+
+    def test_known_compression(self) -> None:
+        """
+        Specifically tests for ability to compress an overlap,
+        verifies that we don't regress on known compressions.
+        """
+        lz77 = Lz77()
+        data = b"abcabcabcabc"
+        compresseddata = lz77.compress(data)
+        self.assertEqual(b"\x07abc\x006\x00\x00", compresseddata)
+
+        decompresseddata = lz77.decompress(compresseddata)
+        self.assertEqual(data, decompresseddata)
diff --git a/bemani/tests/test_protocol.py b/bemani/tests/test_protocol.py
new file mode 100644
index 0000000..69cc022
--- /dev/null
+++ b/bemani/tests/test_protocol.py
@@ -0,0 +1,376 @@
+# vim: set fileencoding=utf-8
+import unittest
+from typing import Optional
+
+from bemani.protocol import EAmuseProtocol, Node
+
+
+class TestProtocol(unittest.TestCase):
+
+    # Define a function that just encrypts/decrypts and encode/decodes, verify
+    # that we can get the same thing back.
+    def assertLoopback(self, root: Node) -> Optional[int]:
+        proto = EAmuseProtocol()
+
+        for encoding in [EAmuseProtocol.BINARY, EAmuseProtocol.XML]:
+            if encoding == EAmuseProtocol.BINARY:
+                loop_name = "binary"
+            elif encoding == EAmuseProtocol.XML:
+                loop_name = "xml"
+            else:
+                raise Exception("Logic error!")
+
+            binary = proto.encode(None, None, root, text_encoding=EAmuseProtocol.SHIFT_JIS, packet_encoding=encoding)
+            newroot = proto.decode(None, None, binary)
+            self.assertEqual(newroot, root, "Round trip with {} and no encryption/compression doesn't match!".format(loop_name))
+
+            binary = proto.encode(None, '1-abcdef-0123', root, text_encoding=EAmuseProtocol.SHIFT_JIS, packet_encoding=encoding)
+            newroot = proto.decode(None, '1-abcdef-0123', binary)
+            self.assertEqual(newroot, root, "Round trip with {}, encryption and no compression doesn't match!".format(loop_name))
+
+            binary = proto.encode('none', None, root, text_encoding=EAmuseProtocol.SHIFT_JIS, packet_encoding=encoding)
+            newroot = proto.decode('none', None, binary)
+            self.assertEqual(newroot, root, "Round trip with {}, encryption and no compression doesn't match!".format(loop_name))
+
+            binary = proto.encode('lz77', None, root, text_encoding=EAmuseProtocol.SHIFT_JIS, packet_encoding=encoding)
+            newroot = proto.decode('lz77', None, binary)
+            self.assertEqual(newroot, root, "Round trip with {}, no encryption and lz77 compression doesn't match!".format(loop_name))
+
+    def test_game_packet1(self) -> Node:
+        root = Node.void('call')
+        root.set_attribute('model', 'M39:J:B:A:2014061900')
+        root.set_attribute('srcid', '012010000000DEADBEEF')
+        root.set_attribute('tag', '1d0cbcd5')
+
+        pcbevent = Node.void('pcbevent')
+        root.add_child(pcbevent)
+        pcbevent.set_attribute('method', 'put')
+
+        pcbevent.add_child(Node.time('time', 1438375918))
+        pcbevent.add_child(Node.u32('seq', value=0))
+
+        item = Node.void('item')
+        pcbevent.add_child(item)
+
+        item.add_child(Node.string('name', 'boot'))
+        item.add_child(Node.s32('value', 1))
+        item.add_child(Node.time('time', 1438375959))
+
+        self.assertLoopback(root)
+
+    def test_game_packet2(self) -> Node:
+        root = Node.void('call')
+        root.set_attribute('model', 'LDJ:A:A:A:2015060700')
+        root.set_attribute('srcid', '012010000000DEADBEEF')
+        root.set_attribute('tag', '9yU+HH4q')
+
+        eacoin = Node.void('eacoin')
+        root.add_child(eacoin)
+        eacoin.set_attribute('esdate', '2015-08-01T02:09:23')
+        eacoin.set_attribute('esid', '177baae4bdf0085f1f3da9b6fed02223ee9b482f62b83a28af704a9c7893a370')
+        eacoin.set_attribute('method', 'consume')
+
+        eacoin.add_child(Node.string('sessid', '5666-5524'))
+        eacoin.add_child(Node.s16('sequence', 0))
+        eacoin.add_child(Node.s32('payment', 420))
+        eacoin.add_child(Node.s32('service', 0))
+        eacoin.add_child(Node.string('itemtype', '0'))
+        eacoin.add_child(Node.string('detail', '/eacoin/premium_free_1p_3'))
+
+        self.assertLoopback(root)
+
+    def test_game_packet3(self) -> Node:
+        root = Node.void('response')
+        root.add_child(Node.void('music'))
+
+        self.assertLoopback(root)
+
+    def test_game_packet4(self) -> Node:
+        root = Node.void('response')
+        game = Node.void('game')
+        root.add_child(game)
+        game.set_attribute('image_no', '1')
+        game.set_attribute('no', '1')
+
+        game.add_child(Node.s32('ir_phase', 0))
+
+        game.add_child(Node.s32('personal_event_phase', 10))
+        game.add_child(Node.s32('shop_event_phase', 6))
+        game.add_child(Node.s32('netvs_phase', 0))
+        game.add_child(Node.s32('card_phase', 9))
+        game.add_child(Node.s32('other_phase', 9))
+        game.add_child(Node.s32('music_open_phase', 8))
+        game.add_child(Node.s32('collabo_phase', 8))
+        game.add_child(Node.s32('local_matching_enable', 1))
+        game.add_child(Node.s32('n_maching_sec', 60))
+        game.add_child(Node.s32('l_matching_sec', 60))
+        game.add_child(Node.s32('is_check_cpu', 0))
+        game.add_child(Node.s32('week_no', 0))
+        game.add_child(Node.s16_array('sel_ranking', [-1, -1, -1, -1, -1]))
+        game.add_child(Node.s16_array('up_ranking', [-1, -1, -1, -1, -1]))
+
+        self.assertLoopback(root)
+
+    def test_game_packet5(self) -> Node:
+        root = Node.void('call')
+        root.set_attribute('model', 'LDJ:A:A:A:2015060700')
+        root.set_attribute('srcid', '012010000000DEADBEEF')
+        root.set_attribute('tag', '9yU+HH4q')
+
+        iidx22pc = Node.void('IIDX22pc')
+        root.add_child(iidx22pc)
+        iidx22pc.set_attribute('bookkeep', '0')
+        iidx22pc.set_attribute('cltype', '0')
+        iidx22pc.set_attribute('d_achi', '0')
+        iidx22pc.set_attribute('d_disp_judge', '0')
+        iidx22pc.set_attribute('d_exscore', '0')
+        iidx22pc.set_attribute('d_gno', '0')
+        iidx22pc.set_attribute('d_gtype', '0')
+        iidx22pc.set_attribute('d_hispeed', '0.000000')
+        iidx22pc.set_attribute('d_judge', '0')
+        iidx22pc.set_attribute('d_judgeAdj', '-3')
+        iidx22pc.set_attribute('d_largejudge', '0')
+        iidx22pc.set_attribute('d_lift', '0')
+        iidx22pc.set_attribute('d_notes', '0.000000')
+        iidx22pc.set_attribute('d_opstyle', '0')
+        iidx22pc.set_attribute('d_pace', '0')
+        iidx22pc.set_attribute('d_sdlen', '0')
+        iidx22pc.set_attribute('d_sdtype', '0')
+        iidx22pc.set_attribute('d_sorttype', '0')
+        iidx22pc.set_attribute('d_timing', '0')
+        iidx22pc.set_attribute('d_tune', '0')
+        iidx22pc.set_attribute('dp_opt', '0')
+        iidx22pc.set_attribute('dp_opt2', '0')
+        iidx22pc.set_attribute('gpos', '0')
+        iidx22pc.set_attribute('iidxid', '56665524')
+        iidx22pc.set_attribute('lid', 'US-3')
+        iidx22pc.set_attribute('method', 'save')
+        iidx22pc.set_attribute('mode', '6')
+        iidx22pc.set_attribute('pmode', '0')
+        iidx22pc.set_attribute('rtype', '0')
+        iidx22pc.set_attribute('s_achi', '4428')
+        iidx22pc.set_attribute('s_disp_judge', '1')
+        iidx22pc.set_attribute('s_exscore', '0')
+        iidx22pc.set_attribute('s_gno', '1')
+        iidx22pc.set_attribute('s_gtype', '2')
+        iidx22pc.set_attribute('s_hispeed', '2.302647')
+        iidx22pc.set_attribute('s_judge', '0')
+        iidx22pc.set_attribute('s_judgeAdj', '-3')
+        iidx22pc.set_attribute('s_largejudge', '0')
+        iidx22pc.set_attribute('s_lift', '60')
+        iidx22pc.set_attribute('s_notes', '29.483595')
+        iidx22pc.set_attribute('s_opstyle', '1')
+        iidx22pc.set_attribute('s_pace', '0')
+        iidx22pc.set_attribute('s_sdlen', '203')
+        iidx22pc.set_attribute('s_sdtype', '1')
+        iidx22pc.set_attribute('s_sorttype', '0')
+        iidx22pc.set_attribute('s_timing', '2')
+        iidx22pc.set_attribute('s_tune', '5')
+        iidx22pc.set_attribute('sp_opt', '8194')
+
+        pyramid = Node.void('pyramid')
+        pyramid.set_attribute('point', '408')
+        iidx22pc.add_child(pyramid)
+
+        achievements = Node.void('achievements')
+        iidx22pc.add_child(achievements)
+        achievements.set_attribute('last_weekly', '0')
+        achievements.set_attribute('pack_comp', '0')
+        achievements.set_attribute('pack_flg', '0')
+        achievements.set_attribute('pack_id', '349')
+        achievements.set_attribute('play_pack', '0')
+        achievements.set_attribute('visit_flg', '1125899906842624')
+        achievements.set_attribute('weekly_num', '0')
+
+        achievements.add_child(Node.s64_array('trophy', [
+            648333697107365824,
+            120628451491823,
+            281475567654912,
+            0,
+            1069547520,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            1125899906842624,
+            4294967296,
+            60348585478096,
+            1498943592322,
+            0,
+            256,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            -4294967296,
+            0,
+            0,
+            4294967704,
+            858608469,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            5,
+            2,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]))
+
+        deller = Node.void('deller')
+        iidx22pc.add_child(deller)
+        deller.set_attribute('deller', '450')
+
+        self.assertLoopback(root)
+
+    def test_game_packet6(self) -> Node:
+        root = Node.void('response')
+        facility = Node.void('facility')
+        root.add_child(facility)
+
+        location = Node.void('location')
+        facility.add_child(location)
+
+        location.add_child(Node.string('id', 'US-6'))
+        location.add_child(Node.string('country', 'US'))
+        location.add_child(Node.string('region', '.'))
+        location.add_child(Node.string('name', ''))
+        location.add_child(Node.u8('type', 0))
+
+        line = Node.void('line')
+        facility.add_child(line)
+
+        line.add_child(Node.string('id', '.'))
+        line.add_child(Node.u8('class', 0))
+
+        portfw = Node.void('portfw')
+        facility.add_child(portfw)
+
+        portfw.add_child(Node.ipv4('globalip', '10.0.0.1'))
+        portfw.add_child(Node.u16('globalport', 20000))
+        portfw.add_child(Node.u16('privateport', 20000))
+
+        public = Node.void('public')
+        facility.add_child(public)
+
+        public.add_child(Node.u8('flag', 1))
+        public.add_child(Node.string('name', '.'))
+        public.add_child(Node.string('latitude', '0'))
+        public.add_child(Node.string('longitude', '0'))
+
+        share = Node.void('share')
+        facility.add_child(share)
+
+        eacoin = Node.void('eacoin')
+        share.add_child(eacoin)
+
+        eacoin.add_child(Node.s32('notchamount', 0))
+        eacoin.add_child(Node.s32('notchcount', 0))
+        eacoin.add_child(Node.s32('supplylimit', 1000000))
+
+        url = Node.void('url')
+        share.add_child(url)
+
+        url.add_child(Node.string('eapass', 'http://some.dummy.net/'))
+        url.add_child(Node.string('arcadefan', 'http://some.dummy.net/'))
+        url.add_child(Node.string('konaminetdx', 'http://some.dummy.net/'))
+        url.add_child(Node.string('konamiid', 'http://some.dummy.net/'))
+        url.add_child(Node.string('eagate', 'http://some.dummy.net/'))
+
+        self.assertLoopback(root)
+
+    def test_packet1(self) -> Node:
+        root = Node.void('test')
+        root.set_attribute('test', 'test string value')
+
+        # Regular nodes
+        root.add_child(Node.void('void_node'))
+        root.add_child(Node.s8('s8_node', -1))
+        root.add_child(Node.u8('u8_node', 245))
+        root.add_child(Node.s16('s16_node', -8000))
+        root.add_child(Node.u16('u16_node', 65000))
+        root.add_child(Node.s32('s32_node', -2000000000))
+        root.add_child(Node.u32('u32_node', 4000000000))
+        root.add_child(Node.s64('s64_node', -1234567890000))
+        root.add_child(Node.u64('u64_node', 1234567890000))
+        root.add_child(Node.binary('bin_node', b'DEADBEEF'))
+        root.add_child(Node.string('str_node', 'this is a string!'))
+        root.add_child(Node.ipv4('ip4_node', '192.168.1.24'))
+        root.add_child(Node.time('time_node', 1234567890))
+        root.add_child(Node.float('float_node', 2.5))
+        root.add_child(Node.fouru8('4u8_node', [0x20, 0x21, 0x22, 0x23]))
+        root.add_child(Node.bool('bool_true_node', True))
+        root.add_child(Node.bool('bool_false_node', False))
+
+        # Array nodes
+        root.add_child(Node.s8_array('s8_array_node', [-1, -2, 3, 4, -5]))
+        root.add_child(Node.u8_array('u8_array_node', [245, 2, 0, 255, 1]))
+        root.add_child(Node.s16_array('s16_array_node', [-8000, 8000]))
+        root.add_child(Node.u16_array('u16_array_node', [65000, 1, 2, 65535]))
+        root.add_child(Node.s32_array('s32_array_node', [-2000000000, -1]))
+        root.add_child(Node.u32_array('u32_array_node', [4000000000, 0, 1, 2]))
+        root.add_child(Node.s64_array('s64_array_node', [-1234567890000, -1, 1, 1337]))
+        root.add_child(Node.u64_array('u64_array_node', [1234567890000, 123, 456, 7890]))
+        root.add_child(Node.time_array('time_array_node', [1234567890, 98765432]))
+        root.add_child(Node.float_array('float_array_node', [2.5, 0.0, 5.0, 20.5]))
+        root.add_child(Node.bool_array('bool_array_node', [False, True, True, False]))
+
+        # XML escaping
+        escape = Node.string('escape_test', '\r\n<testing> & \'thing\' "thing" \r\nthing on new line\r\n    ')
+        escape.set_attribute('test', '<testing> & \'thing\' "thing" \r\n thing')
+        root.add_child(escape)
+
+        # Unicode
+        unicode_node = Node.string('unicode', '今日は')
+        unicode_node.set_attribute('unicode_attr', 'わたし')
+        root.add_child(unicode_node)
+
+        self.assertLoopback(root)
diff --git a/bemani/utils/__init__.py b/bemani/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/bemani/utils/api.py b/bemani/utils/api.py
new file mode 100644
index 0000000..1fd8204
--- /dev/null
+++ b/bemani/utils/api.py
@@ -0,0 +1,34 @@
+import argparse
+import yaml  # type: ignore
+
+from bemani.data import Data
+from bemani.api import app, config  # noqa: F401
+
+
+def load_config(filename: str) -> None:
+    global config
+
+    config.update(yaml.safe_load(open(filename)))  # type: ignore
+    config['database']['engine'] = Data.create_engine(config)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="An API services provider for eAmusement games, conforming to BEMAPI specs.")
+    parser.add_argument("-p", "--port", help="Port to listen on. Defaults to 80", type=int, default=80)
+    parser.add_argument("-c", "--config", help="Core configuration. Defaults to server.yaml", type=str, default="server.yaml")
+    parser.add_argument("-r", "--profile", help="Turn on profiling for API", action="store_true")
+    args = parser.parse_args()
+
+    # Set up app
+    load_config(args.config)
+
+    if args.profile:
+        from werkzeug.contrib.profiler import ProfilerMiddleware  # type: ignore
+        app.wsgi_app = ProfilerMiddleware(app.wsgi_app, profile_dir='.')  # type: ignore
+
+    # Run the app
+    app.run(host='0.0.0.0', port=args.port, debug=True)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/arcutils.py b/bemani/utils/arcutils.py
new file mode 100644
index 0000000..a3ab0e8
--- /dev/null
+++ b/bemani/utils/arcutils.py
@@ -0,0 +1,51 @@
+import argparse
+import os
+
+from bemani.format import ARC
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to extract ARC files.")
+    parser.add_argument(
+        "file",
+        help="ARC file to extract.",
+        type=str,
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        help="Directory to extract to. Defaults to current directory.",
+        default="."
+    )
+    parser.add_argument(
+        "-l",
+        "--list-only",
+        action="store_true",
+        help="Print files but do not extract them.",
+    )
+    args = parser.parse_args()
+
+    root = args.directory
+    if root[-1] != '/':
+        root = root + '/'
+    root = os.path.realpath(root)
+
+    fp = open(args.file, 'rb')
+    data = fp.read()
+    fp.close()
+
+    arc = ARC(data)
+    for fn in arc.filenames:
+        if args.list_only:
+            print(fn)
+        else:
+            print('Extracting {} to disk...'.format(fn))
+            realfn = os.path.join(root, fn)
+            dirof = os.path.dirname(realfn)
+            os.makedirs(dirof, exist_ok=True)
+            with open(realfn, 'wb') as fp:
+                fp.write(arc.read_file(fn))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/bemanishark.py b/bemani/utils/bemanishark.py
new file mode 100644
index 0000000..682b08c
--- /dev/null
+++ b/bemani/utils/bemanishark.py
@@ -0,0 +1,95 @@
+from typing import Optional
+import argparse
+
+from bemani.sniff import Sniffer
+from bemani.protocol import EAmuseProtocol, EAmuseException
+from bemani.common import HTTP
+
+
+def mainloop(address: Optional[str]=None, port: int=80, verbose: bool=False) -> None:
+    """
+    Main loop of BEMANIShark. Starts an instance of Sniffer and EAmuseProtocol and does a
+    lazy job of banging them together with the above HTTP.parse. Will loop trying to decode
+    packets forever.
+
+    Arguments:
+        address - A string representing an IP of interest
+        port - An integer representing a port of interest
+    """
+    sniffer = Sniffer(address=address, port=port)
+    parser = EAmuseProtocol()
+
+    while True:
+        packets = sniffer.recv_stream()
+
+        inbound = HTTP.parse(packets['inbound'], request=True)
+        outbound = HTTP.parse(packets['outbound'], response=True)
+
+        if inbound is not None:
+            if inbound['data'] is None:
+                in_req = None
+            else:
+                try:
+                    in_req = parser.decode(
+                        inbound['headers'].get('x-compress'),
+                        inbound['headers'].get('x-eamuse-info'),
+                        inbound['data']
+                    )
+                except EAmuseException as e:
+                    in_req = None
+
+            print("Inbound request (from {}:{} to {}:{}):".format(
+                packets['source_address'],
+                packets['source_port'],
+                packets['destination_address'],
+                packets['destination_port'],
+            ))
+            if verbose:
+                print("HTTP {} request for URI {}".format(inbound['method'], inbound['uri']))
+                print("Compression is {}".format(inbound['headers'].get('x-compress', 'none')))
+                print("Encryption key is {}".format(inbound['headers'].get('x-eamuse-info', 'none')))
+            if in_req is None:
+                print("Inbound request was not parseable")
+            else:
+                print(in_req)
+
+        if outbound is not None:
+            if outbound['data'] is None:
+                out_req = None
+            else:
+                try:
+                    out_req = parser.decode(
+                        outbound['headers'].get('x-compress'),
+                        outbound['headers'].get('x-eamuse-info'),
+                        outbound['data']
+                    )
+                except EAmuseException as e:
+                    out_req = None
+
+            print("Outbound response (from {}:{} to {}:{}):".format(
+                packets['destination_address'],
+                packets['destination_port'],
+                packets['source_address'],
+                packets['source_port'],
+            ))
+            if verbose:
+                print("Compression is {}".format(outbound['headers'].get('x-compress', 'none')))
+                print("Encryption key is {}".format(outbound['headers'].get('x-eamuse-info', 'none')))
+            if out_req is None:
+                print("Outbound response was not parseable")
+            else:
+                print(out_req)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to sniff packets and decode them as eAmusement packets. Should probably be run as root.")
+    parser.add_argument("-p", "--port", help="Port to sniff on. Defaults to 80", type=int, default=80)
+    parser.add_argument("-a", "--address", help="Address to sniff on. Defaults to all addresses", type=str, default=None)
+    parser.add_argument("-v", "--verbose", help="Show extra packet information", action='store_true')
+    args = parser.parse_args()
+
+    mainloop(address=args.address, port=args.port, verbose=args.verbose)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/binutils.py b/bemani/utils/binutils.py
new file mode 100644
index 0000000..3d61c77
--- /dev/null
+++ b/bemani/utils/binutils.py
@@ -0,0 +1,26 @@
+import argparse
+import sys
+
+from bemani.protocol.binary import BinaryEncoding
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to convert binxml files to their XML representation.")
+    parser.add_argument("-i", "--infile", help="File containing an XML or binary node structure. Use - for stdin.", type=str, default=None, required=True)
+    args = parser.parse_args()
+
+    if args.infile == '-':
+        # Load from stdin
+        packet = sys.stdin.buffer.read()
+    else:
+        with open(args.infile, mode="rb") as myfile:
+            packet = myfile.read()
+            myfile.close()
+
+    benc = BinaryEncoding()
+    filexml = benc.decode(packet)
+    print(filexml)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/cardconvert.py b/bemani/utils/cardconvert.py
new file mode 100644
index 0000000..c30d392
--- /dev/null
+++ b/bemani/utils/cardconvert.py
@@ -0,0 +1,28 @@
+import argparse
+
+from bemani.common import CardCipher, CardCipherException
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to convert between card IDs and back-of-card characters.")
+    parser.add_argument(
+        "number",
+        help="card ID or back-of-card characters to convert.",
+        type=str,
+    )
+    args = parser.parse_args()
+
+    try:
+        print(CardCipher.decode(args.number))
+    except CardCipherException:
+        try:
+            back = CardCipher.encode(args.number)
+            print(" ".join([
+                back[i:(i + 4)] for i in range(0, len(back), 4)
+            ]))
+        except CardCipherException:
+            print('Bad card ID or back-of-card characters!')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/dbutils.py b/bemani/utils/dbutils.py
new file mode 100644
index 0000000..fc70928
--- /dev/null
+++ b/bemani/utils/dbutils.py
@@ -0,0 +1,122 @@
+import argparse
+import getpass
+import sys
+import yaml  # type: ignore
+from typing import Any, Dict, Optional
+
+from bemani.data import Data, DBCreateException
+
+
+def create(config: Dict[str, Any]) -> None:
+    data = Data(config)
+    data.create()
+    data.close()
+
+
+def generate(config: Dict[str, Any], message: Optional[str], allow_empty: bool) -> None:
+    if message is None:
+        raise Exception('Please provide a message!')
+    data = Data(config)
+    data.generate(message, allow_empty)
+    data.close()
+
+
+def upgrade(config: Dict[str, Any]) -> None:
+    data = Data(config)
+    data.upgrade()
+    data.close()
+
+
+def change_password(config: Dict[str, Any], username: Optional[str]) -> None:
+    if username is None:
+        raise Exception('Please provide a username!')
+    password1 = getpass.getpass('Password: ')
+    password2 = getpass.getpass('Re-enter password: ')
+    if password1 != password2:
+        raise Exception('Passwords don\'t match!')
+    data = Data(config)
+    userid = data.local.user.from_username(username)
+    if userid is None:
+        raise Exception('User not found!')
+    data.local.user.update_password(userid, password1)
+    print('User {} changed password.'.format(username))
+
+
+def add_admin(config: Dict[str, Any], username: Optional[str]) -> None:
+    if username is None:
+        raise Exception('Please provide a username!')
+    data = Data(config)
+    userid = data.local.user.from_username(username)
+    if userid is None:
+        raise Exception('User not found!')
+    user = data.local.user.get_user(userid)
+    user.admin = True
+    data.local.user.put_user(user)
+    print('User {} gained admin rights.'.format(username))
+
+
+def remove_admin(config: Dict[str, Any], username: Optional[str]) -> None:
+    if username is None:
+        raise Exception('Please provide a username!')
+    data = Data(config)
+    userid = data.local.user.from_username(username)
+    if userid is None:
+        raise Exception('User not found!')
+    user = data.local.user.get_user(userid)
+    user.admin = False
+    data.local.user.put_user(user)
+    print('User {} lost admin rights.'.format(username))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility for working with databases created with this codebase.")
+    parser.add_argument(
+        "operation",
+        help="Operation to perform, options include 'create', 'generate', 'upgrade', 'change-password', 'add-admin' and 'remove-admin'.",
+        type=str,
+    )
+    parser.add_argument(
+        "-u",
+        "--username",
+        help="Username of user to add/remove admin rights for.",
+        type=str,
+    )
+    parser.add_argument(
+        "-m",
+        "--message",
+        help="Message to use for auto-generated migration scripts.",
+        type=str,
+    )
+    parser.add_argument(
+        "-e",
+        "--allow-empty",
+        help="Allow empty migration script to be generated. Useful for data-only migrations.",
+        action='store_true',
+    )
+    parser.add_argument("-c", "--config", help="Core configuration. Defaults to server.yaml", type=str, default="server.yaml")
+    args = parser.parse_args()
+
+    config = yaml.safe_load(open(args.config))  # type: ignore
+    config['database']['engine'] = Data.create_engine(config)
+    try:
+        if args.operation == "create":
+            create(config)
+        elif args.operation == "generate":
+            generate(config, args.message, args.allow_empty)
+        elif args.operation == "upgrade":
+            upgrade(config)
+        elif args.operation == "add-admin":
+            add_admin(config, args.username)
+        elif args.operation == "remove-admin":
+            remove_admin(config, args.username)
+        elif args.operation == 'change-password':
+            change_password(config, args.username)
+        else:
+            raise Exception("Unknown operation '{}'".format(args.operation))
+    except DBCreateException as e:
+        print(str(e))
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/frontend.py b/bemani/utils/frontend.py
new file mode 100644
index 0000000..f94e8de
--- /dev/null
+++ b/bemani/utils/frontend.py
@@ -0,0 +1,109 @@
+import argparse
+import yaml  # type: ignore
+
+from bemani.backend.iidx import IIDXFactory
+from bemani.backend.popn import PopnMusicFactory
+from bemani.backend.jubeat import JubeatFactory
+from bemani.backend.bishi import BishiBashiFactory
+from bemani.backend.ddr import DDRFactory
+from bemani.backend.sdvx import SoundVoltexFactory
+from bemani.backend.reflec import ReflecBeatFactory
+from bemani.backend.museca import MusecaFactory
+from bemani.common import GameConstants
+from bemani.data import Data
+from bemani.frontend import app, config  # noqa: F401
+from bemani.frontend.account import account_pages
+from bemani.frontend.admin import admin_pages
+from bemani.frontend.arcade import arcade_pages
+from bemani.frontend.home import home_pages
+from bemani.frontend.iidx import iidx_pages
+from bemani.frontend.popn import popn_pages
+from bemani.frontend.bishi import bishi_pages
+from bemani.frontend.jubeat import jubeat_pages
+from bemani.frontend.ddr import ddr_pages
+from bemani.frontend.sdvx import sdvx_pages
+from bemani.frontend.reflec import reflec_pages
+from bemani.frontend.museca import museca_pages
+
+
+def register_blueprints() -> None:
+    global config
+
+    app.register_blueprint(account_pages)
+    app.register_blueprint(admin_pages)
+    app.register_blueprint(arcade_pages)
+    app.register_blueprint(home_pages)
+
+    if config.get('support', {}).get(GameConstants.IIDX, False):
+        app.register_blueprint(iidx_pages)
+    if config.get('support', {}).get(GameConstants.POPN_MUSIC, False):
+        app.register_blueprint(popn_pages)
+    if config.get('support', {}).get(GameConstants.JUBEAT, False):
+        app.register_blueprint(jubeat_pages)
+    if config.get('support', {}).get(GameConstants.BISHI_BASHI, False):
+        app.register_blueprint(bishi_pages)
+    if config.get('support', {}).get(GameConstants.DDR, False):
+        app.register_blueprint(ddr_pages)
+    if config.get('support', {}).get(GameConstants.SDVX, False):
+        app.register_blueprint(sdvx_pages)
+    if config.get('support', {}).get(GameConstants.REFLEC_BEAT, False):
+        app.register_blueprint(reflec_pages)
+    if config.get('support', {}).get(GameConstants.MUSECA, False):
+        app.register_blueprint(museca_pages)
+
+
+def register_games() -> None:
+    global config
+
+    if config.get('support', {}).get(GameConstants.POPN_MUSIC, False):
+        PopnMusicFactory.register_all()
+    if config.get('support', {}).get(GameConstants.JUBEAT, False):
+        JubeatFactory.register_all()
+    if config.get('support', {}).get(GameConstants.IIDX, False):
+        IIDXFactory.register_all()
+    if config.get('support', {}).get(GameConstants.BISHI_BASHI, False):
+        BishiBashiFactory.register_all()
+    if config.get('support', {}).get(GameConstants.DDR, False):
+        DDRFactory.register_all()
+    if config.get('support', {}).get(GameConstants.SDVX, False):
+        SoundVoltexFactory.register_all()
+    if config.get('support', {}).get(GameConstants.REFLEC_BEAT, False):
+        ReflecBeatFactory.register_all()
+    if config.get('support', {}).get(GameConstants.MUSECA, False):
+        MusecaFactory.register_all()
+
+
+def load_config(filename: str) -> None:
+    global config
+
+    config.update(yaml.safe_load(open(filename)))  # type: ignore
+    config['database']['engine'] = Data.create_engine(config)
+    app.secret_key = config['secret_key']
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A front end services provider for eAmusement games.")
+    parser.add_argument("-p", "--port", help="Port to listen on. Defaults to 80", type=int, default=80)
+    parser.add_argument("-c", "--config", help="Core configuration. Defaults to server.yaml", type=str, default="server.yaml")
+    parser.add_argument("-r", "--profile", help="Turn on profiling for front end", action="store_true")
+    args = parser.parse_args()
+
+    # Set up app
+    load_config(args.config)
+
+    # Register all blueprints
+    register_blueprints()
+
+    # Register all games
+    register_games()
+
+    if args.profile:
+        from werkzeug.contrib.profiler import ProfilerMiddleware  # type: ignore
+        app.wsgi_app = ProfilerMiddleware(app.wsgi_app, profile_dir='.')  # type: ignore
+
+    # Run the app
+    app.run(host='0.0.0.0', port=args.port, debug=True)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/ifsutils.py b/bemani/utils/ifsutils.py
new file mode 100644
index 0000000..b466997
--- /dev/null
+++ b/bemani/utils/ifsutils.py
@@ -0,0 +1,52 @@
+import argparse
+import os
+
+from bemani.format import IFS
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to extract IFS files.")
+    parser.add_argument(
+        "file",
+        help="IFS file to extract.",
+        type=str,
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        help="Directory to extract to. Defaults to current directroy.",
+        default="."
+    )
+    parser.add_argument(
+        "--convert-xml-files",
+        help="Convert xml files that are in binary.",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--convert-texture-files",
+        help="Convert texture files that are in game-format.",
+        action="store_true",
+    )
+    args = parser.parse_args()
+
+    root = args.directory
+    if root[-1] != '/':
+        root = root + '/'
+    root = os.path.realpath(root)
+
+    fp = open(args.file, 'rb')
+    data = fp.read()
+    fp.close()
+
+    ifs = IFS(data, args.convert_xml_files, args.convert_texture_files)
+    for fn in ifs.filenames:
+        print('Extracting {} to disk...'.format(fn))
+        realfn = os.path.join(root, fn)
+        dirof = os.path.dirname(realfn)
+        os.makedirs(dirof, exist_ok=True)
+        with open(realfn, 'wb') as fp:
+            fp.write(ifs.read_file(fn))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/iidxutils.py b/bemani/utils/iidxutils.py
new file mode 100644
index 0000000..e2e2c46
--- /dev/null
+++ b/bemani/utils/iidxutils.py
@@ -0,0 +1,47 @@
+import argparse
+
+from bemani.format import IIDXMusicDB
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to patch a IIDX music database.")
+    parser.add_argument(
+        "infile",
+        help="Music DB to work with.",
+        type=str,
+    )
+    parser.add_argument(
+        "outfile",
+        help="Music DB to overwrite.",
+        type=str,
+    )
+    parser.add_argument(
+        "--hide-leggendarias",
+        help="Hide leggendarias in normal folders.",
+        action="store_true",
+    )
+    args = parser.parse_args()
+
+    fp = open(args.infile, 'rb')
+    data = fp.read()
+    fp.close()
+
+    db = IIDXMusicDB(data)
+    if args.hide_leggendarias:
+        for song in db.songs:
+            if song.title[-1:] == '†' or (
+                song.difficulties[0] == 0 and
+                song.difficulties[1] == 0 and
+                song.difficulties[2] == 12
+            ):
+                print('Patching \'{}\' to only appear in leggendaria folder!'.format(song.title))
+                song.folder = 0x5C
+
+    print('Generating new database file...')
+    fp = open(args.outfile, 'wb')
+    fp.write(db.get_new_db())
+    fp.close()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/proxy.py b/bemani/utils/proxy.py
new file mode 100644
index 0000000..437a48a
--- /dev/null
+++ b/bemani/utils/proxy.py
@@ -0,0 +1,304 @@
+import argparse
+import requests
+import socket
+import yaml  # type: ignore
+from flask import Flask, Response, request
+from typing import Any, Dict, Optional
+import urllib.parse as urlparse
+
+from bemani.protocol import EAmuseProtocol, Node
+
+# Application configuration
+app = Flask(__name__)
+config: Dict[str, Any] = {}
+
+
+def modify_request(config: Dict[str, Any], req_body: Node) -> Optional[Node]:
+    # Not sure if there's any reason to modify requests, but its plumbed
+    return None
+
+
+def modify_response(config: Dict[str, Any], resp_body: Node) -> Optional[Node]:
+    # Figure out if we need to modify anything in the response
+    if resp_body.name != 'response':
+        # Not what we expected, bail
+        return None
+
+    # Now we get to the meat of packet detection
+    body = resp_body.children[0]
+
+    # Is this a services packet? We need to modify this to point the rest of the
+    # game packets at this proxy :(
+    if body.name == 'services':
+        for child in body.children:
+            if child.name == 'item':
+                if child.attribute('name') == 'ntp':
+                    # Don't override this
+                    continue
+                elif child.attribute('name') == 'keepalive':
+                    # Completely rewrite to point at the proxy server, otherwise if we're proxying
+                    # to a local backend, we will end up giving out a local address and we will get
+                    # Network NG.
+                    address = socket.gethostbyname(config['keepalive'])
+                    child.set_attribute(
+                        'url',
+                        'http://{}/core/keepalive?pa={}&ia={}&ga={}&ma={}&t1=2&t2=10'.format(
+                            address,
+                            address,
+                            address,
+                            address,
+                            address,
+                        ),
+                    )
+                else:
+                    # Get netloc to replace
+                    url = urlparse.urlparse(child.attribute('url'))
+                    defaultport = {
+                        'http': 80,
+                        'https': 443,
+                    }.get(url.scheme, 0)
+                    if config['local_port'] != defaultport:
+                        new_url = child.attribute('url').replace(url.netloc, '{}:{}'.format(
+                            config['local_host'],
+                            config['local_port'],
+                        ))
+                    else:
+                        new_url = child.attribute('url').replace(url.netloc, '{}'.format(
+                            config['local_host'],
+                        ))
+                    child.set_attribute('url', new_url)
+
+        return resp_body
+
+    return None
+
+
+@app.route('/', defaults={'path': ''}, methods=['GET'])
+@app.route('/<path:path>', methods=['GET'])
+def receive_healthcheck(path: str) -> Response:
+    if '*' in config['remote']:
+        remote_host = config['remote']['*']['host']
+        remote_port = config['remote']['*']['port']
+    else:
+        return Response("No route for default PCBID", 500)
+
+    actual_path = '/{}'.format(path)
+    if request.query_string is not None and len(request.query_string) > 0:
+        actual_path = actual_path + '?{}'.format(request.query_string.decode('ascii'))
+
+    # Make request to foreign service, using the same parameters
+    r = requests.get(
+        'http://{}:{}{}'.format(remote_host, remote_port, actual_path),
+        timeout=config['timeout'],
+        allow_redirects=False,
+    )
+
+    headers = {}
+    for header in ['Location']:
+        if header in r.headers:
+            headers[header] = r.headers[header]
+
+    return Response(r.content, r.status_code, headers)
+
+
+@app.route('/', defaults={'path': ''}, methods=['POST'])
+@app.route('/<path:path>', methods=['POST'])
+def receive_request(path: str) -> Response:
+    # First, parse the packet itself
+    client_proto = EAmuseProtocol()
+    server_proto = EAmuseProtocol()
+    remote_address = request.headers.get('X-Remote-Address', None)
+    request_compression = request.headers.get('X-Compress', None)
+    request_encryption = request.headers.get('X-Eamuse-Info', None)
+
+    actual_path = '/{}'.format(path)
+    if request.query_string is not None and len(request.query_string) > 0:
+        actual_path = actual_path + '?{}'.format(request.query_string.decode('ascii'))
+
+    if config['verbose']:
+        print("HTTP request for URI {}".format(actual_path))
+        print("Compression is {}".format(request_compression))
+        print("Encryption key is {}".format(request_encryption))
+
+    req = client_proto.decode(
+        request_compression,
+        request_encryption,
+        request.data,
+    )
+
+    if req is None:
+        # Nothing to do here
+        return Response("Unrecognized packet!", 500)
+
+    if config['verbose']:
+        print("Original request to server:")
+        print(req)
+
+    # Grab PCBID for directing to mulitple servers
+    pcbid = req.attribute('srcid')
+    if pcbid in config['remote']:
+        remote_host = config['remote'][pcbid]['host']
+        remote_port = config['remote'][pcbid]['port']
+    elif '*' in config['remote']:
+        remote_host = config['remote']['*']['host']
+        remote_port = config['remote']['*']['port']
+    else:
+        return Response("No route for PCBID {}".format(pcbid), 500)
+
+    modified_request = modify_request(config, req)
+    if modified_request is None:
+        # Return the original binary data instead of re-encoding it
+        # to the exact same thing.
+        req_binary = request.data
+    else:
+        if config['verbose']:
+            print("Modified request to server:")
+            print(modified_request)
+
+        # Re-encode the modified packet
+        req_binary = server_proto.encode(
+            request_compression,
+            request_encryption,
+            modified_request,
+            client_proto.last_text_encoding,
+            client_proto.last_packet_encoding,
+        )
+
+    # Set up custom headers for remote request
+    headers = {}
+    if request_compression is not None:
+        headers['X-Compress'] = request_compression
+    if request_encryption is not None:
+        headers['X-Eamuse-Info'] = request_encryption
+
+    # For lobby functionality, make sure the request receives
+    # the original IP address
+    headers['X-Remote-Address'] = remote_address or request.remote_addr
+
+    # Make request to foreign service, using the same parameters
+    r = requests.post(
+        'http://{}:{}{}'.format(remote_host, remote_port, actual_path),
+        headers=headers,
+        data=req_binary,
+        timeout=config['timeout'],
+    )
+
+    if r.status_code != 200:
+        # Failed on remote side
+        return Response("Failed to get response!", 500)
+
+    # Decode response, for modification if necessary
+    response_compression = r.headers.get('X-Compress', None)
+    response_encryption = r.headers.get('X-Eamuse-Info', None)
+    resp = server_proto.decode(
+        response_compression,
+        response_encryption,
+        r.content,
+    )
+
+    if resp is None:
+        # Nothing to do here
+        return Response("Unrecognized packet!", 500)
+
+    if config['verbose']:
+        print("Original response from server:")
+        print(resp)
+
+    modified_response = modify_response(config, resp)
+    if modified_response is None:
+        # Return the original response data instead of re-encoding it
+        # to the exact same thing.
+        resp_binary = r.content
+    else:
+        if config['verbose']:
+            print("Modified response from server:")
+            print(modified_response)
+
+        # Re-encode the modified packet
+        resp_binary = client_proto.encode(
+            response_compression,
+            response_encryption,
+            modified_response,
+        )
+
+    # Some old clients are case sensitive, so be careful to capitalize
+    # these responses here.
+    flask_resp = Response(resp_binary)
+    if response_compression is not None:
+        flask_resp.headers['X-Compress'] = response_compression
+    if response_encryption is not None:
+        flask_resp.headers['X-Eamuse-Info'] = response_encryption
+    return flask_resp
+
+
+def load_proxy_config(filename: str) -> None:
+    global config
+
+    config_data = yaml.safe_load(open(filename))  # type: ignore
+    if 'pcbid' in config_data and config_data['pcbid'] is not None:
+        for pcbid in config_data['pcbid']:
+            remote_name = config_data['pcbid'][pcbid]
+            remote_config = config_data['remote'][remote_name]
+            config['remote'][pcbid] = remote_config
+
+
+def load_config(filename: str) -> None:
+    global config
+
+    config_data = yaml.safe_load(open(filename))  # type: ignore
+    config.update({
+        'local_host': config_data['local']['host'],
+        'local_port': config_data['local']['port'],
+        'verbose': config_data.get('verbose', False),
+        'timeout': config_data.get('timeout', 30),
+        'keepalive': config_data.get('keepalive', 'localhost'),
+    })
+
+    if 'default' in config_data:
+        remote_config = config_data['remote'][config_data['default']]
+        config.update({
+            'remote': {
+                '*': remote_config,
+            },
+        })
+    else:
+        config.update({
+            'remote': {}
+        })
+
+    if 'pcbid' in config_data and config_data['pcbid'] is not None:
+        load_proxy_config(filename)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="A utility to MITM non-SSL eAmusement connections.")
+    parser.add_argument("-p", "--port", help="Port to listen on. Defaults to 9090", type=int, default=9090)
+    parser.add_argument("-a", "--address", help="Address to listen on. Defaults to all addresses", type=str, default="0.0.0.0")
+    parser.add_argument("-r", "--real-address", help="Real address we are listening on (for NAT and such)", type=str, default='127.0.0.1')
+    parser.add_argument("-q", "--remote-port", help="Port to connect to.", type=int, required=True)
+    parser.add_argument("-b", "--remote-address", help="Address to connect to.", type=str, required=True)
+    parser.add_argument("-c", "--config", help="Configuration file for PCBID to remote server mapping.", type=str, default=None)
+    parser.add_argument("-k", "--keepalive", help="Keepalive domain to advertise. Defaults to localhost", type=str, default='localhost')
+    parser.add_argument("-v", "--verbose", help="Display verbose packet info.", action='store_true')
+    parser.add_argument("-t", "--timeout", help="Timeout (in seconds) for proxy requests. Defaults to 30 seconds.", type=int, default=30)
+    args = parser.parse_args()
+
+    config.update({
+        'local_host': args.real_address,
+        'local_port': args.port,
+        'remote': {
+            '*': {
+                'host': args.remote_address,
+                'port': args.remote_port,
+            },
+        },
+        'verbose': args.verbose,
+        'timeout': args.timeout,
+        'keepalive': args.keepalive,
+    })
+
+    # Fill in remote addresses for PCBIDs we should redirect to a non-default server
+    if args.config is not None:
+        load_proxy_config(args.config)
+
+    app.run(host='0.0.0.0', port=args.port, debug=True)
diff --git a/bemani/utils/psmap.py b/bemani/utils/psmap.py
new file mode 100644
index 0000000..dec7e09
--- /dev/null
+++ b/bemani/utils/psmap.py
@@ -0,0 +1,231 @@
+import argparse
+import pefile  # type: ignore
+import struct
+from typing import List
+
+from bemani.protocol import Node
+from bemani.utils.responsegen import generate_lines
+
+
+def parse_psmap(data: bytes, offset: str, rootname: str) -> Node:
+    pe = pefile.PE(data=data, fast_load=True)
+    root = Node.void(rootname)
+    base = int(offset, 16)
+
+    def virtual_to_physical(offset: int) -> int:
+        for section in pe.sections:
+            start = section.VirtualAddress + pe.OPTIONAL_HEADER.ImageBase
+            end = start + section.SizeOfRawData
+
+            if offset >= start and offset < end:
+                return (offset - start) + section.PointerToRawData
+        raise Exception('Couldn\'t find raw offset for virtual offset 0x{:08x}'.format(offset))
+
+    if base >= pe.OPTIONAL_HEADER.ImageBase:
+        # Assume this is virtual
+        base = virtual_to_physical(base)
+
+    def read_string(offset: int) -> str:
+        # First, translate load offset in memory to disk offset
+        offset = virtual_to_physical(offset)
+
+        # Now, grab bytes until we're null-terminated
+        bytestring = []
+        while data[offset] != 0:
+            bytestring.append(data[offset])
+            offset = offset + 1
+
+        # Its shift-jis encoded, so decode it now
+        return bytes(bytestring).decode('shift_jisx0213')
+
+    # For recursing into nodes
+    saved_root: List[Node] = []
+    saved_loc: List[int] = []
+
+    while True:
+        chunk = data[base:(base + 16)]
+        base = base + 16
+
+        (nodetype, mandatory, outoffset, width, nameptr, defaultptr) = struct.unpack('<BBHIII', chunk)
+
+        if nodetype == 0xFF:
+            # End of nodes, see if we should exit
+            if len(saved_root) == 0:
+                break
+            else:
+                root = saved_root.pop()
+                oldbase = saved_loc.pop()
+                if oldbase is not None:
+                    base = oldbase
+                continue
+
+        # Grab name, get rid of parse numbers
+        name = read_string(nameptr)
+        try:
+            if name.index('#') >= 0:
+                name = name[:name.index('#')]
+        except ValueError:
+            pass
+
+        if nodetype == 0x00:
+            raise Exception('Invalid node type 0x{:02x}'.format(nodetype))
+        elif nodetype == 0x01:
+            # This is a void node, so we should handle by recursing
+            node = Node.void(name)
+            root.add_child(node)
+
+            # Recurse here
+            saved_root.append(root)
+
+            if defaultptr != 0:
+                saved_loc.append(base)
+                base = virtual_to_physical(defaultptr)
+            else:
+                saved_loc.append(None)
+
+            root = node
+            continue
+        elif nodetype == 0x02 or nodetype == 0x43:
+            if nodetype < 0x40:
+                elements = int(width / 1)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.s8_array(name, [-1] * elements)
+            else:
+                node = Node.s8(name, -1)
+        elif nodetype == 0x03 or nodetype == 0x44:
+            if nodetype < 0x40:
+                elements = int(width / 1)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.u8_array(name, [0] * elements)
+            else:
+                node = Node.u8(name, 0)
+        elif nodetype == 0x04 or nodetype == 0x45:
+            if nodetype < 0x40:
+                elements = int(width / 2)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.s16_array(name, [-1] * elements)
+            else:
+                node = Node.s16(name, -1)
+        elif nodetype == 0x05 or nodetype == 0x46:
+            if nodetype < 0x40:
+                elements = int(width / 2)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.u16_array(name, [0] * elements)
+            else:
+                node = Node.u16(name, 0)
+        elif nodetype == 0x06 or nodetype == 0x47:
+            if nodetype < 0x40:
+                elements = int(width / 4)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.s32_array(name, [-1] * elements)
+            else:
+                node = Node.s32(name, -1)
+        elif nodetype == 0x07 or nodetype == 0x48:
+            if nodetype < 0x40:
+                elements = int(width / 4)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.u32_array(name, [0] * elements)
+            else:
+                node = Node.u32(name, 0)
+        elif nodetype == 0x08 or nodetype == 0x49:
+            if nodetype < 0x40:
+                elements = int(width / 8)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.s64_array(name, [-1] * elements)
+            else:
+                node = Node.s64(name, -1)
+        elif nodetype == 0x09 or nodetype == 0x4A:
+            if nodetype < 0x40:
+                elements = int(width / 8)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.u64_array(name, [0] * elements)
+            else:
+                node = Node.u64(name, 0)
+        elif nodetype == 0x0A:
+            node = Node.string(name, '')
+        elif nodetype == 0x0D:
+            node = Node.float(name, 0.0)
+        elif nodetype == 0x32 or nodetype == 0x6D:
+            if nodetype < 0x40:
+                elements = int(width / 1)
+            else:
+                elements = width
+            if elements > 1:
+                node = Node.bool_array(name, [False] * elements)
+            else:
+                node = Node.bool(name, False)
+        else:
+            raise Exception('Unimplemented node type 0x{:02x}'.format(nodetype))
+
+        # Append it
+        root.add_child(node)
+
+    return root
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to extract psmap node lists and generate code.")
+    parser.add_argument(
+        "--file",
+        help="DLL file to extract from.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    parser.add_argument(
+        "--offset",
+        help="Hex offset into the file.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    parser.add_argument(
+        "-o",
+        "--outfile",
+        help="File to write python code to. Use - for stdout.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    parser.add_argument(
+        "--root",
+        help="Root node name.",
+        type=str,
+        default="root",
+    )
+    args = parser.parse_args()
+
+    fp = open(args.file, 'rb')
+    data = fp.read()
+    fp.close()
+
+    layout = parse_psmap(data, args.offset, args.root)
+    # Walk through, outputting each node and attaching it to its parent
+    code = '\n'.join(generate_lines(layout, {}))
+
+    if args.outfile == '-':
+        print(code)
+    else:
+        with open(args.outfile, mode="a") as outfp:
+            outfp.write(code)
+            outfp.close
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/read.py b/bemani/utils/read.py
new file mode 100644
index 0000000..90f3b8c
--- /dev/null
+++ b/bemani/utils/read.py
@@ -0,0 +1,3511 @@
+#! /usr/bin/env python3
+
+# vim: set fileencoding=utf-8
+import csv  # type: ignore
+import argparse
+import copy
+import io
+import jaconv  # type: ignore
+import json
+import os
+import pefile  # type: ignore
+import struct
+import yaml  # type: ignore
+import xml.etree.ElementTree as ET
+from sqlalchemy import create_engine  # type: ignore
+from sqlalchemy.engine.result import ResultProxy  # type: ignore
+from sqlalchemy.orm import sessionmaker  # type: ignore
+from sqlalchemy.sql import text  # type: ignore
+from sqlalchemy.exc import IntegrityError  # type: ignore
+from typing import Any, Dict, List, Optional, Tuple
+
+from bemani.common import GameConstants, VersionConstants, DBConstants, Time
+from bemani.format import ARC, IFS, IIDXChart, IIDXMusicDB
+from bemani.data import Server, Song
+from bemani.data.interfaces import APIProviderInterface
+from bemani.data.api.music import GlobalMusicData
+from bemani.data.api.game import GlobalGameData
+from bemani.data.mysql.music import MusicData
+from bemani.data.mysql.user import UserData
+
+
+class ReadAPI(APIProviderInterface):
+    def __init__(self, server: str, token: str) -> None:
+        self.__server = server
+        self.__token = token
+
+    def get_all_servers(self) -> List[Server]:
+        return [
+            Server(
+                0,
+                Time.now(),
+                self.__server,
+                self.__token,
+                False,
+                False,
+            )
+        ]
+
+
+class ImportBase:
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        game: str,
+        version: Optional[int],
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        self.game = game
+        self.version = version
+        self.update = update
+        self.no_combine = no_combine
+        self.__config = config
+        self.__url = "mysql://{}:{}@{}/{}?charset=utf8mb4".format(
+            config['database']['user'],
+            config['database']['password'],
+            config['database']['address'],
+            config['database']['database'],
+        )
+        self.__engine = create_engine(self.__url)  # type: ignore
+        self.__sessionmanager = sessionmaker(self.__engine)
+        self.__conn = self.__engine.connect()
+        self.__session = self.__sessionmanager(bind=self.__conn)
+        self.__batch = False
+
+    def start_batch(self) -> None:
+        self.__batch = True
+
+    def finish_batch(self) -> None:
+        self.__session.commit()
+        self.__batch = False
+
+    def execute(self, sql: str, params: Optional[Dict[str, Any]]=None) -> ResultProxy:
+        if not self.__batch:
+            raise Exception('Logic error, cannot execute outside of a batch!')
+
+        if self.__config['database'].get('read_only', False):
+            # See if this is an insert/update/delete
+            for write_statement in [
+                "insert into ",
+                "update ",
+                "delete from ",
+            ]:
+                if write_statement in sql.lower():
+                    raise Exception('Read-only mode is active!')
+        return self.__session.execute(text(sql), params if params is not None else {})
+
+    def remote_music(self, server: str, token: str) -> GlobalMusicData:
+        api = ReadAPI(server, token)
+        user = UserData(self.__config, self.__session)
+        music = MusicData(self.__config, self.__session)
+        return GlobalMusicData(api, user, music)
+
+    def remote_game(self, server: str, token: str) -> GlobalGameData:
+        api = ReadAPI(server, token)
+        return GlobalGameData(api)
+
+    def get_next_music_id(self) -> int:
+        cursor = self.execute("SELECT MAX(id) AS next_id FROM `music`")
+        result = cursor.fetchone()
+        try:
+            return result['next_id'] + 1
+        except TypeError:
+            # Nothing in DB
+            return 1
+
+    def get_music_id_for_song(self, songid: int, chart: int, version: Optional[int]=None) -> Optional[int]:
+        if version is None:
+            # Normal lookup
+            if self.version is None:
+                raise Exception('Cannot get music ID for song when operating on all versions!')
+            version = self.version
+            sql = (
+                "SELECT id FROM `music` WHERE songid = :songid AND chart = :chart AND game = :game AND version != :version"
+            )
+        else:
+            # Specific version lookup
+            sql = (
+                "SELECT id FROM `music` WHERE songid = :songid AND chart = :chart AND game = :game AND version = :version"
+            )
+
+        cursor = self.execute(sql, {'songid': songid, 'chart': chart, 'game': self.game, 'version': version})
+        if cursor.rowcount != 0:
+            result = cursor.fetchone()
+            return result['id']
+        else:
+            return None
+
+    def get_music_id_for_song_data(
+        self,
+        title: Optional[str],
+        artist: Optional[str],
+        genre: Optional[str],
+        chart: int,
+        version: Optional[int]=None,
+    ) -> Optional[int]:
+        frags = []
+        if title is not None:
+            frags.append("name = :title")
+        if artist is not None:
+            frags.append("artist = :artist")
+        if genre is not None:
+            frags.append("genre = :genre")
+        frags.append("chart = :chart")
+        frags.append("game = :game")
+
+        if version is None:
+            # Normal lookup
+            if self.version is None:
+                raise Exception('Cannot get music ID for song when operating on all versions!')
+            version = self.version
+            frags.append("version != :version")
+        else:
+            frags.append("version = :version")
+
+        sql = "SELECT id FROM `music` WHERE " + " AND ".join(frags)
+        cursor = self.execute(sql, {'title': title, 'artist': artist, 'genre': genre, 'chart': chart, 'game': self.game, 'version': version})
+        if cursor.rowcount != 0:
+            result = cursor.fetchone()
+            return result['id']
+        else:
+            return None
+
+    def insert_music_id_for_song(
+        self,
+        musicid: int,
+        songid: int,
+        chart: int,
+        name: Optional[str]=None,
+        artist: Optional[str]=None,
+        genre: Optional[str]=None,
+        data: Optional[Dict[str, Any]]=None,
+        version: Optional[int]=None,
+    ) -> None:
+        version = version if version is not None else self.version
+        if version is None:
+            raise Exception('Cannot get insert new song when operating on all versions!')
+        if data is None:
+            jsondata = '{}'
+        else:
+            jsondata = json.dumps(data)
+        try:
+            sql = (
+                "INSERT INTO `music` (id, songid, chart, game, version, name, artist, genre, data) " +
+                "VALUES (:id, :songid, :chart, :game, :version, :name, :artist, :genre, :data)"
+            )
+            self.execute(
+                sql,
+                {
+                    'id': musicid,
+                    'songid': songid,
+                    'chart': chart,
+                    'game': self.game,
+                    'version': version,
+                    'name': name,
+                    'artist': artist,
+                    'genre': genre,
+                    'data': jsondata
+                },
+            )
+        except IntegrityError:
+            if self.update:
+                print("Entry already existed, so updating information!")
+                self.update_metadata_for_song(songid, chart, name, artist, genre, data, version)
+            else:
+                print("Entry already existed, so skip creating a second one!")
+
+    def update_metadata_for_song(
+        self,
+        songid: int,
+        chart: int,
+        name: Optional[str]=None,
+        artist: Optional[str]=None,
+        genre: Optional[str]=None,
+        data: Optional[Dict[str, Any]]=None,
+        version: Optional[int]=None,
+    ) -> None:
+        if data is None:
+            jsondata = None
+        else:
+            jsondata = json.dumps(data)
+        version = version if version is not None else self.version
+
+        updates = []
+        if jsondata is not None:
+            updates.append("data = :data")
+        if name is not None:
+            updates.append("name = :name")
+        if artist is not None:
+            updates.append("artist = :artist")
+        if genre is not None:
+            updates.append("genre = :genre")
+        if len(updates) == 0:
+            return
+        sql = "UPDATE `music` SET {} WHERE songid = :songid AND chart = :chart AND game = :game".format(
+            ", ".join(updates),
+        )
+        if version is not None:
+            sql = sql + " AND version = :version"
+        self.execute(
+            sql,
+            {
+                'songid': songid,
+                'chart': chart,
+                'game': self.game,
+                'version': version,
+                'name': name,
+                'artist': artist,
+                'genre': genre,
+                'data': jsondata
+            },
+        )
+
+    def update_metadata_for_music_id(
+        self,
+        musicid: int,
+        name: Optional[str]=None,
+        artist: Optional[str]=None,
+        genre: Optional[str]=None,
+        data: Optional[Dict[str, Any]]=None,
+        version: Optional[int]=None,
+    ) -> None:
+        if data is None:
+            jsondata = None
+        else:
+            jsondata = json.dumps(data)
+        version = version if version is not None else self.version
+
+        updates = []
+        if jsondata is not None:
+            updates.append("data = :data")
+        if name is not None:
+            updates.append("name = :name")
+        if artist is not None:
+            updates.append("artist = :artist")
+        if genre is not None:
+            updates.append("genre = :genre")
+        if len(updates) == 0:
+            return
+        sql = "UPDATE `music` SET {} WHERE id = :musicid AND game = :game".format(
+            ", ".join(updates),
+        )
+        if version is not None:
+            sql = sql + " AND version = :version"
+        self.execute(
+            sql,
+            {
+                'musicid': musicid,
+                'game': self.game,
+                'version': version,
+                'name': name,
+                'artist': artist,
+                'genre': genre,
+                'data': jsondata
+            },
+        )
+
+    def insert_catalog_entry(
+        self,
+        cattype: str,
+        catid: int,
+        data: Optional[Dict[str, Any]]=None,
+    ) -> None:
+        if data is None:
+            jsondata = '{}'
+        else:
+            jsondata = json.dumps(data)
+        try:
+            sql = (
+                "INSERT INTO `catalog` (game, version, type, id, data) " +
+                "VALUES (:game, :version, :type, :id, :data)"
+            )
+            self.execute(
+                sql,
+                {
+                    'id': catid,
+                    'type': cattype,
+                    'game': self.game,
+                    'version': self.version,
+                    'data': jsondata
+                },
+            )
+        except IntegrityError:
+            if self.update:
+                print("Entry already existed, so updating information!")
+                sql = (
+                    "UPDATE `catalog` SET data = :data WHERE " +
+                    "game = :game AND version = :version AND type = :type AND id = :id"
+                )
+                self.execute(
+                    sql,
+                    {
+                        'id': catid,
+                        'type': cattype,
+                        'game': self.game,
+                        'version': self.version,
+                        'data': jsondata
+                    },
+                )
+            else:
+                print("Entry already existed, so skip creating a second one!")
+
+    def close(self) -> None:
+        """
+        Close any open data connection.
+        """
+        # Make sure we don't leak connections after finising insertion.
+        if self.__batch:
+            raise Exception('Logic error, opened a batch without closing!')
+        if self.__session is not None:
+            self.__session.close()
+        if self.__conn is not None:
+            self.__conn.close()
+            self.__conn = None
+        if self.__engine is not None:
+            self.__engine.dispose()
+            self.__engine = None
+
+
+class ImportPopn(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        actual_version = {
+            '19': VersionConstants.POPN_MUSIC_TUNE_STREET,
+            '20': VersionConstants.POPN_MUSIC_FANTASIA,
+            '21': VersionConstants.POPN_MUSIC_SUNNY_PARK,
+            '22': VersionConstants.POPN_MUSIC_LAPISTORIA,
+            '23': VersionConstants.POPN_MUSIC_ECLALE,
+            '24': VersionConstants.POPN_MUSIC_USANEKO,
+        }.get(version, -1)
+
+        if actual_version == VersionConstants.POPN_MUSIC_TUNE_STREET:
+            # Pop'n 19 has extra charts for old play modes (challenge and enjoy mode).
+            # Cho challenge is analogous to regular mode in newer games, but Pop'n
+            # 19 doesn't have easy charts, just 5 button charts.
+            self.charts = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+        elif actual_version >= VersionConstants.POPN_MUSIC_FANTASIA:
+            # Newer pop'n has charts for easy, normal, hyper, another
+            self.charts = [0, 1, 2, 3]
+        else:
+            raise Exception("Unsupported Pop'n Music version, expected one of the following: 19, 20, 21, 22, 23, 24!")
+
+        super().__init__(config, GameConstants.POPN_MUSIC, actual_version, no_combine, update)
+
+    def scrape(self, infile: str) -> List[Dict[str, Any]]:
+        with open(infile, mode="rb") as myfile:
+            data = myfile.read()
+            myfile.close()
+
+        pe = pefile.PE(data=data, fast_load=True)
+
+        def virtual_to_physical(offset: int) -> int:
+            for section in pe.sections:
+                start = section.VirtualAddress + pe.OPTIONAL_HEADER.ImageBase
+                end = start + section.SizeOfRawData
+
+                if offset >= start and offset < end:
+                    return (offset - start) + section.PointerToRawData
+            raise Exception('Couldn\'t find raw offset for virtual offset 0x{:08x}'.format(offset))
+
+        if self.version == VersionConstants.POPN_MUSIC_TUNE_STREET:
+            # Based on K39:J:A:A:2010122200
+
+            # Normal offset for music DB, size
+            offset = 0x1F68E8
+            step = 72
+            length = 1048
+
+            # Offset and step of file DB
+            file_offset = 0x2D6888
+            file_step = 24
+
+            # Standard lookups
+            genre_offset = 0
+            title_offset = 1
+            artist_offset = 2
+            comment_offset = 3
+            english_title_offset = -1
+            english_artist_offset = -1
+            extended_genre_offset = -1
+            charts_offset = 6
+            folder_offset = 7
+
+            # Offsets for normal chart difficulties
+            easy_offset = 12
+            normal_offset = 10
+            hyper_offset = 11
+            ex_offset = 13
+
+            # Offsets for battle chart difficulties
+            battle_normal_offset = 14
+            battle_hyper_offset = 15
+
+            # Offsets into which offset to seek to for file lookups
+            easy_file_offset = 18
+            normal_file_offset = 16
+            hyper_file_offset = 17
+            ex_file_offset = 19
+            battle_normal_file_offset = 20
+            battle_hyper_file_offset = 21
+
+            packedfmt = (
+                '<'
+                'I'  # Genre
+                'I'  # Title
+                'I'  # Artist
+                'I'  # Comment
+                'H'  # ??
+                'H'  # ??
+                'I'  # Available charts mask
+                'I'  # Folder
+                'I'  # Event flags?
+                'B'  # Event flags?
+                'B'  # Normal difficulty
+                'B'  # Hyper difficulty
+                'B'  # Easy difficulty
+                'B'  # EX difficulty
+                'B'  # Battle normal difficulty
+                'B'  # Battle hyper difficulty
+                'x'  # ??
+                'x'  # ??
+                'x'  # ??
+                'H'  # Normal chart pointer
+                'H'  # Hyper chart pointer
+                'H'  # Easy chart pointer
+                'H'  # EX chart pointer
+                'H'  # Battle normal pointer
+                'H'  # Battle hyper pointer
+                'xxxxxxxxxxxxxxxxxx'
+            )
+
+            # Offsets into file DB for finding file and folder.
+            file_folder_offset = 0
+            file_name_offset = 1
+
+            filefmt = (
+                '<'
+                'I'  # Folder
+                'I'  # Filename
+                'I'
+                'I'
+                'I'
+                'I'
+            )
+
+            # Decoding function for chart masks
+            def available_charts(mask: int) -> Tuple[bool, bool, bool, bool, bool, bool]:
+                return (
+                    True,  # Always an easy chart
+                    True,  # Always a normal chart
+                    mask & 0x1000000 > 0,  # Hyper chart bit
+                    mask & 0x2000000 > 0,  # Ex chart bit
+                    True,  # Always a battle normal chart
+                    mask & 0x4000000 > 0,  # Battle hyper chart bit
+                )
+        elif self.version == VersionConstants.POPN_MUSIC_FANTASIA:
+            # Based on L39:J:A:A:2012091900
+
+            # Normal offset for music DB, size
+            offset = 0x1AE240
+            step = 160
+            length = 1122
+
+            # Offset and step of file DB
+            file_offset = 0x273768
+            file_step = 24
+
+            # Standard lookups
+            genre_offset = 0
+            title_offset = 1
+            artist_offset = 2
+            comment_offset = 3
+            english_title_offset = -1
+            english_artist_offset = -1
+            extended_genre_offset = -1
+            charts_offset = 6
+            folder_offset = 7
+
+            # Offsets for normal chart difficulties
+            easy_offset = 12
+            normal_offset = 10
+            hyper_offset = 11
+            ex_offset = 13
+
+            # Offsets for battle chart difficulties
+            battle_normal_offset = 14
+            battle_hyper_offset = 15
+
+            # Offsets into which offset to seek to for file lookups
+            easy_file_offset = 18
+            normal_file_offset = 16
+            hyper_file_offset = 17
+            ex_file_offset = 19
+            battle_normal_file_offset = 20
+            battle_hyper_file_offset = 21
+
+            packedfmt = (
+                '<'
+                'I'  # Genre
+                'I'  # Title
+                'I'  # Artist
+                'I'  # Comment
+                'H'  # ??
+                'H'  # ??
+                'I'  # Available charts mask
+                'I'  # Folder
+                'I'  # Event flags?
+                'B'  # Event flags?
+                'B'  # Normal difficulty
+                'B'  # Hyper difficulty
+                'B'  # Easy difficulty
+                'B'  # EX difficulty
+                'B'  # Battle normal difficulty
+                'B'  # Battle hyper difficulty
+                'x'  # ??
+                'x'  # ??
+                'x'  # ??
+                'H'  # Normal chart pointer
+                'H'  # Hyper chart pointer
+                'H'  # Easy chart pointer
+                'H'  # EX chart pointer
+                'H'  # Battle normal pointer
+                'H'  # Battle hyper pointer
+                'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+            )
+
+            # Offsets into file DB for finding file and folder.
+            file_folder_offset = 0
+            file_name_offset = 1
+
+            filefmt = (
+                '<'
+                'I'  # Folder
+                'I'  # Filename
+                'I'
+                'I'
+                'I'
+                'I'
+            )
+
+            # Decoding function for chart masks
+            def available_charts(mask: int) -> Tuple[bool, bool, bool, bool, bool, bool]:
+                return (
+                    True,  # Always an easy chart
+                    True,  # Always a normal chart
+                    mask & 0x1000000 > 0,  # Hyper chart bit
+                    mask & 0x2000000 > 0,  # Ex chart bit
+                    True,  # Always a battle normal chart
+                    mask & 0x4000000 > 0,  # Battle hyper chart bit
+                )
+        elif self.version == VersionConstants.POPN_MUSIC_SUNNY_PARK:
+            # Based on M39:J:A:A:2014061900
+
+            # Normal offset for music DB, size
+            offset = 0x1FB640
+            step = 164
+            length = 1280
+
+            # Offset and step of file DB
+            file_offset = 0x2E0D20
+            file_step = 28
+
+            # Standard lookups
+            genre_offset = 0
+            title_offset = 1
+            artist_offset = 2
+            comment_offset = 3
+            english_title_offset = 4
+            english_artist_offset = 5
+            extended_genre_offset = 6
+            charts_offset = 9
+            folder_offset = 10
+
+            # Offsets for normal chart difficulties
+            easy_offset = 13
+            normal_offset = 14
+            hyper_offset = 15
+            ex_offset = 16
+
+            # Offsets for battle chart difficulties
+            battle_normal_offset = 17
+            battle_hyper_offset = 18
+
+            # Offsets into which offset to seek to for file lookups
+            easy_file_offset = 19
+            normal_file_offset = 20
+            hyper_file_offset = 21
+            ex_file_offset = 22
+            battle_normal_file_offset = 21
+            battle_hyper_file_offset = 22
+
+            packedfmt = (
+                '<'
+                'I'  # Genre
+                'I'  # Title
+                'I'  # Artist
+                'I'  # Comment
+                'I'  # English Title
+                'I'  # English Artist
+                'I'  # Extended genre?
+                'H'  # ??
+                'H'  # ??
+                'I'  # Available charts mask
+                'I'  # Folder
+                'I'  # Event unlocks?
+                'H'  # Event unlocks?
+                'B'  # Easy difficulty
+                'B'  # Normal difficulty
+                'B'  # Hyper difficulty
+                'B'  # EX difficulty
+                'B'  # Battle normal difficulty
+                'B'  # Battle hyper difficulty
+                'H'  # Easy chart pointer
+                'H'  # Normal chart pointer
+                'H'  # Hyper chart pointer
+                'H'  # EX chart pointer
+                'H'  # Battle normal pointer
+                'H'  # Battle hyper pointer
+                'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+            )
+
+            # Offsets into file DB for finding file and folder.
+            file_folder_offset = 0
+            file_name_offset = 1
+
+            filefmt = (
+                '<'
+                'I'  # Folder
+                'I'  # Filename
+                'I'
+                'I'
+                'I'
+                'I'
+                'I'
+            )
+
+            # Decoding function for chart masks
+            def available_charts(mask: int) -> Tuple[bool, bool, bool, bool, bool, bool]:
+                return (
+                    mask & 0x0080000 > 0,  # Easy chart bit
+                    True,  # Always a normal chart
+                    mask & 0x1000000 > 0,  # Hyper chart bit
+                    mask & 0x2000000 > 0,  # Ex chart bit
+                    True,  # Always a battle normal chart
+                    mask & 0x4000000 > 0,  # Battle hyper chart bit
+                )
+        elif self.version == VersionConstants.POPN_MUSIC_LAPISTORIA:
+            # Based on M39:J:A:A:2015081900
+
+            # Normal offset for music DB, size
+            offset = 0x3124B0
+            step = 160
+            length = 1423
+
+            # Offset and step of file DB
+            file_offset = 0x472130
+            file_step = 28
+
+            # Standard lookups
+            genre_offset = 0
+            title_offset = 1
+            artist_offset = 2
+            comment_offset = 3
+            english_title_offset = 4
+            english_artist_offset = 5
+            extended_genre_offset = -1
+            charts_offset = 8
+            folder_offset = 9
+
+            # Offsets for normal chart difficulties
+            easy_offset = 12
+            normal_offset = 13
+            hyper_offset = 14
+            ex_offset = 15
+
+            # Offsets for battle chart difficulties
+            battle_normal_offset = 16
+            battle_hyper_offset = 17
+
+            # Offsets into which offset to seek to for file lookups
+            easy_file_offset = 18
+            normal_file_offset = 19
+            hyper_file_offset = 20
+            ex_file_offset = 21
+            battle_normal_file_offset = 22
+            battle_hyper_file_offset = 23
+
+            packedfmt = (
+                '<'
+                'I'  # Genre
+                'I'  # Title
+                'I'  # Artist
+                'I'  # Comment
+                'I'  # English Title
+                'I'  # English Artist
+                'H'  # ??
+                'H'  # ??
+                'I'  # Available charts mask
+                'I'  # Folder
+                'I'  # Event unlocks?
+                'H'  # Event unlocks?
+                'B'  # Easy difficulty
+                'B'  # Normal difficulty
+                'B'  # Hyper difficulty
+                'B'  # EX difficulty
+                'B'  # Battle normal difficulty
+                'B'  # Battle hyper difficulty
+                'H'  # Easy chart pointer
+                'H'  # Normal chart pointer
+                'H'  # Hyper chart pointer
+                'H'  # EX chart pointer
+                'H'  # Battle normal pointer
+                'H'  # Battle hyper pointer
+                'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+            )
+
+            # Offsets into file DB for finding file and folder.
+            file_folder_offset = 0
+            file_name_offset = 1
+
+            filefmt = (
+                '<'
+                'I'  # Folder
+                'I'  # Filename
+                'I'
+                'I'
+                'I'
+                'I'
+                'I'
+            )
+
+            # Decoding function for chart masks
+            def available_charts(mask: int) -> Tuple[bool, bool, bool, bool, bool, bool]:
+                return (
+                    mask & 0x0080000 > 0,  # Easy chart bit
+                    True,  # Always a normal chart
+                    mask & 0x1000000 > 0,  # Hyper chart bit
+                    mask & 0x2000000 > 0,  # Ex chart bit
+                    True,  # Always a battle normal chart
+                    mask & 0x4000000 > 0,  # Battle hyper chart bit
+                )
+        elif self.version == VersionConstants.POPN_MUSIC_ECLALE:
+            # Based on M39:J:A:A:2016100500
+
+            # Normal offset for music DB, size
+            offset = 0x2DE5C8
+            step = 160
+            length = 1551
+
+            # Offset and step of file DB
+            file_offset = 0x2D1948
+            file_step = 32
+
+            # Standard lookups
+            genre_offset = 0
+            title_offset = 1
+            artist_offset = 2
+            comment_offset = 3
+            english_title_offset = 4
+            english_artist_offset = 5
+            extended_genre_offset = -1
+            charts_offset = 8
+            folder_offset = 9
+
+            # Offsets for normal chart difficulties
+            easy_offset = 12
+            normal_offset = 13
+            hyper_offset = 14
+            ex_offset = 15
+
+            # Offsets for battle chart difficulties
+            battle_normal_offset = 16
+            battle_hyper_offset = 17
+
+            # Offsets into which offset to seek to for file lookups
+            easy_file_offset = 18
+            normal_file_offset = 19
+            hyper_file_offset = 20
+            ex_file_offset = 21
+            battle_normal_file_offset = 22
+            battle_hyper_file_offset = 23
+
+            packedfmt = (
+                '<'
+                'I'  # Genre
+                'I'  # Title
+                'I'  # Artist
+                'I'  # Comment
+                'I'  # English Title
+                'I'  # English Artist
+                'H'  # ??
+                'H'  # ??
+                'I'  # Available charts mask
+                'I'  # Folder
+                'I'  # Event unlocks?
+                'H'  # Event unlocks?
+                'B'  # Easy difficulty
+                'B'  # Normal difficulty
+                'B'  # Hyper difficulty
+                'B'  # EX difficulty
+                'B'  # Battle normal difficulty
+                'B'  # Battle hyper difficulty
+                'H'  # Easy chart pointer
+                'H'  # Normal chart pointer
+                'H'  # Hyper chart pointer
+                'H'  # EX chart pointer
+                'H'  # Battle normal pointer
+                'H'  # Battle hyper pointer
+                'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+            )
+
+            # Offsets into file DB for finding file and folder.
+            file_folder_offset = 0
+            file_name_offset = 1
+
+            filefmt = (
+                '<'
+                'I'  # Folder
+                'I'  # Filename
+                'I'
+                'I'
+                'I'
+                'I'
+                'I'
+                'I'
+            )
+
+            # Decoding function for chart masks
+            def available_charts(mask: int) -> Tuple[bool, bool, bool, bool, bool, bool]:
+                return (
+                    mask & 0x0080000 > 0,  # Easy chart bit
+                    True,  # Always a normal chart
+                    mask & 0x1000000 > 0,  # Hyper chart bit
+                    mask & 0x2000000 > 0,  # Ex chart bit
+                    True,  # Always a battle normal chart
+                    mask & 0x4000000 > 0,  # Battle hyper chart bit
+                )
+        elif self.version == VersionConstants.POPN_MUSIC_USANEKO:
+            # Based on M39:J:A:A:2018101500
+
+            # Normal offset for music DB, size
+            offset = 0x299210
+            step = 172
+            length = 1704
+
+            # Offset and step of file DB
+            file_offset = 0x28AF08
+            file_step = 32
+
+            # Standard lookups
+            genre_offset = 0
+            title_offset = 1
+            artist_offset = 2
+            comment_offset = 3
+            english_title_offset = 4
+            english_artist_offset = 5
+            extended_genre_offset = -1
+            charts_offset = 8
+            folder_offset = 9
+
+            # Offsets for normal chart difficulties
+            easy_offset = 12
+            normal_offset = 13
+            hyper_offset = 14
+            ex_offset = 15
+
+            # Offsets for battle chart difficulties
+            battle_normal_offset = 16
+            battle_hyper_offset = 17
+
+            # Offsets into which offset to seek to for file lookups
+            easy_file_offset = 18
+            normal_file_offset = 19
+            hyper_file_offset = 20
+            ex_file_offset = 21
+            battle_normal_file_offset = 22
+            battle_hyper_file_offset = 23
+
+            packedfmt = (
+                '<'
+                'I'  # Genre
+                'I'  # Title
+                'I'  # Artist
+                'I'  # Comment
+                'I'  # English Title
+                'I'  # English Artist
+                'H'  # ??
+                'H'  # ??
+                'I'  # Available charts mask
+                'I'  # Folder
+                'I'  # Event unlocks?
+                'I'  # Event unlocks?
+                'B'  # Easy difficulty
+                'B'  # Normal difficulty
+                'B'  # Hyper difficulty
+                'B'  # EX difficulty
+                'B'  # Battle normal difficulty
+                'B'  # Battle hyper difficulty
+                'xx'  # Unknown pointer
+                'H'  # Easy chart pointer
+                'H'  # Normal chart pointer
+                'H'  # Hyper chart pointer
+                'H'  # EX chart pointer
+                'H'  # Battle normal pointer
+                'H'  # Battle hyper pointer
+                'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+            )
+
+            # Offsets into file DB for finding file and folder.
+            file_folder_offset = 0
+            file_name_offset = 1
+
+            filefmt = (
+                '<'
+                'I'  # Folder
+                'I'  # Filename
+                'I'
+                'I'
+                'I'
+                'I'
+                'I'
+                'I'
+            )
+
+            # Decoding function for chart masks
+            def available_charts(mask: int) -> Tuple[bool, bool, bool, bool, bool, bool]:
+                return (
+                    mask & 0x0080000 > 0,  # Easy chart bit
+                    True,  # Always a normal chart
+                    mask & 0x1000000 > 0,  # Hyper chart bit
+                    mask & 0x2000000 > 0,  # Ex chart bit
+                    True,  # Always a battle normal chart
+                    mask & 0x4000000 > 0,  # Battle hyper chart bit
+                )
+        else:
+            raise Exception('Unsupported version {}'.format(self.version))
+
+        def read_string(offset: int) -> str:
+            # First, translate load offset in memory to disk offset
+            offset = virtual_to_physical(offset)
+
+            # Now, grab bytes until we're null-terminated
+            bytestring = []
+            while data[offset] != 0:
+                bytestring.append(data[offset])
+                offset = offset + 1
+
+            # Its shift-jis encoded, so decode it now
+            return bytes(bytestring).decode('shift_jisx0213')
+
+        def file_chunk(offset: int) -> Tuple[Any, ...]:
+            fileoffset = file_offset + (file_step * offset)
+            filedata = data[fileoffset:(fileoffset + file_step)]
+            return struct.unpack(filefmt, filedata)
+
+        def file_handle(offset: int) -> str:
+            chunk = file_chunk(offset)
+            return read_string(chunk[file_folder_offset]) + '/' + read_string(chunk[file_name_offset])
+
+        songs = []
+        for songid in range(length):
+            chunkoffset = offset + (step * songid)
+            chunkdata = data[chunkoffset:(chunkoffset + step)]
+            unpacked = struct.unpack(packedfmt, chunkdata)
+            valid_charts = available_charts(unpacked[charts_offset])
+            songinfo = {
+                'id': songid,
+                'title': read_string(unpacked[title_offset]),
+                'artist': read_string(unpacked[artist_offset]),
+                'genre': read_string(unpacked[genre_offset]),
+                'comment': read_string(unpacked[comment_offset]),
+                'title_en': read_string(unpacked[english_title_offset]) if english_title_offset > 0 else '',
+                'artist_en': read_string(unpacked[english_artist_offset]) if english_artist_offset > 0 else '',
+                'long_genre': read_string(unpacked[extended_genre_offset]) if extended_genre_offset > 0 else '',
+                'folder': unpacked[folder_offset],
+                'difficulty': {
+                    'standard': {
+                        'easy': unpacked[easy_offset] if valid_charts[0] else 0,
+                        'normal': unpacked[normal_offset] if valid_charts[1] else 0,
+                        'hyper': unpacked[hyper_offset] if valid_charts[2] else 0,
+                        'ex': unpacked[ex_offset] if valid_charts[3] else 0,
+                    },
+                    'battle': {
+                        'normal': unpacked[battle_normal_offset] if valid_charts[4] else 0,
+                        'hyper': unpacked[battle_hyper_offset] if valid_charts[5] else 0,
+                    }
+                },
+                'file': {
+                    'standard': {
+                        'easy': file_handle(unpacked[easy_file_offset]) if valid_charts[0] else '',
+                        'normal': file_handle(unpacked[normal_file_offset]) if valid_charts[1] else '',
+                        'hyper': file_handle(unpacked[hyper_file_offset]) if valid_charts[2] else '',
+                        'ex': file_handle(unpacked[ex_file_offset]) if valid_charts[3] else '',
+                    },
+                    'battle': {
+                        'normal': file_handle(unpacked[battle_normal_file_offset]) if valid_charts[4] else '',
+                        'hyper': file_handle(unpacked[battle_hyper_file_offset]) if valid_charts[5] else '',
+                    },
+                },
+            }
+
+            if (
+                songinfo['title'] in ['-', '‐'] and
+                songinfo['genre'] in ['-', '‐'] and
+                songinfo['artist'] in ['-', '‐'] and
+                songinfo['comment'] in ['-', '‐']
+            ):
+                # This is a removed song
+                continue
+
+            if (
+                songinfo['title'] == 'ＤＵＭＭＹ' and
+                songinfo['artist'] == 'ＤＵＭＭＹ' and
+                songinfo['genre'] == 'ＤＵＭＭＹ'
+            ):
+                # This is a song the intern left in
+                continue
+
+            # Fix accent issues with title/artist
+            accent_lut: Dict[str, str] = {
+                "鵝": "7",
+                "圄": "à",
+                "圉": "ä",
+                "鵤": "Ä",
+                "鵑": "👁",
+                "鶤": "©",
+                "圈": "é",
+                "鵐": "ê",
+                "鵙": "Ə",
+                "鵲": "ë",
+                "！": "!",
+                "囿": "♥",
+                "鶚": "㊙",
+                "鶉": "ó",
+                "鶇": "ö",
+                "鶲": "Ⓟ",
+                "鶫": "²",
+                "圍": "@",
+                "圖": "ţ",
+                "鵺": "Ü",
+                "囎": ":",
+                "囂": "♡",
+                "釁": "🐾",
+            }
+
+            for orig, rep in accent_lut.items():
+                songinfo['title'] = songinfo['title'].replace(orig, rep)
+                songinfo['artist'] = songinfo['artist'].replace(orig, rep)
+                songinfo['title_en'] = songinfo['title_en'].replace(orig, rep)
+                songinfo['artist_en'] = songinfo['artist_en'].replace(orig, rep)
+                songinfo['genre'] = songinfo['genre'].replace(orig, rep)
+            songs.append(songinfo)
+
+        return songs
+
+    def lookup(self, server: str, token: str) -> List[Dict[str, Any]]:
+        # Grab music info from remote server
+        music = self.remote_music(server, token)
+        songs = music.get_all_songs(self.game, self.version)
+        lut: Dict[int, Dict[str, Any]] = {}
+        chart_map = {
+            0: 'easy',
+            1: 'normal',
+            2: 'hyper',
+            3: 'ex',
+        }
+
+        # Format it the way we expect
+        for song in songs:
+            if song.chart not in chart_map:
+                # Ignore charts on songs we don't support/care about.
+                continue
+
+            if song.id not in lut:
+                lut[song.id] = {
+                    'id': song.id,
+                    'title': song.name,
+                    'artist': song.artist,
+                    'genre': song.genre,
+                    'comment': "",
+                    'title_en': "",
+                    'artist_en': "",
+                    'long_genre': "",
+                    'folder': song.data.get_str('category'),
+                    'difficulty': {
+                        'standard': {
+                            'easy': 0,
+                            'normal': 0,
+                            'hyper': 0,
+                            'ex': 0,
+                        },
+                        'battle': {
+                            'normal': 0,
+                            'hyper': 0,
+                        }
+                    },
+                    'file': {
+                        'standard': {
+                            'easy': "",
+                            'normal': "",
+                            'hyper': "",
+                            'ex': "",
+                        },
+                        'battle': {
+                            'normal': "",
+                            'hyper': "",
+                        },
+                    },
+                }
+            lut[song.id]['difficulty']['standard'][chart_map[song.chart]] = song.data.get_int('difficulty')
+
+        # Return the reassembled data
+        return [val for _, val in lut.items()]
+
+    def import_music_db(self, songs: List[Dict[str, Any]]) -> None:
+        chart_map = {
+            0: 'easy',
+            1: 'normal',
+            2: 'hyper',
+            3: 'ex',
+        }
+
+        for song in songs:
+            self.start_batch()
+            for chart in self.charts:
+                # First, try to find in the DB from another version
+                old_id = self.get_music_id_for_song(song['id'], chart)
+
+                # Now, look up metadata
+                title = song['title_en'] if len(song['title_en']) > 0 else song['title']
+                artist = song['artist_en'] if len(song['artist_en']) > 0 else song['artist']
+                genre = song['genre']
+
+                # We only care about easy/normal/hyper/ex, so only provide mappings there
+                if chart in chart_map:
+                    difficulty = song['difficulty']['standard'][chart_map[chart]]
+                else:
+                    difficulty = 0
+
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} {} ({} chart {})".format(artist, title, song['id'], chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    print("Reused entry for {} {} ({} chart {})".format(artist, title, song['id'], chart))
+                    next_id = old_id
+                self.insert_music_id_for_song(
+                    next_id,
+                    song['id'],
+                    chart,
+                    title,
+                    artist,
+                    genre,
+                    {
+                        'category': str(song['folder']),
+                        'difficulty': difficulty,
+                    },
+                )
+            self.finish_batch()
+
+
+class ImportJubeat(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        actual_version = {
+            'saucer': VersionConstants.JUBEAT_SAUCER,
+            'saucer-fulfill': VersionConstants.JUBEAT_SAUCER_FULFILL,
+            'prop': VersionConstants.JUBEAT_PROP,
+            'qubell': VersionConstants.JUBEAT_QUBELL,
+            'clan': VersionConstants.JUBEAT_CLAN,
+            'all': None,  # Special case for importing metadata
+        }.get(version, -1)
+
+        if actual_version in [
+            None,
+            VersionConstants.JUBEAT_SAUCER,
+            VersionConstants.JUBEAT_SAUCER_FULFILL,
+            VersionConstants.JUBEAT_PROP,
+            VersionConstants.JUBEAT_QUBELL,
+            VersionConstants.JUBEAT_CLAN,
+        ]:
+            self.charts = [0, 1, 2]
+        else:
+            raise Exception("Unsupported Jubeat version, expected one of the following: saucer, saucer-fulfill, prop, qubell, clan!")
+
+        super().__init__(config, GameConstants.JUBEAT, actual_version, no_combine, update)
+
+    def scrape(self, xmlfile: str) -> List[Dict[str, Any]]:
+        if self.version is None:
+            raise Exception('Can\'t scrape Jubeat database for \'all\' version!')
+
+        tree = ET.parse(xmlfile)
+        root = tree.getroot()
+
+        songs: List[Dict[str, Any]] = []
+        for music_entry in root.find('body'):
+            songid = int(music_entry.find('music_id').text)
+            bpm_min = float(music_entry.find('bpm_min').text)
+            bpm_max = float(music_entry.find('bpm_max').text)
+            if bpm_max > 0 and bpm_min < 0:
+                bpm_min = bpm_max
+            difficulties = [
+                int(music_entry.find('level_bsc').text),
+                int(music_entry.find('level_adv').text),
+                int(music_entry.find('level_ext').text),
+            ]
+            genre = "other"
+            for possible_genre in music_entry.find('genre'):
+                if int(possible_genre.text) != 0:
+                    genre = str(possible_genre.tag)
+
+            songs.append({
+                'id': songid,
+                # Title/artist aren't in the music data for Jubeat and must be manually populated.
+                # This is why there is a separate "import_metadata" and data file.
+                'title': None,
+                'artist': None,
+                'genre': genre,
+                'bpm_min': bpm_min,
+                'bpm_max': bpm_max,
+                'difficulty': {
+                    'basic': difficulties[0],
+                    'advanced': difficulties[1],
+                    'extreme': difficulties[2],
+                },
+            })
+        return songs
+
+    def lookup(self, server: str, token: str) -> List[Dict[str, Any]]:
+        if self.version is None:
+            raise Exception('Can\'t look up Jubeat database for \'all\' version!')
+
+        # Grab music info from remote server
+        music = self.remote_music(server, token)
+        songs = music.get_all_songs(self.game, self.version)
+        lut: Dict[int, Dict[str, Any]] = {}
+        chart_map = {
+            0: 'basic',
+            1: 'advanced',
+            2: 'extreme',
+        }
+
+        # Format it the way we expect
+        for song in songs:
+            if song.chart not in chart_map:
+                # Ignore charts on songs we don't support/care about.
+                continue
+
+            if song.id not in lut:
+                lut[song.id] = {
+                    'id': song.id,
+                    'title': song.name,
+                    'artist': song.artist,
+                    'genre': song.genre,
+                    'bpm_min': song.data.get_int('bpm_min'),
+                    'bpm_max': song.data.get_int('bpm_max'),
+                    'difficulty': {
+                        'basic': 0,
+                        'advanced': 0,
+                        'extreme': 0,
+                    },
+                }
+            lut[song.id]['difficulty'][chart_map[song.chart]] = song.data.get_int('difficulty')
+
+        # Return the reassembled data
+        return [val for _, val in lut.items()]
+
+    def import_music_db(self, songs: List[Dict[str, Any]]) -> None:
+        if self.version is None:
+            raise Exception('Can\'t import Jubeat database for \'all\' version!')
+
+        chart_map: Dict[int, str] = {
+            0: 'basic',
+            1: 'advanced',
+            2: 'extreme',
+        }
+        for song in songs:
+            # Skip over duplicate songs for the "play five different versions of this song
+            # across different prefectures" event. The song ID range is 8000301-8000347, so
+            # we arbitrarily choose to keep only the first one.
+            songid = song['id']
+            if songid in set(range(80000302, 80000348)):
+                continue
+
+            self.start_batch()
+            for chart in self.charts:
+                # First, try to find in the DB from another version
+                old_id = self.get_music_id_for_song(songid, chart)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(songid, chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(songid, chart))
+                    next_id = old_id
+                data = {
+                    'difficulty': song['difficulty'][chart_map[chart]],
+                    'bpm_min': song['bpm_min'],
+                    'bpm_max': song['bpm_max'],
+                }
+                self.insert_music_id_for_song(next_id, songid, chart, song['title'], song['artist'], song['genre'], data)
+            self.finish_batch()
+
+    def import_metadata(self, tsvfile: str) -> None:
+        if self.version is not None:
+            raise Exception("Unsupported Jubeat version, expected one of the following: all")
+
+        with open(tsvfile, newline='') as tsvhandle:
+            jubeatreader = csv.reader(tsvhandle, delimiter='\t', quotechar='"')  # type: ignore
+            for row in jubeatreader:
+                songid = int(row[0])
+                name = row[1]
+                artist = row[2]
+
+                print("Setting name/artist for {} all charts".format(songid))
+                self.start_batch()
+                for chart in self.charts:
+                    self.update_metadata_for_song(songid, chart, name, artist)
+                self.finish_batch()
+
+
+class ImportIIDX(ImportBase):
+
+    # Tutorial charts that shouldn't be on the UI
+    BANNED_CHARTS = [
+        16070,
+        16071,
+        16072,
+        16080,
+        16081,
+        16082,
+    ]
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        if version in ['20', '21', '22', '23', '24']:
+            actual_version = {
+                '20': VersionConstants.IIDX_TRICORO,
+                '21': VersionConstants.IIDX_SPADA,
+                '22': VersionConstants.IIDX_PENDUAL,
+                '23': VersionConstants.IIDX_COPULA,
+                '24': VersionConstants.IIDX_SINOBUZ,
+            }[version]
+            self.charts = [0, 1, 2, 3, 4, 5, 6]
+        elif version in ['omni-20', 'omni-21', 'omni-22', 'omni-23', 'omni-24']:
+            actual_version = {
+                'omni-20': VersionConstants.IIDX_TRICORO,
+                'omni-21': VersionConstants.IIDX_SPADA,
+                'omni-22': VersionConstants.IIDX_PENDUAL,
+                'omni-23': VersionConstants.IIDX_COPULA,
+                'omni-24': VersionConstants.IIDX_SINOBUZ,
+            }[version] + DBConstants.OMNIMIX_VERSION_BUMP
+            self.charts = [0, 1, 2, 3, 4, 5, 6]
+        elif version == 'all':
+            actual_version = None
+            self.charts = [0, 1, 2, 3, 4, 5, 6]
+        else:
+            raise Exception("Unsupported IIDX version, expected one of the following: 20, 21, 22, 23, 24, omni-20, omni-21, omni-22, omni-23, omni-24!")
+
+        super().__init__(config, GameConstants.IIDX, actual_version, no_combine, update)
+
+    def __gather_sound_files(self, directory: str) -> Dict[int, str]:
+        files = {}
+        for (dirpath, dirnames, filenames) in os.walk(directory):
+            for filename in filenames:
+                songid, extension = os.path.splitext(filename)
+                if extension == '.1' or extension == '.ifs':
+                    try:
+                        files[int(songid)] = os.path.join(directory, os.path.join(dirpath, filename))
+                    except ValueError:
+                        # Invalid file
+                        pass
+
+            for dirname in dirnames:
+                files.update(self.__gather_sound_files(os.path.join(directory, dirname)))
+
+        return files
+
+    def __revivals(self, songid: int, chart: int) -> Optional[int]:
+        old_id = self.get_music_id_for_song(songid, chart)
+        if old_id is not None:
+            return old_id
+
+        # For revivals from older games, these show up as their respective old IDs
+        # in Spada Omnimix, but in Pendual Omnimix they're in the Pendual category.
+        legacy_to_modern_map = {
+            4213: 23066,
+            9203: 22068,
+            10203: 22052,
+            12201: 22039,
+            12204: 21201,
+            12206: 21064,
+            13215: 23077,
+            14202: 22025,
+            14210: 21068,
+            14211: 22069,
+            14214: 23070,
+            15202: 23069,
+            15204: 21063,
+            15205: 21065,
+            15207: 22028,
+            15208: 22049,
+            15209: 22043,
+            15211: 23060,
+            15215: 21062,
+            16207: 21067,
+            16209: 23062,
+            16212: 21066,
+            22096: 23030,
+            22097: 23051,
+        }
+        # Some charts were changed, and others kept the same on these
+        if chart in [0, 1, 2]:
+            legacy_to_modern_map[9206] = 23065
+
+        legacy_songid = legacy_to_modern_map.get(songid)
+        if legacy_songid is not None:
+            old_id = self.get_music_id_for_song(legacy_songid, chart)
+            if old_id is not None:
+                return old_id
+
+        modern_to_legacy_map = {
+            23066: 4213,
+            22068: 9203,
+            22052: 10203,
+            22039: 12201,
+            21201: 12204,
+            21064: 12206,
+            23077: 13215,
+            22025: 14202,
+            21068: 14210,
+            22069: 14211,
+            23070: 14214,
+            23069: 15202,
+            21063: 15204,
+            21065: 15205,
+            22028: 15207,
+            22049: 15208,
+            22043: 15209,
+            23060: 15211,
+            21062: 15215,
+            21067: 16207,
+            23062: 16209,
+            21066: 16212,
+            23030: 22096,
+            23051: 22097,
+        }
+        # Some charts were changed, and others kept the same on tehse
+        if chart in [0, 1, 2]:
+            modern_to_legacy_map[23065] = 9206
+
+        modern_songid = modern_to_legacy_map.get(songid)
+        if modern_songid is not None:
+            old_id = self.get_music_id_for_song(modern_songid, chart)
+            if old_id is not None:
+                return old_id
+
+        # Failed, so create a new one
+        return None
+
+    def __charts(self, songid: int, chart: int) -> int:
+        # Scripted connection long was set as a hyper in Tricoro omnimix, we
+        # need to map the charts to the another in every other version.
+        if songid == 12204:
+            if chart == 1:
+                return 2
+            if chart == 2:
+                return 1
+        return chart
+
+    def scrape(self, binfile: str, assets_dir: Optional[str]) -> List[Dict[str, Any]]:
+        if self.version is None:
+            raise Exception('Can\'t import IIDX database for \'all\' version!')
+
+        if assets_dir is not None:
+            sound_files = self.__gather_sound_files(os.path.abspath(assets_dir))
+        else:
+            sound_files = None
+
+        bh = open(binfile, 'rb')
+        try:
+            binarydata = bh.read()
+        finally:
+            bh.close()
+
+        musicdb = IIDXMusicDB(binarydata)
+        songs: List[Dict[str, Any]] = []
+        for song in musicdb.songs:
+            bpm = (0, 0)
+            notecounts = [0, 0, 0, 0, 0, 0]
+
+            if song.id in self.BANNED_CHARTS:
+                continue
+
+            if sound_files is not None:
+                if song.id in sound_files:
+                    # Look up chart info!
+                    filename = sound_files[song.id]
+                    _, extension = os.path.splitext(filename)
+                    data = None
+
+                    if extension == '.1':
+                        fp = open(filename, 'rb')
+                        data = fp.read()
+                        fp.close()
+                    else:
+                        fp = open(filename, 'rb')
+                        ifsdata = fp.read()
+                        fp.close()
+                        ifs = IFS(ifsdata)
+                        for fn in ifs.filenames:
+                            _, extension = os.path.splitext(fn)
+                            if extension == '.1':
+                                data = ifs.read_file(fn)
+
+                    if data is not None:
+                        iidxchart = IIDXChart(data)
+                        bpm_min, bpm_max = iidxchart.bpm
+                        bpm = (bpm_min, bpm_max)
+                        notecounts = iidxchart.notecounts
+                    else:
+                        print("Could not find chart information for song {}!".format(song.id))
+                else:
+                    print("No chart information because chart for song {} is missing!".format(song.id))
+
+            songs.append({
+                'id': song.id,
+                'title': song.title,
+                'artist': song.artist,
+                'genre': song.genre,
+                'bpm_min': bpm[0],
+                'bpm_max': bpm[1],
+                'difficulty': {
+                    'spn': song.difficulties[0],
+                    'sph': song.difficulties[1],
+                    'spa': song.difficulties[2],
+                    'dpn': song.difficulties[3],
+                    'dph': song.difficulties[4],
+                    'dpa': song.difficulties[5],
+                },
+                'notecount': {
+                    'spn': notecounts[0],
+                    'sph': notecounts[1],
+                    'spa': notecounts[2],
+                    'dpn': notecounts[3],
+                    'dph': notecounts[4],
+                    'dpa': notecounts[5],
+                },
+            })
+        return songs
+
+    def lookup(self, server: str, token: str) -> List[Dict[str, Any]]:
+        if self.version is None:
+            raise Exception('Can\'t look up IIDX database for \'all\' version!')
+
+        # Grab music info from remote server
+        music = self.remote_music(server, token)
+        songs = music.get_all_songs(self.game, self.version)
+        lut: Dict[int, Dict[str, Any]] = {}
+        chart_map = {
+            0: 'spn',
+            1: 'sph',
+            2: 'spa',
+            3: 'dpn',
+            4: 'dph',
+            5: 'dpa',
+        }
+
+        # Format it the way we expect
+        for song in songs:
+            if song.id in self.BANNED_CHARTS:
+                continue
+            if song.chart not in chart_map:
+                # Ignore charts on songs we don't support/care about.
+                continue
+
+            if song.id not in lut:
+                lut[song.id] = {
+                    'id': song.id,
+                    'title': song.name,
+                    'artist': song.artist,
+                    'genre': song.genre,
+                    'bpm_min': song.data.get_int('bpm_min'),
+                    'bpm_max': song.data.get_int('bpm_max'),
+                    'difficulty': {
+                        'spn': 0,
+                        'sph': 0,
+                        'spa': 0,
+                        'dpn': 0,
+                        'dph': 0,
+                        'dpa': 0,
+                    },
+                    'notecount': {
+                        'spn': 0,
+                        'sph': 0,
+                        'spa': 0,
+                        'dpn': 0,
+                        'dph': 0,
+                        'dpa': 0,
+                    },
+                }
+            if song.chart in chart_map:
+                lut[song.id]['difficulty'][chart_map[song.chart]] = song.data.get_int('difficulty')
+                lut[song.id]['notecount'][chart_map[song.chart]] = song.data.get_int('notecount')
+
+        # Return the reassembled data
+        return [val for _, val in lut.items()]
+
+    def import_music_db(self, songs: List[Dict[str, Any]]) -> None:
+        if self.version is None:
+            raise Exception('Can\'t import IIDX database for \'all\' version!')
+
+        # Import each song into our DB
+        chart_map = {
+            0: 'spn',
+            1: 'sph',
+            2: 'spa',
+            3: 'dpn',
+            4: 'dph',
+            5: 'dpa',
+        }
+        for song in songs:
+            self.start_batch()
+            for chart in self.charts:
+                if chart == 6:
+                    # Beginner chart
+                    songdata: Dict[str, Any] = {}
+                else:
+                    songdata = {
+                        'difficulty': song['difficulty'][chart_map[chart]],
+                        'bpm_min': song['bpm_min'],
+                        'bpm_max': song['bpm_max'],
+                        'notecount': song['notecount'][chart_map[chart]],
+                    }
+                # First, try to find in the DB from another version
+                old_id = self.__revivals(song['id'], self.__charts(song['id'], chart))
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(song['id'], chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(song['id'], chart))
+                    next_id = old_id
+                self.insert_music_id_for_song(next_id, song['id'], chart, song['title'], song['artist'], song['genre'], songdata)
+            self.finish_batch()
+
+    def import_metadata(self, tsvfile: str) -> None:
+        if self.version is not None:
+            raise Exception("Unsupported IIDX version, expected one of the following: all")
+
+        with open(tsvfile, newline='') as tsvhandle:
+            iidxreader = csv.reader(tsvhandle, delimiter='\t', quotechar='"')  # type: ignore
+            for row in iidxreader:
+                songid = int(row[0])
+                name = row[1]
+                artist = row[2]
+                genre = row[3]
+
+                if len(name) == 0:
+                    name = None
+                if len(artist) == 0:
+                    artist = None
+                if len(genre) == 0:
+                    genre = None
+
+                print("Setting name/artist/genre for {} all charts".format(songid))
+                self.start_batch()
+                for chart in self.charts:
+                    self.update_metadata_for_song(songid, chart, name, artist, genre)
+                self.finish_batch()
+
+
+class ImportDDR(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        if version in ['12', '13', '14', '15', '16']:
+            actual_version = {
+                '12': VersionConstants.DDR_X2,
+                '13': VersionConstants.DDR_X3_VS_2NDMIX,
+                '14': VersionConstants.DDR_2013,
+                '15': VersionConstants.DDR_2014,
+                '16': VersionConstants.DDR_ACE,
+            }[version]
+            self.charts = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        else:
+            raise Exception("Unsupported DDR version, expected one of the following: 12, 13, 14, 15, 16")
+
+        super().__init__(config, GameConstants.DDR, actual_version, no_combine, update)
+
+    def scrape(self, infile: str) -> List[Dict[str, Any]]:
+        with open(infile, mode="rb") as myfile:
+            data = myfile.read()
+            myfile.close()
+
+        if self.version == VersionConstants.DDR_X2:
+            # Based on JDX:J:A:A:2010111000
+            offset = 0x254fc0
+            size = 0x14C
+            length = 894
+            # Basic stuff like ID, bpm, chart difficulties
+            unpackfmt = '<xxxxxxxxHHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxHHBBBBBBBBBB'
+            # Groove radar
+            unpackfmt += 'HHHHHHHHH' * 5
+            if len(unpackfmt) < size:
+                # Skew is because I'm too lazy to count the Hs above
+                skew = 3 + (9 * 5)
+                # Just pad it for ease of construction
+                unpackfmt = unpackfmt + ('x' * (size - len(unpackfmt) - skew))
+            # Basic offsets
+            id_offset = 1
+            edit_offset = 0
+            bpm_min_offset = 3
+            bpm_max_offset = 2
+            folder_offset = 24  # This is a byte offset into the raw field
+
+            # Single/double difficulty array offsets
+            single_difficulties = 4
+            double_difficulties = 9
+
+            # Groove gauge offsets
+            groove_single_beginner = 22
+            groove_single_basic = 14
+            groove_single_difficult = 15
+            groove_single_expert = 16
+            groove_single_challenge = 17
+
+            groove_double_basic = 18
+            groove_double_difficult = 19
+            groove_double_expert = 20
+            groove_double_challenge = 21
+
+            # Relative offsets for each groove gauge value
+            voltage = 0
+            stream = 9
+            air = 18
+            chaos = 27
+            freeze = 36
+
+            # Folder start version
+            folder_start = 12
+        elif self.version == VersionConstants.DDR_X3_VS_2NDMIX:
+            # Based on KDX:J:A:A:2012112600
+            offset = 0x27A4C8
+            size = 0x150
+            length = 1062
+            # Basic stuff like ID, bpm, chart difficulties
+            unpackfmt = '<xxxxxxxxHHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxHHBBBBBBBBBB'
+            # Groove radar
+            unpackfmt += 'HHHHHHHHH' * 5
+            if len(unpackfmt) < size:
+                # Skew is because I'm too lazy to count the Hs above
+                skew = 3 + (9 * 5)
+                # Just pad it for ease of construction
+                unpackfmt = unpackfmt + ('x' * (size - len(unpackfmt) - skew))
+            # Basic offsets
+            id_offset = 1
+            edit_offset = 0
+            bpm_min_offset = 3
+            bpm_max_offset = 2
+            folder_offset = 24  # This is a byte offset into the raw field
+
+            # Single/double difficulty array offsets
+            single_difficulties = 4
+            double_difficulties = 9
+
+            # Groove gauge offsets
+            groove_single_beginner = 22
+            groove_single_basic = 14
+            groove_single_difficult = 15
+            groove_single_expert = 16
+            groove_single_challenge = 17
+
+            groove_double_basic = 18
+            groove_double_difficult = 19
+            groove_double_expert = 20
+            groove_double_challenge = 21
+
+            # Relative offsets for each groove gauge value
+            voltage = 0
+            stream = 9
+            air = 18
+            chaos = 27
+            freeze = 36
+
+            # Folder start version
+            folder_start = 13
+        elif self.version == VersionConstants.DDR_2013:
+            # Based on MDX:J:A:A:2014032700
+            offset = 0x2663D8
+            size = 0x1D0
+            length = 1238
+            # Basic stuff like ID, bpm, chart difficulties
+            unpackfmt = '<xxxxxxxxHHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxHHBBBBBBBBBB'
+            # Groove radar
+            unpackfmt += 'HHHHHHHHH' * 5
+            if len(unpackfmt) < size:
+                # Skew is because I'm too lazy to count the Hs above
+                skew = 3 + (9 * 5)
+                # Just pad it for ease of construction
+                unpackfmt = unpackfmt + ('x' * (size - len(unpackfmt) - skew))
+            # Basic offsets
+            id_offset = 1
+            edit_offset = 0
+            bpm_min_offset = 3
+            bpm_max_offset = 2
+            folder_offset = 20  # This is a byte offset into the raw field
+
+            # Single/double difficulty array offsets
+            single_difficulties = 4
+            double_difficulties = 9
+
+            # Groove gauge offsets
+            groove_single_beginner = 22
+            groove_single_basic = 14
+            groove_single_difficult = 15
+            groove_single_expert = 16
+            groove_single_challenge = 17
+
+            groove_double_basic = 18
+            groove_double_difficult = 19
+            groove_double_expert = 20
+            groove_double_challenge = 21
+
+            # Relative offsets for each groove gauge value
+            voltage = 0
+            stream = 9
+            air = 18
+            chaos = 27
+            freeze = 36
+
+            # Folder start version
+            folder_start = 14
+        elif self.version == VersionConstants.DDR_2014:
+            # Based on MDX:A:A:A:2015122100
+            offset = 0x2B72B0
+            size = 0x1D0
+            length = 1466
+            # Basic stuff like ID, bpm, chart difficulties
+            unpackfmt = '<xxxxxxxxHHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxHHBBBBBBBBBB'
+            # Groove radar
+            unpackfmt += 'HHHHHHHHH' * 5
+            if len(unpackfmt) < size:
+                # Skew is because I'm too lazy to count the Hs above
+                skew = 3 + (9 * 5)
+                # Just pad it for ease of construction
+                unpackfmt = unpackfmt + ('x' * (size - len(unpackfmt) - skew))
+            # Basic offsets
+            id_offset = 1
+            edit_offset = 0
+            bpm_min_offset = 3
+            bpm_max_offset = 2
+            folder_offset = 20  # This is a byte offset into the raw field
+
+            # Single/double difficulty array offsets
+            single_difficulties = 4
+            double_difficulties = 9
+
+            # Groove gauge offsets
+            groove_single_beginner = 22
+            groove_single_basic = 14
+            groove_single_difficult = 15
+            groove_single_expert = 16
+            groove_single_challenge = 17
+
+            groove_double_basic = 18
+            groove_double_difficult = 19
+            groove_double_expert = 20
+            groove_double_challenge = 21
+
+            # Relative offsets for each groove gauge value
+            voltage = 0
+            stream = 9
+            air = 18
+            chaos = 27
+            freeze = 36
+
+            # Folder start version
+            folder_start = 15
+        else:
+            raise Exception('Unknown game version!')
+        songs = []
+
+        for i in range(length):
+            start = offset + (i * size)
+            end = offset + ((i + 1) * size)
+            chunk = data[start:end]
+
+            # First, figure out if it is actually a song
+            ssqcode = chunk[0:6].decode('ascii').replace('\0', '').strip()
+            if len(ssqcode) == 0:
+                continue
+            unpacked = struct.unpack(unpackfmt, chunk)
+            songinfo = {
+                'id': unpacked[id_offset],
+                'edit_id': unpacked[edit_offset],
+                'ssqcode': ssqcode,
+                'difficulty': {
+                    'single': {
+                        'beginner': unpacked[single_difficulties + 0],
+                        'basic': unpacked[single_difficulties + 1],
+                        'difficult': unpacked[single_difficulties + 2],
+                        'expert': unpacked[single_difficulties + 3],
+                        'challenge': unpacked[single_difficulties + 4],
+                    },
+                    'double': {
+                        'beginner': unpacked[double_difficulties + 0],
+                        'basic': unpacked[double_difficulties + 1],
+                        'difficult': unpacked[double_difficulties + 2],
+                        'expert': unpacked[double_difficulties + 3],
+                        'challenge': unpacked[double_difficulties + 4],
+                    },
+                },
+                'groove_gauge': {
+                    'single': {
+                        'beginner': {
+                            'voltage': unpacked[groove_single_beginner + voltage],
+                            'stream': unpacked[groove_single_beginner + stream],
+                            'air': unpacked[groove_single_beginner + air],
+                            'chaos': unpacked[groove_single_beginner + chaos],
+                            'freeze': unpacked[groove_single_beginner + freeze],
+                        },
+                        'basic': {
+                            'voltage': unpacked[groove_single_basic + voltage],
+                            'stream': unpacked[groove_single_basic + stream],
+                            'air': unpacked[groove_single_basic + air],
+                            'chaos': unpacked[groove_single_basic + chaos],
+                            'freeze': unpacked[groove_single_basic + freeze],
+                        },
+                        'difficult': {
+                            'voltage': unpacked[groove_single_difficult + voltage],
+                            'stream': unpacked[groove_single_difficult + stream],
+                            'air': unpacked[groove_single_difficult + air],
+                            'chaos': unpacked[groove_single_difficult + chaos],
+                            'freeze': unpacked[groove_single_difficult + freeze],
+                        },
+                        'expert': {
+                            'voltage': unpacked[groove_single_expert + voltage],
+                            'stream': unpacked[groove_single_expert + stream],
+                            'air': unpacked[groove_single_expert + air],
+                            'chaos': unpacked[groove_single_expert + chaos],
+                            'freeze': unpacked[groove_single_expert + freeze],
+                        },
+                        'challenge': {
+                            'voltage': unpacked[groove_single_challenge + voltage],
+                            'stream': unpacked[groove_single_challenge + stream],
+                            'air': unpacked[groove_single_challenge + air],
+                            'chaos': unpacked[groove_single_challenge + chaos],
+                            'freeze': unpacked[groove_single_challenge + freeze],
+                        },
+                    },
+                    'double': {
+                        'beginner': {
+                            'voltage': 0,
+                            'stream': 0,
+                            'air': 0,
+                            'chaos': 0,
+                            'freeze': 0,
+                        },
+                        'basic': {
+                            'voltage': unpacked[groove_double_basic + voltage],
+                            'stream': unpacked[groove_double_basic + stream],
+                            'air': unpacked[groove_double_basic + air],
+                            'chaos': unpacked[groove_double_basic + chaos],
+                            'freeze': unpacked[groove_double_basic + freeze],
+                        },
+                        'difficult': {
+                            'voltage': unpacked[groove_double_difficult + voltage],
+                            'stream': unpacked[groove_double_difficult + stream],
+                            'air': unpacked[groove_double_difficult + air],
+                            'chaos': unpacked[groove_double_difficult + chaos],
+                            'freeze': unpacked[groove_double_difficult + freeze],
+                        },
+                        'expert': {
+                            'voltage': unpacked[groove_double_expert + voltage],
+                            'stream': unpacked[groove_double_expert + stream],
+                            'air': unpacked[groove_double_expert + air],
+                            'chaos': unpacked[groove_double_expert + chaos],
+                            'freeze': unpacked[groove_double_expert + freeze],
+                        },
+                        'challenge': {
+                            'voltage': unpacked[groove_double_challenge + voltage],
+                            'stream': unpacked[groove_double_challenge + stream],
+                            'air': unpacked[groove_double_challenge + air],
+                            'chaos': unpacked[groove_double_challenge + chaos],
+                            'freeze': unpacked[groove_double_challenge + freeze],
+                        },
+                    },
+                },
+                'bpm_min': unpacked[bpm_min_offset],
+                'bpm_max': unpacked[bpm_max_offset],
+                'folder': folder_start - chunk[folder_offset],
+            }
+            songs.append(songinfo)
+        return songs
+
+    def hydrate(self, songs: List[Dict[str, Any]], infile: str) -> List[Dict[str, Any]]:
+        tree = ET.parse(infile)
+        root = tree.getroot()
+        data = {}
+        for music_entry in root.find('mdblist'):
+            musicid = int(music_entry.attrib['reclink'])
+            title = ''
+            artist = ''
+            title_en = ''
+            artist_en = ''
+
+            for child in music_entry:
+                if child.tag == 'name':
+                    if child.attrib['lang'] == 'ja':
+                        title = child.text
+                    else:
+                        title_en = child.text
+                if child.tag == 'artist':
+                    if child.attrib['lang'] == 'ja':
+                        artist = child.text
+                    else:
+                        artist_en = child.text
+
+            data[musicid] = {
+                'title': title,
+                'artist': artist,
+                'title_en': title_en,
+                'artist_en': artist_en,
+            }
+
+        songs = copy.deepcopy(songs)
+        for song in songs:
+            newdata = data.get(song['id'])
+            if newdata is not None:
+                song.update(newdata)
+
+        return songs
+
+    def parse_xml(self, arcfile: str) -> List[Dict[str, Any]]:
+        with open(arcfile, mode="rb") as myfile:
+            data = myfile.read()
+            myfile.close()
+
+        arc = ARC(data)
+        if 'data/gamedata/musicdb.xml' in arc.filenames:
+            xmldata = arc.read_file('data/gamedata/musicdb.xml')
+        else:
+            raise Exception('Invalid .arc file provided!')
+
+        xml = xmldata.decode('utf-8')
+        root = ET.fromstring(xml)
+        songs = []
+
+        if root.tag != 'mdb':
+            raise Exception('Invalid musicdb.xml file in .arc!')
+
+        for music_entry in root:
+            songid = int(music_entry.find('mcode').text)
+            title = music_entry.find('title').text
+            artist = music_entry.find('artist').text
+            ssqcode = music_entry.find('basename').text
+            bpm = int(music_entry.find('bpmmax').text)
+            folder = int(music_entry.find('series').text)
+            difficulties = [int(x) for x in music_entry.find('diffLv').text.split(' ')]
+
+            # For some reason Ace thinks of itself as 17, and DDR 2013/2014 as 14, 15 and 16
+            # somewhat spread out. Fix that here.
+            folder = {
+                1: 1,
+                2: 2,
+                3: 3,
+                4: 4,
+                5: 5,
+                6: 6,
+                7: 7,
+                8: 8,
+                9: 9,
+                10: 10,
+                11: 11,
+                12: 12,
+                13: 13,
+                14: 14,
+                15: 15,
+                16: 15,
+                17: 16,
+                18: 17,
+            }[folder]
+
+            songinfo = {
+                'id': songid,
+                'edit_id': songid,
+                'ssqcode': ssqcode,
+                'title': title,
+                'artist': artist,
+                'difficulty': {
+                    'single': {
+                        'beginner': difficulties[0],
+                        'basic': difficulties[1],
+                        'difficult': difficulties[2],
+                        'expert': difficulties[3],
+                        'challenge': difficulties[4],
+                    },
+                    'double': {
+                        'beginner': difficulties[5],
+                        'basic': difficulties[6],
+                        'difficult': difficulties[7],
+                        'expert': difficulties[8],
+                        'challenge': difficulties[9],
+                    },
+                },
+                'bpm_min': bpm,
+                'bpm_max': bpm,
+                'folder': folder,
+                'groove_gauge': {},
+            }
+
+            # Groove information is calculated on the fly, maybe some day we will
+            # duplicate that here, but for now, zero it out.
+            for playmode in ['single', 'double']:
+                songinfo['groove_gauge'][playmode] = {}  # type: ignore
+
+                for charttype in ['beginner', 'basic', 'difficult', 'expert', 'challenge']:
+                    songinfo['groove_gauge'][playmode][charttype] = {  # type: ignore
+                        'voltage': 0,
+                        'stream': 0,
+                        'air': 0,
+                        'chaos': 0,
+                        'freeze': 0,
+                    }
+
+            songs.append(songinfo)
+
+        return songs
+
+    def lookup(self, server: str, token: str) -> List[Dict[str, Any]]:
+        # Grab music info from remote server
+        music = self.remote_music(server, token)
+        songs = music.get_all_songs(self.game, self.version)
+        lut: Dict[int, Dict[str, Any]] = {}
+        chart_map = {
+            0: ('single', 'beginner'),
+            1: ('single', 'basic'),
+            2: ('single', 'difficult'),
+            3: ('single', 'expert'),
+            4: ('single', 'challenge'),
+            5: ('double', 'beginner'),
+            6: ('double', 'basic'),
+            7: ('double', 'difficult'),
+            8: ('double', 'expert'),
+            9: ('double', 'challenge'),
+        }
+
+        # Format it the way we expect
+        for song in songs:
+            if song.chart not in chart_map:
+                # Ignore charts on songs we don't support/care about.
+                continue
+
+            if song.id not in lut:
+                lut[song.id] = {
+                    'id': song.id,
+                    'edit_id': song.data.get_int('edit_id'),
+                    'ssqcode': '',
+                    'title': song.name,
+                    'artist': song.artist,
+                    'difficulty': {
+                        'single': {
+                            'beginner': 0,
+                            'basic': 0,
+                            'difficult': 0,
+                            'expert': 0,
+                            'challenge': 0,
+                        },
+                        'double': {
+                            'beginner': 0,
+                            'basic': 0,
+                            'difficult': 0,
+                            'expert': 0,
+                            'challenge': 0,
+                        },
+                    },
+                    'groove_gauge': {
+                        'single': {
+                            'beginner': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'basic': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'difficult': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'expert': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'challenge': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                        },
+                        'double': {
+                            'beginner': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'basic': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'difficult': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'expert': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                            'challenge': {
+                                'voltage': 0,
+                                'stream': 0,
+                                'air': 0,
+                                'chaos': 0,
+                                'freeze': 0,
+                            },
+                        },
+                    },
+                    'bpm_min': song.data.get_int('bpm_min'),
+                    'bpm_max': song.data.get_int('bpm_max'),
+                    'folder': song.data.get_int('category'),
+                }
+            style, chart = chart_map[song.chart]
+            lut[song.id]['difficulty'][style][chart] = song.data.get_int('difficulty')
+            lut[song.id]['groove_gauge'][style][chart]['air'] = song.data.get_dict('groove').get_int('air')
+            lut[song.id]['groove_gauge'][style][chart]['chaos'] = song.data.get_dict('groove').get_int('chaos')
+            lut[song.id]['groove_gauge'][style][chart]['freeze'] = song.data.get_dict('groove').get_int('freeze')
+            lut[song.id]['groove_gauge'][style][chart]['stream'] = song.data.get_dict('groove').get_int('stream')
+            lut[song.id]['groove_gauge'][style][chart]['voltage'] = song.data.get_dict('groove').get_int('voltage')
+
+        # Return the reassembled data
+        return [val for _, val in lut.items()]
+
+    def import_music_db(self, songs: List[Dict[str, Any]]) -> None:
+        for song in songs:
+            self.start_batch()
+            for chart in self.charts:
+                key = ['beginner', 'basic', 'difficult', 'expert', 'challenge']
+
+                if chart in [0, 1, 2, 3, 4]:
+                    # For singles only!
+                    difficulty = song['difficulty']['single'][key[chart]]
+                    groovestats = song['groove_gauge']['single'][key[chart]]
+                elif chart in [5, 6, 7, 8, 9]:
+                    # Doubles!
+                    difficulty = song['difficulty']['double'][key[chart - 5]]
+                    groovestats = song['groove_gauge']['double'][key[chart - 5]]
+                else:
+                    raise Exception('Unrecognized chart type!')
+
+                if difficulty == 0:
+                    # No chart for this difficulty
+                    continue
+
+                if song['edit_id'] == 0:
+                    raise Exception('Expected non-zero edit id!')
+
+                # DDR is stupid and changes in-game IDs around willy-nilly, but the edit ID is stable.
+                # So, create a virtual edit ID entry and link everything to that. We can't just store
+                # the edit ID as the real ID because in-game the protocol uses the changing ID.
+                old_id = self.get_music_id_for_song(song['edit_id'], chart, version=0)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} {} ({} chart {})".format(song['title'], song['artist'], song['id'], chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    print("Reused entry for {} {} ({} chart {})".format(song['title'], song['artist'], song['id'], chart))
+                    next_id = old_id
+                # Add the virtual entry we talked about above, so we can link this song in the future.
+                self.insert_music_id_for_song(
+                    next_id,
+                    song['edit_id'],
+                    chart,
+                    song['title'],
+                    song['artist'],
+                    None,  # No genres in DDR
+                    {
+                        'category': song['folder'],
+                        'bpm_min': song['bpm_min'],
+                        'bpm_max': song['bpm_max'],
+                        'difficulty': difficulty,
+                        'groove': groovestats,
+                        'edit_id': song['edit_id'],
+                    },
+                    version=0,
+                )
+                # Add the normal entry so the game finds the song.
+                self.insert_music_id_for_song(
+                    next_id,
+                    song['id'],
+                    chart,
+                    song['title'],
+                    song['artist'],
+                    None,  # No genres in DDR
+                    {
+                        'category': song['folder'],
+                        'bpm_min': song['bpm_min'],
+                        'bpm_max': song['bpm_max'],
+                        'difficulty': difficulty,
+                        'groove': groovestats,
+                        'edit_id': song['edit_id'],
+                    },
+                )
+            self.finish_batch()
+
+
+class ImportSDVX(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        actual_version = {
+            '1': VersionConstants.SDVX_BOOTH,
+            '2': VersionConstants.SDVX_INFINITE_INFECTION,
+            '3': VersionConstants.SDVX_GRAVITY_WARS,
+            '4': VersionConstants.SDVX_HEAVENLY_HAVEN,
+        }.get(version, -1)
+        if actual_version == VersionConstants.SDVX_BOOTH:
+            self.charts = [0, 1, 2]
+        elif actual_version in [VersionConstants.SDVX_INFINITE_INFECTION, VersionConstants.SDVX_GRAVITY_WARS]:
+            self.charts = [0, 1, 2, 3]
+        elif actual_version == VersionConstants.SDVX_HEAVENLY_HAVEN:
+            self.charts = [0, 1, 2, 3, 4]
+        else:
+            raise Exception("Unsupported SDVX version, expected one of the following: 1, 2, 3, 4!")
+
+        super().__init__(config, GameConstants.SDVX, actual_version, no_combine, update)
+
+    def scrape(self, infile: str) -> List[Dict[str, Any]]:
+        with open(infile, mode="rb") as myfile:
+            data = myfile.read()
+            myfile.close()
+
+        pe = pefile.PE(data=data, fast_load=True)
+
+        def virtual_to_physical(offset: int) -> int:
+            for section in pe.sections:
+                start = section.VirtualAddress + pe.OPTIONAL_HEADER.ImageBase
+                end = start + section.SizeOfRawData
+
+                if offset >= start and offset < end:
+                    return (offset - start) + section.PointerToRawData
+            raise Exception('Couldn\'t find raw offset for virtual offset 0x{:08x}'.format(offset))
+
+        if self.version == VersionConstants.SDVX_BOOTH:
+            offset = 0xFFF28
+            size = 163
+            stride = 40
+        else:
+            raise Exception('Unsupported version for catalog scrape!')
+
+        def read_string(spot: int) -> str:
+            # First, translate load offset in memory to disk offset
+            spot = virtual_to_physical(spot)
+
+            # Now, grab bytes until we're null-terminated
+            bytestring = []
+            while data[spot] != 0:
+                bytestring.append(data[spot])
+                spot = spot + 1
+
+            return bytes(bytestring).decode('shift_jis')
+
+        entries = []
+        for i in range(size):
+            start = offset + i * stride
+            end = offset + (i + 1) * stride
+            chunk = data[start:end]
+
+            values = struct.unpack('<IIIIIIIIII', chunk)
+            # Price looks to be fixed here, assert it so we catch problems
+            if values[3] != values[4]:
+                raise Exception('Expected price values to match!')
+            entry = {
+                'catalogid': values[0],
+                'musicid': values[1],
+                'chart': values[2],
+                'price': values[3],
+                'condition_jp': read_string(values[8]),
+                'condition_en': read_string(values[9]),
+            }
+            entries.append(entry)
+        return entries
+
+    def import_catalog(self, dllfile: str) -> None:
+        entries = self.scrape(dllfile)
+
+        for entry in entries:
+            self.start_batch()
+            print("New catalog entry for {} chart {}".format(entry['musicid'], entry['chart']))
+            self.insert_catalog_entry(
+                'song_unlock',
+                entry['catalogid'],
+                {
+                    'blocks': entry['price'],
+                    'musicid': entry['musicid'],
+                    'chart': entry['chart'],
+                },
+            )
+            self.finish_batch()
+
+    def import_appeal_cards(self, csvfile: str) -> None:
+        with open(csvfile, 'rb') as csvhandle:
+            csvdata = csvhandle.read().decode('shift_jisx0213')
+
+        csvstr = io.StringIO(csvdata)
+        appealreader = csv.reader(csvstr, delimiter=',', quotechar='"')  # type: ignore
+        for row in appealreader:
+            appealids = []
+            if self.version == VersionConstants.SDVX_INFINITE_INFECTION:
+                try:
+                    appealids.append(int(row[-5]))
+                except (TypeError, ValueError):
+                    pass
+            elif self.version == VersionConstants.SDVX_GRAVITY_WARS:
+                try:
+                    appealids.append(int(row[-9]))
+                except (TypeError, ValueError):
+                    pass
+            else:
+                raise Exception('Cannot import appeal cards for SDVX version {}'.format(self.version))
+
+            self.start_batch()
+            for appealid in appealids:
+                print("New catalog entry for appeal card {}".format(appealid))
+                self.insert_catalog_entry(
+                    'appealcard',
+                    appealid,
+                    {},
+                )
+            self.finish_batch()
+
+    def import_music_db_or_appeal_cards(self, xmlfile: str) -> None:
+        with open(xmlfile, 'rb') as fp:
+            # This is gross, but elemtree won't do it for us so whatever
+            bytedata = fp.read()
+            strdata = bytedata.decode('shift_jisx0213', errors='replace')
+        root = ET.fromstring(strdata)
+
+        for music_entry in root.findall('music'):
+            # Grab the ID
+            songid = int(music_entry.attrib['id'])
+            title = None
+            artist = None
+            bpm_min = None
+            bpm_max = None
+            limited = [0, 0, 0, 0, 0]
+            difficulties = [0, 0, 0, 0, 0]
+
+            if self.version == VersionConstants.SDVX_BOOTH:
+                # Find normal info about the song
+                for info in music_entry.findall('info'):
+                    if info.attrib['attr'] == 'title_yomigana':
+                        title = jaconv.h2z(info.text)
+                    if info.attrib['attr'] == 'artist_yomigana':
+                        artist = jaconv.h2z(info.text)
+                    if info.attrib['attr'] == 'bpm_min':
+                        bpm_min = float(info.text)
+                    if info.attrib['attr'] == 'bpm_max':
+                        bpm_max = float(info.text)
+                    if info.attrib['attr'] == 'limited':
+                        limited = [int(info.text), int(info.text), int(info.text), int(info.text)]
+                # Make sure we got everything
+                if title is None or artist is None or bpm_min is None or bpm_max is None:
+                    raise Exception('Couldn\'t parse info for song {}'.format(songid))
+
+                # Grab valid difficulties
+                for difficulty in music_entry.findall('difficulty'):
+                    # Figure out the actual difficulty
+                    offset = {
+                        'novice': 0,
+                        'advanced': 1,
+                        'exhaust': 2,
+                    }.get(difficulty.attrib['attr'])
+                    if offset is None:
+                        continue
+
+                    difficulties[offset] = int(difficulty.find('difnum').text)
+            elif self.version in [VersionConstants.SDVX_INFINITE_INFECTION, VersionConstants.SDVX_GRAVITY_WARS]:
+                # Find normal info about the song
+                info = music_entry.find('info')
+                title = info.find('title_name').text
+                artist = info.find('artist_name').text
+                bpm_min = float(info.find('bpm_min').text) / 100.0
+                bpm_max = float(info.find('bpm_max').text) / 100.0
+
+                # Grab valid difficulties
+                for difficulty in music_entry.find('difficulty'):
+                    # Figure out the actual difficulty
+                    offset = {
+                        'novice': 0,
+                        'advanced': 1,
+                        'exhaust': 2,
+                        'infinite': 3,
+                    }.get(difficulty.tag)
+                    if offset is None:
+                        continue
+
+                    difficulties[offset] = int(difficulty.find('difnum').text)
+                    limited[offset] = int(difficulty.find('limited').text)
+            elif self.version == VersionConstants.SDVX_HEAVENLY_HAVEN:
+                # Find normal info about the song
+                info = music_entry.find('info')
+                title = info.find('title_name').text
+                artist = info.find('artist_name').text
+                bpm_min = float(info.find('bpm_min').text) / 100.0
+                bpm_max = float(info.find('bpm_max').text) / 100.0
+
+                # Grab valid difficulties
+                for difficulty in music_entry.find('difficulty'):
+                    # Figure out the actual difficulty
+                    offset = {
+                        'novice': 0,
+                        'advanced': 1,
+                        'exhaust': 2,
+                        'infinite': 3,
+                        'maximum': 4,
+                    }.get(difficulty.tag)
+                    if offset is None:
+                        continue
+
+                    difficulties[offset] = int(difficulty.find('difnum').text)
+                    limited[offset] = int(difficulty.find('limited').text)
+
+            # Fix accent issues with title/artist
+            accent_lut: Dict[str, str] = {
+                '驩': 'Ø',
+                '齲': '♥',
+                '齶': '♡',
+                '趁': 'Ǣ',
+                '騫': 'á',
+                '曦': 'à',
+                '驫': 'ā',
+                '齷': 'é',
+                '曩': 'è',
+                '䧺': 'ê',
+                '骭': 'ü',
+            }
+
+            for orig, rep in accent_lut.items():
+                title = title.replace(orig, rep)
+                artist = artist.replace(orig, rep)
+
+            # Import it
+            self.start_batch()
+            for chart in self.charts:
+                # First, try to find in the DB from another version
+                old_id = self.get_music_id_for_song(songid, chart)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(songid, chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(songid, chart))
+                    next_id = old_id
+                data = {
+                    'limited': limited[chart],
+                    'difficulty': difficulties[chart],
+                    'bpm_min': bpm_min,
+                    'bpm_max': bpm_max,
+                }
+                self.insert_music_id_for_song(next_id, songid, chart, title, artist, None, data)
+            self.finish_batch()
+
+        appealids: List[int] = []
+        for appeal_entry in root.findall('card'):
+            # Grab the ID
+            appealids.append(int(appeal_entry.attrib['id']))
+
+        if appealids:
+            self.start_batch()
+            for appealid in appealids:
+                print("New catalog entry for appeal card {}".format(appealid))
+                self.insert_catalog_entry(
+                    'appealcard',
+                    appealid,
+                    {},
+                )
+            self.finish_batch()
+
+    def import_from_server(self, server: str, token: str) -> None:
+        # First things first, lets try to import the music DB. We want to make
+        # sure that even if the server doesn't respond right, we have a chart
+        # entry for every chart for each song we're importing.
+        music = self.remote_music(server, token)
+        music_lut: Dict[int, Dict[int, Song]] = {}
+        for entry in music.get_all_songs(self.game, self.version):
+            if entry.id not in music_lut:
+                music_lut[entry.id] = {
+                    chart: Song(
+                        entry.game,
+                        entry.version,
+                        entry.id,
+                        chart,
+                        entry.name,
+                        entry.artist,
+                        entry.genre,
+                        {}
+                    ) for chart in self.charts
+                }
+            music_lut[entry.id][entry.chart] = entry
+
+        # Import it
+        for _, songs in music_lut.items():
+            self.start_batch()
+            for _, song in songs.items():
+                old_id = self.get_music_id_for_song(song.id, song.chart)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(song.id, song.chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(song.id, song.chart))
+                    next_id = old_id
+                data = {
+                    'limited': song.data.get_int('limited'),
+                    'difficulty': song.data.get_int('difficulty'),
+                    'bpm_min': song.data.get_int('bpm_min'),
+                    'bpm_max': song.data.get_int('bpm_max'),
+                }
+                self.insert_music_id_for_song(next_id, song.id, song.chart, song.name, song.artist, None, data)
+            self.finish_batch()
+
+        # Now, attempt to insert any catalog items we got for this version.
+        game = self.remote_game(server, token)
+        self.start_batch()
+        for item in game.get_items(self.game, self.version):
+            if item.type == "appealcard":
+                print("New catalog entry for appeal card {}".format(item.id))
+                self.insert_catalog_entry(
+                    'appealcard',
+                    item.id,
+                    {},
+                )
+            elif item.type == "song_unlock":
+                print("New catalog entry for {} chart {}".format(item.data.get_int('musicid'), item.data.get_int('chart')))
+                self.insert_catalog_entry(
+                    'song_unlock',
+                    item.id,
+                    {
+                        'blocks': item.data.get_int('blocks'),
+                        'musicid': item.data.get_int('musicid'),
+                        'chart': item.data.get_int('chart'),
+                    },
+                )
+        self.finish_batch()
+
+
+class ImportMuseca(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        actual_version = {
+            '1': VersionConstants.MUSECA,
+            '1+1/2': VersionConstants.MUSECA_1_PLUS,
+        }.get(version, -1)
+
+        if actual_version in [VersionConstants.MUSECA, VersionConstants.MUSECA_1_PLUS]:
+            self.charts = [0, 1, 2, 3]
+        else:
+            raise Exception("Unsupported Museca version, expected one of the following: 1, 1+1/2!")
+
+        super().__init__(config, GameConstants.MUSECA, actual_version, no_combine, update)
+
+    def import_music_db(self, xmlfile: str) -> None:
+        with open(xmlfile, 'rb') as fp:
+            # This is gross, but elemtree won't do it for us so whatever
+            bytedata = fp.read()
+            strdata = bytedata.decode('shift_jisx0213')
+        root = ET.fromstring(strdata)
+
+        for music_entry in root.findall('music'):
+            # Grab the ID
+            songid = int(music_entry.attrib['id'])
+            title = None
+            artist = None
+            bpm_min = None
+            bpm_max = None
+            limited = [0, 0, 0, 0]
+            difficulties = [0, 0, 0, 0]
+
+            # Find normal info about the song
+            info = music_entry.find('info')
+            title = info.find('title_name').text
+            artist = info.find('artist_name').text
+            bpm_min = float(info.find('bpm_min').text) / 100.0
+            bpm_max = float(info.find('bpm_max').text) / 100.0
+
+            # Grab valid difficulties
+            for difficulty in music_entry.find('difficulty'):
+                # Figure out the actual difficulty
+                offset = {
+                    'novice': 0,
+                    'advanced': 1,
+                    'exhaust': 2,
+                    'infinite': 3,
+                }.get(difficulty.tag)
+                if offset is None:
+                    continue
+
+                difficulties[offset] = int(difficulty.find('difnum').text)
+                limited[offset] = int(difficulty.find('limited').text)
+
+            # Import it
+            self.start_batch()
+            for chart in self.charts:
+                # First, try to find in the DB from another version
+                old_id = self.get_music_id_for_song(songid, chart)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(songid, chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(songid, chart))
+                    next_id = old_id
+                data = {
+                    'limited': limited[chart],
+                    'difficulty': difficulties[chart],
+                    'bpm_min': bpm_min,
+                    'bpm_max': bpm_max,
+                }
+                self.insert_music_id_for_song(next_id, songid, chart, title, artist, None, data)
+            self.finish_batch()
+
+    def import_from_server(self, server: str, token: str) -> None:
+        # First things first, lets try to import the music DB. We want to make
+        # sure that even if the server doesn't respond right, we have a chart
+        # entry for every chart for each song we're importing.
+        music = self.remote_music(server, token)
+        music_lut: Dict[int, Dict[int, Song]] = {}
+        for entry in music.get_all_songs(self.game, self.version):
+            if entry.id not in music_lut:
+                music_lut[entry.id] = {
+                    chart: Song(
+                        entry.game,
+                        entry.version,
+                        entry.id,
+                        chart,
+                        entry.name,
+                        entry.artist,
+                        entry.genre,
+                        {}
+                    ) for chart in self.charts
+                }
+            music_lut[entry.id][entry.chart] = entry
+
+        # Import it
+        for _, songs in music_lut.items():
+            self.start_batch()
+            for _, song in songs.items():
+                # First, try to find in the DB from another version
+                old_id = self.get_music_id_for_song(song.id, song.chart)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(song.id, song.chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(song.id, song.chart))
+                    next_id = old_id
+                data = {
+                    'limited': song.data.get_int('limited'),
+                    'difficulty': song.data.get_int('difficulty'),
+                    'bpm_min': song.data.get_int('bpm_min'),
+                    'bpm_max': song.data.get_int('bpm_max'),
+                }
+                self.insert_music_id_for_song(next_id, song.id, song.chart, song.name, song.artist, None, data)
+            self.finish_batch()
+
+
+class ImportReflecBeat(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        # We always have 4 charts, even if we're importing from Colette and below,
+        # so that we guarantee a stable song ID. We'll be in trouble if Reflec
+        # ever adds a fifth chart.
+        if version in ['1', '2', '3', '4', '5', '6']:
+            actual_version = {
+                '1': VersionConstants.REFLEC_BEAT,
+                '2': VersionConstants.REFLEC_BEAT_LIMELIGHT,
+                '3': VersionConstants.REFLEC_BEAT_COLETTE,
+                '4': VersionConstants.REFLEC_BEAT_GROOVIN,
+                '5': VersionConstants.REFLEC_BEAT_VOLZZA,
+                '6': VersionConstants.REFLEC_BEAT_VOLZZA_2,
+            }[version]
+            self.charts = [0, 1, 2, 3]
+        else:
+            raise Exception("Unsupported ReflecBeat version, expected one of the following: 1, 2, 3, 4, 5, 6")
+
+        super().__init__(config, GameConstants.REFLEC_BEAT, actual_version, no_combine, update)
+
+    def scrape(self, infile: str) -> List[Dict[str, Any]]:
+        with open(infile, mode="rb") as myfile:
+            data = myfile.read()
+            myfile.close()
+
+        if self.version == VersionConstants.REFLEC_BEAT:
+            # Based on KBR:A:A:A:2011112300
+            offset = 0xBFBD0
+            stride = 280
+            max_songs = 93
+            max_difficulties = 3
+
+            song_offset = 0x4C
+            song_length = 0x40
+            # Artists aren't included in this mix.
+            artist_offset = None
+            artist_length = None
+            chart_offset = 0xD5
+            chart_length = 0x20
+            difficulties_offset = 0xD2
+        elif self.version == VersionConstants.REFLEC_BEAT_LIMELIGHT:
+            # Based on LBR:A:A:A:2012082900
+            offset = 0x132C48
+            stride = 220
+            max_songs = 191
+            max_difficulties = 3
+
+            song_offset = 0x4C
+            song_length = 0x40
+            # Artists aren't included in this mix.
+            artist_offset = None
+            artist_length = None
+            chart_offset = 0x9B
+            chart_length = 0x20
+            difficulties_offset = 0x98
+        elif self.version == VersionConstants.REFLEC_BEAT_COLETTE:
+            # Based on MBR:J:A:A:2014011600
+            offset = 0x1E6880
+            stride = 468
+            max_songs = 443
+            max_difficulties = 3
+
+            song_offset = 0x34
+            song_length = 0x80
+            artist_offset = 0xB4
+            artist_length = 0x80
+            chart_offset = 0x1b4
+            chart_length = 0x20
+            difficulties_offset = 0x1A8
+        elif self.version == VersionConstants.REFLEC_BEAT_GROOVIN:
+            # Based on MBR:J:A:A:2015102100
+            offset = 0x212EC0
+            stride = 524
+            max_songs = 698
+            max_difficulties = 4
+
+            song_offset = 0x3C
+            song_length = 0x80
+            artist_offset = 0xBC
+            artist_length = 0x80
+            chart_offset = 0x1E8
+            chart_length = 0x20
+            difficulties_offset = 0x1D0
+        elif self.version == VersionConstants.REFLEC_BEAT_VOLZZA:
+            # Based on MBR:J:A:A:2016030200
+            offset = 0x1A0EC8
+            stride = 552
+            max_songs = 805
+            max_difficulties = 4
+
+            song_offset = 0x38
+            song_length = 0x80
+            artist_offset = 0xB8
+            artist_length = 0x80
+            chart_offset = 0x1E4
+            chart_length = 0x20
+            difficulties_offset = 0x1CC
+        elif self.version == VersionConstants.REFLEC_BEAT_VOLZZA_2:
+            # Based on MBR:J:A:A:2016100400
+            offset = 0x1CBC68
+            stride = 552
+            max_songs = 850
+            max_difficulties = 4
+
+            song_offset = 0x38
+            song_length = 0x80
+            artist_offset = 0xB8
+            artist_length = 0x80
+            chart_offset = 0x1E4
+            chart_length = 0x20
+            difficulties_offset = 0x1CC
+        else:
+            raise Exception('Unsupported ReflecBeat version {}'.format(self.version))
+
+        def convert_string(inb: bytes) -> str:
+            end = None
+            for i in range(len(inb)):
+                if inb[i] == 0:
+                    end = i
+                    break
+            if end is None:
+                raise Exception('Invalid string!')
+            if end == 0:
+                return ''
+
+            return inb[:end].decode('shift_jisx0213')
+
+        def convert_version(songid: int, folder: int) -> int:
+            if self.version == VersionConstants.REFLEC_BEAT_VOLZZA_2:
+                # Reflec Volzza 2 appears from network and DLL perspective to be identical
+                # to Volzza 1, including what version the game thinks it is for songs. So,
+                # hard code the new song IDs so we can show the difference on the frontend.
+                if folder == 5:
+                    if songid in [733, 760, 772, 773, 774, 782, 785, 786]:
+                        return 6
+                    if songid >= 788:
+                        return 6
+
+            return folder
+
+        songs = []
+        for i in range(max_songs):
+            start = offset + (stride * i)
+            end = start + stride
+            songdata = data[start:end]
+
+            title = convert_string(songdata[song_offset:(song_offset + song_length)])
+            if artist_offset is None:
+                artist = ''
+            else:
+                artist = convert_string(songdata[artist_offset:(artist_offset + artist_length)])
+            if title == '' and artist == '':
+                continue
+            songid = struct.unpack('<I', songdata[0:4])[0]
+            chart = convert_string(songdata[chart_offset:(chart_offset + chart_length)])
+            difficulties = [d for d in songdata[difficulties_offset:(difficulties_offset + max_difficulties)]]
+            difficulties = [0 if d == 255 else d for d in difficulties]
+            folder = convert_version(songid, int(chart[0]))
+
+            while len(difficulties) < 4:
+                difficulties.append(0)
+
+            songs.append({
+                'id': songid,
+                'title': title,
+                'artist': artist,
+                'chartid': chart[:4],
+                'difficulties': difficulties,
+                'folder': folder,
+            })
+        return songs
+
+    def lookup(self, server: str, token: str) -> List[Dict[str, Any]]:
+        # Grab music info from remote server
+        music = self.remote_music(server, token)
+        songs = music.get_all_songs(self.game, self.version)
+        lut: Dict[int, Dict[str, Any]] = {}
+        for song in songs:
+            if song.id not in lut:
+                lut[song.id] = {
+                    'id': song.id,
+                    'title': song.name,
+                    'artist': song.artist,
+                    'chartid': song.data.get_str('chart_id'),
+                    'difficulties': [0] * len(self.charts),
+                    'folder': song.data.get_int('folder'),
+                }
+            lut[song.id]['difficulties'][song.chart] = song.data.get_int('difficulty')
+
+        # Return the reassembled data
+        return [val for _, val in lut.items()]
+
+    def import_music_db(self, songs: List[Dict[str, Any]]) -> None:
+        for song in songs:
+            self.start_batch()
+            for chart in self.charts:
+                songid = song['id']
+                chartid = song['chartid']
+
+                # ReflecBeat re-numbers some of their songs and overlaps with IDs from older
+                # versions, so we need to keep a virtual mapping similar to DDR. Its not good
+                # enough to just do title/artist because Reflec also has revival charts that
+                # are named the same. Luckily we have internal chart ID to map on!
+                old_id = self.get_music_id_for_song_data(None, None, chartid, chart, version=0)
+                if self.no_combine or old_id is None:
+                    # Insert original
+                    print("New entry for {} chart {}".format(songid, chart))
+                    next_id = self.get_next_music_id()
+                else:
+                    # Insert pointing at same ID so scores transfer
+                    print("Reused entry for {} chart {}".format(songid, chart))
+                    next_id = old_id
+                if old_id is None:
+                    # Add the virtual music entry we talked about above. Use the song ID when we discover
+                    # the song, plus the folder as a way to make them unique.
+                    self.insert_music_id_for_song(
+                        next_id,
+                        self.version * 10000 + songid,
+                        chart,
+                        song['title'],
+                        song['artist'],
+                        chartid,  # Chart goes into genre for reflec, so we can handle revival charts
+                        {
+                            'difficulty': song['difficulties'][chart],
+                            'folder': song['folder'],
+                            'chart_id': chartid,
+                        },
+                        version=0,
+                    )
+                else:
+                    if self.update:
+                        # Force a folder/difficulty update for this song.
+                        self.update_metadata_for_music_id(
+                            old_id,
+                            song['title'],
+                            song['artist'],
+                            chartid,  # Chart goes into genre for reflec, so we can handle revival charts
+                            {
+                                'difficulty': song['difficulties'][chart],
+                                'folder': song['folder'],
+                                'chart_id': chartid,
+                            },
+                            version=0,
+                        )
+
+                # Add the normal entry so the game finds the song.
+                self.insert_music_id_for_song(
+                    next_id,
+                    songid,
+                    chart,
+                    song['title'],
+                    song['artist'],
+                    None,  # Reflec Beat has no genres for real songs.
+                    {
+                        'difficulty': song['difficulties'][chart],
+                        'folder': song['folder'],
+                        'chart_id': chartid,
+                    },
+                )
+            self.finish_batch()
+
+
+class ImportDanceEvolution(ImportBase):
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        version: str,
+        no_combine: bool,
+        update: bool,
+    ) -> None:
+        if version in ['1']:
+            actual_version = 1
+        else:
+            raise Exception("Unsupported Dance Evolution version, expected one of the following: 1")
+
+        super().__init__(config, GameConstants.DANCE_EVOLUTION, actual_version, no_combine, update)
+
+    def scrape(self, infile: str) -> List[Dict[str, Any]]:
+        with open(infile, mode="rb") as myfile:
+            data = myfile.read()
+            myfile.close()
+
+            arc = ARC(data)
+            data = arc.read_file('data/song/song_params.plist')
+
+        # First, do a header check like the game does
+        if data[0:4] != b'MS02':
+            raise Exception("Invalid song params file!")
+        if data[4:6] not in [b'BE', b'LE']:
+            raise Exception("Invalid song params file!")
+
+        def get_string(offset: int, default: Optional[str] = None) -> str:
+            lut_offset = struct.unpack('>I', data[(offset):(offset + 4)])[0]
+            if lut_offset == 0:
+                if default is None:
+                    raise Exception("Expecting a string, got empty!")
+                return default
+            length = 0
+            while data[lut_offset + length] != 0:
+                length += 1
+            return data[lut_offset:(lut_offset + length)].decode('utf-8').replace("\n", " ")
+
+        def get_int(offset: int) -> int:
+            return struct.unpack('>I', data[(offset):(offset + 4)])[0]
+
+        # Now, make sure we know how long the file is
+        numsongs = struct.unpack('>I', data[8:12])[0]
+        filelen = struct.unpack('>I', data[12:16])[0]
+        if filelen != len(data):
+            raise Exception("Invalid song params file!")
+
+        # Now, extract the meaningful data for each song
+        retval = []
+        for i in range(numsongs):
+            offset = (i * 128) + 16
+
+            songcode = get_string(offset + 0)  # noqa: F841
+            songres1 = get_string(offset + 4)  # noqa: F841
+            songres2 = get_string(offset + 8)  # noqa: F841
+            bpm_min = get_int(offset + 12)
+            bpm_max = get_int(offset + 16)
+            copyright = get_string(offset + 24, "")
+            title = get_string(offset + 52, 'Unknown song')
+            artist = get_string(offset + 56, 'Unknown artist')
+            level = get_int(offset + 64)
+            charares1 = get_string(offset + 72)  # noqa: F841
+            charares2 = get_string(offset + 76)  # noqa: F841
+            kana_sort = get_string(offset + 108)
+
+            flag1 = data[offset + 33] != 0x00  # noqa: F841
+            flag2 = data[offset + 34] == 0x01  # noqa: F841
+            flag3 = data[offset + 34] == 0x02  # noqa: F841
+            flag4 = data[offset + 116] != 0x00  # noqa: F841
+
+            # TODO: Get the real music ID from the data, once we have in-game traffic.
+            retval.append({
+                'id': i,
+                'title': title,
+                'artist': artist,
+                'copyright': copyright or None,
+                'sort_key': kana_sort,
+                'bpm_min': bpm_min,
+                'bpm_max': bpm_max,
+                'level': level,
+            })
+
+        return retval
+
+    def lookup(self, server: str, token: str) -> List[Dict[str, Any]]:
+        # TODO: We never got far enough to support DanEvo in the server, or
+        # specify it in BEMAPI. So this is a dead function for now, but maybe
+        # some year in the future I'll be able to support this.
+        return []
+
+    def import_music_db(self, songs: List[Dict[str, Any]]) -> None:
+        for song in songs:
+            # Import it
+            self.start_batch()
+
+            # First, try to find in the DB from another version
+            old_id = self.get_music_id_for_song(song['id'], 0)
+            if self.no_combine or old_id is None:
+                # Insert original
+                print("New entry for {} chart {}".format(song['id'], 0))
+                next_id = self.get_next_music_id()
+            else:
+                # Insert pointing at same ID so scores transfer
+                print("Reused entry for {} chart {}".format(song['id'], 0))
+                next_id = old_id
+            data = {
+                'level': song['level'],
+                'bpm_min': song['bpm_min'],
+                'bpm_max': song['bpm_max'],
+            }
+            self.insert_music_id_for_song(next_id, song['id'], 0, song['title'], song['artist'], None, data)
+            self.finish_batch()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Import Game Music DB')
+    parser.add_argument(
+        '--series',
+        action='store',
+        type=str,
+        required=True,
+        help='The game series we are importing.',
+    )
+    parser.add_argument(
+        '--version',
+        dest='version',
+        action='store',
+        type=str,
+        required=True,
+        help='The game version we are importing.',
+    )
+    parser.add_argument(
+        '--csv',
+        dest='csv',
+        action='store',
+        type=str,
+        help='The CSV file to read, for applicable games.',
+    )
+    parser.add_argument(
+        '--tsv',
+        dest='tsv',
+        action='store',
+        type=str,
+        help='The TSV file to read, for applicable games.',
+    )
+    parser.add_argument(
+        '--xml',
+        dest='xml',
+        action='store',
+        type=str,
+        help='The game XML file to read, for applicable games.',
+    )
+    parser.add_argument(
+        '--bin',
+        dest='bin',
+        action='store',
+        type=str,
+        help='The game binary file to read, for applicable games.',
+    )
+    parser.add_argument(
+        '--assets',
+        dest='assets',
+        action='store',
+        type=str,
+        help='The game sound assets directory, for applicable games.',
+    )
+    parser.add_argument(
+        '--no-combine',
+        dest='no_combine',
+        action='store_true',
+        default=False,
+        help='Don\'t look for the same music ID in other versions.',
+    )
+    parser.add_argument(
+        '--update',
+        dest='update',
+        action='store_true',
+        default=False,
+        help='Overwrite data with updated values when it already exists.',
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        default="config.yaml",
+        help="Core configuration for importing to DB. Defaults to 'config.yaml'.",
+    )
+    parser.add_argument(
+        "--server",
+        type=str,
+        help="The remote BEMAPI server to read data from.",
+    )
+    parser.add_argument(
+        "--token",
+        type=str,
+        help="The access token to use with the remote BEMAPI server.",
+    )
+
+    # Parse args, validate invariants.
+    args = parser.parse_args()
+    if (args.token and not args.server) or (args.server and not args.token):
+        raise Exception("Must specify both --server and --token together!")
+    if (args.csv or args.tsv or args.xml or args.bin or args.assets) and (args.server or args.token):
+        raise Exception("Cannot specify both a remote server and a local file to read from!")
+
+    # Load the config so we can talk to the server
+    config = yaml.safe_load(open(args.config))  # type: ignore
+
+    if args.series == GameConstants.POPN_MUSIC:
+        popn = ImportPopn(config, args.version, args.no_combine, args.update)
+        if args.bin:
+            songs = popn.scrape(args.bin)
+        elif args.server and args.token:
+            songs = popn.lookup(args.server, args.token)
+        else:
+            raise Exception(
+                'No game DLL provided and no remote server specified! Please ' +
+                'provide either a --bin or a --server and --token option!'
+            )
+        popn.import_music_db(songs)
+        popn.close()
+
+    elif args.series == GameConstants.JUBEAT:
+        jubeat = ImportJubeat(config, args.version, args.no_combine, args.update)
+        if args.tsv is not None:
+            # Special case for Jubeat, grab the title/artist metadata that was
+            # hand-populated since its not in the music DB.
+            jubeat.import_metadata(args.tsv)
+        else:
+            # Normal case, doing a music DB import.
+            if args.xml is not None:
+                songs = jubeat.scrape(args.xml)
+            elif args.server and args.token:
+                songs = jubeat.lookup(args.server, args.token)
+            else:
+                raise Exception(
+                    'No music_info.xml or TSV provided and no remote server specified! Please ' +
+                    'provide either a --xml, --tsv or a --server and --token option!'
+                )
+            jubeat.import_music_db(songs)
+        jubeat.close()
+
+    elif args.series == GameConstants.IIDX:
+        iidx = ImportIIDX(config, args.version, args.no_combine, args.update)
+        if args.tsv is not None:
+            # Special case for IIDX, grab the title/artist metadata that was
+            # wrong in the music DB, and correct it.
+            iidx.import_metadata(args.tsv)
+        else:
+            # Normal case, doing a music DB import.
+            if args.bin is not None:
+                songs = iidx.scrape(args.bin, args.assets)
+            elif args.server and args.token:
+                songs = iidx.lookup(args.server, args.token)
+            else:
+                raise Exception(
+                    'No music_data.bin or TSV provided and no remote server specified! Please ' +
+                    'provide either a --bin, --tsv or a --server and --token option!'
+                )
+            iidx.import_music_db(songs)
+        iidx.close()
+
+    elif args.series == GameConstants.DDR:
+        ddr = ImportDDR(config, args.version, args.no_combine, args.update)
+        if args.server and args.token:
+            songs = ddr.lookup(args.server, args.token)
+        else:
+            if args.version == '16':
+                if args.bin is None:
+                    raise Exception('No startup.arc provided!')
+                # DDR Ace has a different format altogether
+                songs = ddr.parse_xml(args.bin)
+            else:
+                if args.bin is None:
+                    raise Exception('No game DLL provided!')
+                if args.xml is None:
+                    raise Exception('No game music XML provided!')
+                # DDR splits the music DB between the DLL and external XML
+                # (Why??), so we must first scrape then hydrate with extra
+                # data to get the full DB.
+                songs = ddr.scrape(args.bin)
+                songs = ddr.hydrate(songs, args.xml)
+        ddr.import_music_db(songs)
+        ddr.close()
+
+    elif args.series == GameConstants.SDVX:
+        sdvx = ImportSDVX(config, args.version, args.no_combine, args.update)
+        if args.server and args.token:
+            sdvx.import_from_server(args.server, args.token)
+        else:
+            if args.xml is None and args.bin is None and args.csv is None:
+                raise Exception(
+                    'No XML file or game DLL or appeal card CSV provided and ' +
+                    'no remote server specified! Please provide either a --xml, ' +
+                    '--bin, --csv or a --server and --token option!'
+                )
+            if args.xml is not None:
+                sdvx.import_music_db_or_appeal_cards(args.xml)
+            if args.bin is not None:
+                sdvx.import_catalog(args.bin)
+            if args.csv is not None:
+                sdvx.import_appeal_cards(args.csv)
+        sdvx.close()
+
+    elif args.series == GameConstants.MUSECA:
+        museca = ImportMuseca(config, args.version, args.no_combine, args.update)
+        if args.server and args.token:
+            museca.import_from_server(args.server, args.token)
+        elif args.xml is not None:
+            museca.import_music_db(args.xml)
+        else:
+            raise Exception(
+                'No music-info.xml provided and no remote server specified! ' +
+                'Please provide either a --xml or a --server and --token option!'
+            )
+        museca.close()
+
+    elif args.series == GameConstants.REFLEC_BEAT:
+        reflec = ImportReflecBeat(config, args.version, args.no_combine, args.update)
+        if args.bin is not None:
+            songs = reflec.scrape(args.bin)
+        elif args.server and args.token:
+            songs = reflec.lookup(args.server, args.token)
+        else:
+            raise Exception(
+                'No game DLL provided and no remote server specified! ' +
+                'Please provide either a --bin or a --server and --token option!'
+            )
+        reflec.import_music_db(songs)
+        reflec.close()
+
+    elif args.series == GameConstants.DANCE_EVOLUTION:
+        danevo = ImportDanceEvolution(config, args.version, args.no_combine, args.update)
+        if args.server and args.token:
+            songs = danevo.lookup(args.server, args.token)
+        elif args.bin is not None:
+            songs = danevo.scrape(args.bin)
+        else:
+            raise Exception(
+                'No resource_lists.arc provided and no remote server ' +
+                'specified! Please provide either a --bin or a ' +
+                '--server and --token option!',
+            )
+        danevo.import_music_db(songs)
+        danevo.close()
+
+    else:
+        raise Exception('Unsupported game series!')
diff --git a/bemani/utils/replay.py b/bemani/utils/replay.py
new file mode 100644
index 0000000..3cabc5b
--- /dev/null
+++ b/bemani/utils/replay.py
@@ -0,0 +1,148 @@
+import argparse
+import random
+import requests
+import sys
+
+from bemani.protocol import EAmuseProtocol, Node
+
+
+def hex_string(length: int, caps: bool=False) -> str:
+    if caps:
+        string = '0123456789ABCDEF'
+    else:
+        string = '0123456789abcdef'
+    return ''.join([random.choice(string) for x in range(length)])
+
+
+class Protocol:
+    def __init__(self, address: str, port: int, encryption: bool, compression: bool, verbose: bool) -> None:
+        self.__address = address
+        self.__port = port
+        self.__encryption = encryption
+        self.__compression = compression
+        self.__verbose = verbose
+
+    def exchange(self, uri: str, tree: Node, text_encoding: str="shift-jis", packet_encoding: str="binary") -> Node:
+        headers = {}
+
+        if self.__verbose:
+            print('Outgoing request:')
+            print(tree)
+
+        # Handle encoding
+        if packet_encoding == "xml":
+            _packet_encoding = EAmuseProtocol.XML
+        elif packet_encoding == "binary":
+            _packet_encoding = EAmuseProtocol.BINARY
+        else:
+            raise Exception("Unknown packet encoding {}".format(packet_encoding))
+
+        # Handle encryption
+        if self.__encryption:
+            encryption = '1-{}-{}'.format(
+                hex_string(8),
+                hex_string(4),
+            )
+            headers['X-Eamuse-Info'] = encryption
+        else:
+            encryption = None
+
+        # Handle compression
+        if self.__compression:
+            compression = 'lz77'
+        else:
+            compression = None
+        headers['X-Compress'] = compression
+
+        # Convert it
+        proto = EAmuseProtocol()
+        req = proto.encode(
+            compression,
+            encryption,
+            tree,
+            text_encoding=text_encoding,
+            packet_encoding=_packet_encoding,
+        )
+
+        # Send the request, get the response
+        r = requests.post(
+            'http://{}:{}{}{}'.format(
+                self.__address,
+                self.__port,
+                '/' if uri[0] != '/' else '',
+                uri,
+            ),
+            headers=headers,
+            data=req,
+        )
+
+        # Get the compression and encryption
+        encryption = headers.get('X-Eamuse-Info')
+        compression = headers.get('X-Compress')
+
+        # Decode it
+        packet = proto.decode(
+            compression,
+            encryption,
+            r.content,
+        )
+        if self.__verbose:
+            print('Incoming response:')
+            print(packet)
+        return packet
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to replay a packet from a log or binary dump.")
+    parser.add_argument("-i", "--infile", help="File containing an XML or binary node structure. Use - for stdin.", type=str, default=None, required=True)
+    parser.add_argument("-e", "--encoding", help="Encoding for the packet, defaults to UTF-8.", type=str, default='utf-8')
+    parser.add_argument("-p", "--port", help="Port to talk to. Defaults to 80", type=int, default=80)
+    parser.add_argument("-a", "--address", help="Address to talk to. Defaults to 127.0.0.1", type=str, default="127.0.0.1")
+    parser.add_argument("-u", "--path", help="URI that we should post to. Defaults to '/'", type=str, default="/")
+    args = parser.parse_args()
+
+    if args.infile == '-':
+        # Load from stdin
+        packet = sys.stdin.buffer.read()
+    else:
+        with open(args.infile, mode="rb") as myfile:
+            packet = myfile.read()
+            myfile.close
+
+    # Add an XML special node to force encoding (will be overwritten if there
+    # is one in the packet).
+    packet = b''.join([
+        '<?xml encoding="{}"?>'.format(args.encoding).encode(args.encoding),
+        packet,
+    ])
+
+    # Attempt to decode it
+    proto = EAmuseProtocol()
+    tree = proto.decode(
+        None,
+        None,
+        packet,
+    )
+
+    if tree is None:
+        # Can't decode, exit
+        raise Exception("Unable to decode packet!")
+
+    model = tree.attribute('model')
+    module = tree.children[0].name
+    method = tree.children[0].attribute('method')
+
+    server = Protocol(args.address, args.port, False, False, False)
+    server.exchange(
+        '{}?model={}&module={}&method={}'.format(
+            args.path,
+            model,
+            module,
+            method,
+        ),
+        tree,
+    )
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/responsegen.py b/bemani/utils/responsegen.py
new file mode 100644
index 0000000..9a6a75e
--- /dev/null
+++ b/bemani/utils/responsegen.py
@@ -0,0 +1,159 @@
+import argparse
+import sys
+from typing import Dict, List, Optional
+
+from bemani.protocol import EAmuseProtocol, Node
+
+
+def generate_node_name(node: Node, used_names: Dict[str, Node]) -> str:
+    potential_name = node.name
+    if potential_name not in used_names:
+        used_names[potential_name] = node
+        return potential_name
+
+    loop = 1
+    while '{}_{}'.format(potential_name, loop) in used_names:
+        loop = loop + 1
+
+    potential_name = '{}_{}'.format(potential_name, loop)
+    used_names[potential_name] = node
+    return potential_name
+
+
+def generate_node_create(node: Node) -> str:
+    dtype = node.data_type
+    if dtype == 'str':
+        method = 'string'
+    elif dtype == 'bin':
+        method = 'binary'
+    elif dtype == 'ip4':
+        method = 'ipv4'
+    elif dtype == '4u8':
+        method = 'fouru8'
+    else:
+        method = dtype
+    if node.is_array:
+        method = '{}_array'.format(method)
+
+    if dtype != 'void':
+        # Format the type for display
+        if dtype == 'str':
+            value = ', \'{}\''.format(node.value)
+        elif dtype == 'ip4':
+            value = ', \'{}.{}.{}.{}\''.format(
+                node.value[0],
+                node.value[1],
+                node.value[2],
+                node.value[3],
+            )
+        else:
+            value = ', {}'.format(node.value)
+    else:
+        value = ''
+
+    return 'Node.{}(\'{}\'{})'.format(
+        method,
+        node.name,
+        value
+    )
+
+
+def generate_node_link(node_name: str, used_names: Dict[str, Node], parent: Node) -> str:
+    # Find the node that parents this, link to it
+    found_parent = None
+    for parent_name in used_names:
+        if used_names[parent_name] is parent:
+            found_parent = parent_name
+            break
+
+    if found_parent is None:
+        raise Exception('Failed to find parent name for {}'.format(parent))
+
+    return '{}.add_child({})'.format(
+        found_parent,
+        node_name,
+    )
+
+
+def generate_lines(node: Node, used_names: Dict[str, Node], parent: Optional[Node]=None) -> List[str]:
+    # First, generate node itself
+    create = generate_node_create(node)
+    if not node.children and not node.attributes and parent:
+        # Just directly hook this up to parent
+        return [generate_node_link(create, used_names, parent)]
+
+    # Print the node generate itself
+    out = []
+    node_name = generate_node_name(node, used_names)
+    out.append('{} = {}'.format(node_name, create))
+
+    # Now, generate add to parent if exists
+    if parent is not None:
+        out.append(generate_node_link(node_name, used_names, parent))
+
+    # Now generate node attributes
+    for attr in node.attributes:
+        out.append('{}.set_attribute(\'{}\', \'{}\')'.format(
+            node_name,
+            attr,
+            node.attributes[attr],
+        ))
+
+    # Now, do the same for all children
+    for child in node.children:
+        out.extend(generate_lines(child, used_names, node))
+
+    return out
+
+
+def generate_code(infile: str, outfile: str, encoding: str) -> None:
+    if infile == '-':
+        # Load from stdin
+        packet = sys.stdin.buffer.read()
+    else:
+        with open(infile, mode="rb") as infp:
+            packet = infp.read()
+            infp.close
+
+    # Add an XML special node to force encoding (will be overwritten if there
+    # is one in the packet).
+    packet = b''.join([
+        '<?xml encoding="{}"?>'.format(encoding).encode(encoding),
+        packet,
+    ])
+
+    # Attempt to decode it
+    proto = EAmuseProtocol()
+    req = proto.decode(
+        None,
+        None,
+        packet,
+    )
+
+    if req is None:
+        # Can't decode, exit
+        raise Exception("Unable to decode packet!")
+
+    # Walk through, outputting each node and attaching it to its parent
+    code = '\n'.join(generate_lines(req, {}))
+
+    if outfile == '-':
+        print(code)
+    else:
+        with open(outfile, mode="a") as outfp:
+            outfp.write(code)
+            outfp.close
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to generate code that will generate a packet.")
+    parser.add_argument("-i", "--infile", help="File containing an XML or binary node structure. Use - for stdin.", type=str, default=None, required=True)
+    parser.add_argument("-o", "--outfile", help="File to write python code to. Use - for stdout.", type=str, default=None, required=True)
+    parser.add_argument("-e", "--encoding", help="Encoding for the packet, defaults to UTF-8.", type=str, default='utf-8')
+    args = parser.parse_args()
+
+    generate_code(args.infile, args.outfile, args.encoding)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/scheduler.py b/bemani/utils/scheduler.py
new file mode 100644
index 0000000..e63e825
--- /dev/null
+++ b/bemani/utils/scheduler.py
@@ -0,0 +1,75 @@
+import argparse
+import yaml  # type: ignore
+from typing import Any, Dict, List
+
+from bemani.backend.popn import PopnMusicFactory
+from bemani.backend.jubeat import JubeatFactory
+from bemani.backend.iidx import IIDXFactory
+from bemani.backend.bishi import BishiBashiFactory
+from bemani.backend.ddr import DDRFactory
+from bemani.backend.sdvx import SoundVoltexFactory
+from bemani.backend.reflec import ReflecBeatFactory
+from bemani.backend.museca import MusecaFactory
+from bemani.frontend.popn import PopnMusicCache
+from bemani.frontend.iidx import IIDXCache
+from bemani.frontend.jubeat import JubeatCache
+from bemani.frontend.bishi import BishiBashiCache
+from bemani.frontend.ddr import DDRCache
+from bemani.frontend.sdvx import SoundVoltexCache
+from bemani.frontend.reflec import ReflecBeatCache
+from bemani.frontend.museca import MusecaCache
+from bemani.common import GameConstants
+from bemani.data import Data
+
+
+def run_scheduled_work(config: Dict[str, Any]) -> None:
+    data = Data(config)
+
+    # Only run scheduled work for enabled components
+    enabled_factories: List[Any] = []
+    enabled_caches: List[Any] = []
+    if config.get('support', {}).get(GameConstants.IIDX, False):
+        enabled_factories.append(IIDXFactory)
+        enabled_caches.append(IIDXCache)
+    if config.get('support', {}).get(GameConstants.POPN_MUSIC, False):
+        enabled_factories.append(PopnMusicFactory)
+        enabled_caches.append(PopnMusicCache)
+    if config.get('support', {}).get(GameConstants.JUBEAT, False):
+        enabled_factories.append(JubeatFactory)
+        enabled_caches.append(JubeatCache)
+    if config.get('support', {}).get(GameConstants.BISHI_BASHI, False):
+        enabled_factories.append(BishiBashiFactory)
+        enabled_caches.append(BishiBashiCache)
+    if config.get('support', {}).get(GameConstants.DDR, False):
+        enabled_factories.append(DDRFactory)
+        enabled_caches.append(DDRCache)
+    if config.get('support', {}).get(GameConstants.SDVX, False):
+        enabled_factories.append(SoundVoltexFactory)
+        enabled_caches.append(SoundVoltexCache)
+    if config.get('support', {}).get(GameConstants.REFLEC_BEAT, False):
+        enabled_factories.append(ReflecBeatFactory)
+        enabled_caches.append(ReflecBeatCache)
+    if config.get('support', {}).get(GameConstants.MUSECA, False):
+        enabled_factories.append(MusecaFactory)
+        enabled_caches.append(MusecaCache)
+
+    # First, run any backend scheduled work
+    for factory in enabled_factories:
+        factory.run_scheduled_work(data, config)  # type: ignore
+
+    # Now, warm the caches for the frontend
+    for cache in enabled_caches:
+        cache.preload(data, config)  # type: ignore
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="A scheduler for work that needs to be done periodically.")
+    parser.add_argument("-c", "--config", help="Core configuration. Defaults to server.yaml", type=str, default="server.yaml")
+    args = parser.parse_args()
+
+    # Set up global configuration
+    config = yaml.safe_load(open(args.config))  # type: ignore
+    config['database']['engine'] = Data.create_engine(config)
+
+    # Run out of band work
+    run_scheduled_work(config)
diff --git a/bemani/utils/services.py b/bemani/utils/services.py
new file mode 100644
index 0000000..df85b6d
--- /dev/null
+++ b/bemani/utils/services.py
@@ -0,0 +1,175 @@
+import argparse
+import copy
+import traceback
+import yaml  # type: ignore
+from typing import Any, Dict
+from flask import Flask, request, redirect, Response, make_response
+
+from bemani.protocol import EAmuseProtocol
+from bemani.backend import Dispatch, UnrecognizedPCBIDException
+from bemani.backend.iidx import IIDXFactory
+from bemani.backend.popn import PopnMusicFactory
+from bemani.backend.jubeat import JubeatFactory
+from bemani.backend.bishi import BishiBashiFactory
+from bemani.backend.ddr import DDRFactory
+from bemani.backend.sdvx import SoundVoltexFactory
+from bemani.backend.reflec import ReflecBeatFactory
+from bemani.backend.museca import MusecaFactory
+from bemani.common import GameConstants
+from bemani.data import Data
+
+
+app = Flask(__name__)
+config: Dict[str, Any] = {}
+
+
+@app.route('/', defaults={'path': ''}, methods=['GET'])
+@app.route('/<path:path>', methods=['GET'])
+def receive_healthcheck(path: str) -> Response:
+    global config
+    redirect_uri = config['server'].get('redirect')
+    if redirect_uri is None:
+        # Return a standard status OKAY message.
+        return Response("Services OK.")
+    else:
+        # Redirect to the configured location.
+        return redirect(redirect_uri, code=308)  # type: ignore
+
+
+@app.route('/', defaults={'path': ''}, methods=['POST'])
+@app.route('/<path:path>', methods=['POST'])
+def receive_request(path: str) -> Response:
+    proto = EAmuseProtocol()
+    remote_address = request.headers.get('x-remote-address', None)
+    compression = request.headers.get('x-compress', None)
+    encryption = request.headers.get('x-eamuse-info', None)
+    req = proto.decode(
+        compression,
+        encryption,
+        request.data,
+    )
+
+    if req is None:
+        # Nothing to do here
+        return Response("Unrecognized packet!", 500)
+    if req.name in {'soapenv:Envelope', 'soap:Envelope', 'methodCall'}:
+        # We get lots of spam from random bots trying to SOAP
+        # us up, so ignore this shit.
+        return Response("Unrecognized packet!", 500)
+
+    # Create and format config
+    global config
+    requestconfig = copy.copy(config)
+    requestconfig['client'] = {
+        'address': remote_address or request.remote_addr,
+    }
+
+    dataprovider = Data(requestconfig)
+    try:
+        dispatch = Dispatch(requestconfig, dataprovider, True)
+        resp = dispatch.handle(req)
+
+        if resp is None:
+            # Nothing to do here
+            dataprovider.local.network.put_event(
+                'unhandled_packet',
+                {
+                    'request': str(req),
+                },
+            )
+            return Response("No response generated", 404)
+
+        compression = None
+
+        data = proto.encode(
+            compression,
+            encryption,
+            resp,
+        )
+
+        response = make_response(data)
+
+        # Some old clients are case-sensitive, even though http spec says these
+        # shouldn't matter, so capitalize correctly.
+        if compression:
+            response.headers['X-Compress'] = compression
+        else:
+            response.headers['X-Compress'] = 'none'
+        if encryption:
+            response.headers['X-Eamuse-Info'] = encryption
+
+        return response
+    except UnrecognizedPCBIDException as e:
+        dataprovider.local.network.put_event(
+            'unauthorized_pcbid',
+            {
+                'pcbid': e.pcbid,
+                'model': e.model,
+                'ip': e.ip,
+            },
+        )
+        return Response("Unauthorized client", 403)
+    except Exception:
+        stack = traceback.format_exc()
+        print(stack)
+        dataprovider.local.network.put_event(
+            'exception',
+            {
+                'service': 'xrpc',
+                'request': str(req),
+                'traceback': stack,
+            },
+        )
+        return Response("Crash when handling packet!", 500)
+    finally:
+        dataprovider.close()
+
+
+def load_config(filename: str) -> None:
+    global config
+
+    config.update(yaml.safe_load(open(filename)))  # type: ignore
+    config['database']['engine'] = Data.create_engine(config)
+
+
+def register_games() -> None:
+    global config
+
+    if config.get('support', {}).get(GameConstants.POPN_MUSIC, False):
+        PopnMusicFactory.register_all()
+    if config.get('support', {}).get(GameConstants.JUBEAT, False):
+        JubeatFactory.register_all()
+    if config.get('support', {}).get(GameConstants.IIDX, False):
+        IIDXFactory.register_all()
+    if config.get('support', {}).get(GameConstants.BISHI_BASHI, False):
+        BishiBashiFactory.register_all()
+    if config.get('support', {}).get(GameConstants.DDR, False):
+        DDRFactory.register_all()
+    if config.get('support', {}).get(GameConstants.REFLEC_BEAT, False):
+        ReflecBeatFactory.register_all()
+    if config.get('support', {}).get(GameConstants.SDVX, False):
+        SoundVoltexFactory.register_all()
+    if config.get('support', {}).get(GameConstants.MUSECA, False):
+        MusecaFactory.register_all()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="A backend services provider for eAmusement games")
+    parser.add_argument("-p", "--port", help="Port to listen on. Defaults to 80", type=int, default=80)
+    parser.add_argument("-c", "--config", help="Core configuration. Defaults to server.yaml", type=str, default="server.yaml")
+    parser.add_argument("-r", "--profile", help="Turn on profiling for front end", action="store_true")
+    args = parser.parse_args()
+
+    # Set up global configuration, overriding config port for convenience
+    load_config(args.config)
+    config['server']['port'] = args.port
+
+    # Register game handlers
+    register_games()
+
+    if args.profile:
+        from werkzeug.contrib.profiler import ProfilerMiddleware  # type: ignore
+        app.wsgi_app = ProfilerMiddleware(app.wsgi_app, profile_dir='.')  # type: ignore
+
+    # Run the app
+    app.run(host='0.0.0.0', port=args.port, debug=True)
diff --git a/bemani/utils/struct.py b/bemani/utils/struct.py
new file mode 100644
index 0000000..1a3d372
--- /dev/null
+++ b/bemani/utils/struct.py
@@ -0,0 +1,77 @@
+import argparse
+import pefile  # type: ignore
+import struct
+
+
+def parse_struct(data: bytes, startaddr: str, endaddr: str, fmt: str) -> None:
+    pe = pefile.PE(data=data, fast_load=True)
+    start: int = int(startaddr, 16)
+    end: int = int(endaddr, 16)
+
+    def virtual_to_physical(offset: int) -> int:
+        for section in pe.sections:
+            start = section.VirtualAddress + pe.OPTIONAL_HEADER.ImageBase
+            end = start + section.SizeOfRawData
+
+            if offset >= start and offset < end:
+                return (offset - start) + section.PointerToRawData
+        raise Exception('Couldn\'t find raw offset for virtual offset 0x{:08x}'.format(offset))
+
+    if start >= pe.OPTIONAL_HEADER.ImageBase:
+        # Assume this is virtual
+        start = virtual_to_physical(start)
+
+    if end >= pe.OPTIONAL_HEADER.ImageBase:
+        # Assume this is virtual
+        end = virtual_to_physical(end)
+
+    size: int = struct.calcsize(fmt)
+
+    while start < end:
+        chunk = data[start:(start + size)]
+        start = start + size
+
+        print(list(struct.unpack(fmt, chunk)))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to print structs out of a DLL.")
+    parser.add_argument(
+        "--file",
+        help="DLL file to extract from.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    parser.add_argument(
+        "--start",
+        help="Hex offset into the file we should start at.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    parser.add_argument(
+        "--end",
+        help="Hex offset into the file we should go until.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    parser.add_argument(
+        "--format",
+        help="Python struct format we should print using.",
+        type=str,
+        default=None,
+        required=True,
+    )
+    args = parser.parse_args()
+
+    fp = open(args.file, 'rb')
+    data = fp.read()
+    fp.close()
+
+    parse_struct(data, args.start, args.end, args.format)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/trafficgen.py b/bemani/utils/trafficgen.py
new file mode 100644
index 0000000..5e86ac6
--- /dev/null
+++ b/bemani/utils/trafficgen.py
@@ -0,0 +1,545 @@
+import argparse
+import sys
+from typing import Any, Dict, Optional
+import yaml  # type: ignore
+
+from bemani.client import ClientProtocol, BaseClient
+from bemani.client.iidx import (
+    IIDXTricoroClient,
+    IIDXSpadaClient,
+    IIDXPendualClient,
+    IIDXCopulaClient,
+    IIDXSinobuzClient,
+)
+from bemani.client.jubeat import (
+    JubeatSaucerClient,
+    JubeatSaucerFulfillClient,
+    JubeatPropClient,
+    JubeatQubellClient,
+    JubeatClanClient,
+)
+from bemani.client.popn import (
+    PopnMusicTuneStreetClient,
+    PopnMusicFantasiaClient,
+    PopnMusicSunnyParkClient,
+    PopnMusicLapistoriaClient,
+    PopnMusicEclaleClient,
+    PopnMusicUsaNekoClient,
+)
+from bemani.client.ddr import (
+    DDRX2Client,
+    DDRX3Client,
+    DDR2013Client,
+    DDR2014Client,
+    DDRAceClient,
+)
+from bemani.client.sdvx import (
+    SoundVoltexBoothClient,
+    SoundVoltexInfiniteInfectionClient,
+    SoundVoltexGravityWarsS1Client,
+    SoundVoltexGravityWarsS2Client,
+    SoundVoltexHeavenlyHavenClient,
+)
+from bemani.client.museca import (
+    Museca1Client,
+    Museca1PlusClient,
+)
+from bemani.client.reflec import (
+    ReflecBeat,
+    ReflecBeatLimelight,
+    ReflecBeatColette,
+    ReflecBeatGroovinUpper,
+    ReflecBeatVolzza,
+    ReflecBeatVolzza2,
+)
+from bemani.client.bishi import TheStarBishiBashiClient
+
+
+def get_client(proto: ClientProtocol, pcbid: str, game: str, config: Dict[str, Any]) -> BaseClient:
+    if game == 'pnm-tune-street':
+        return PopnMusicTuneStreetClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'pnm-fantasia':
+        return PopnMusicFantasiaClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'pnm-sunny-park':
+        return PopnMusicSunnyParkClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'pnm-lapistoria':
+        return PopnMusicLapistoriaClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'pnm-eclale':
+        return PopnMusicEclaleClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'pnm-usaneko':
+        return PopnMusicUsaNekoClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'jubeat-saucer':
+        return JubeatSaucerClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'jubeat-saucer-fulfill':
+        return JubeatSaucerFulfillClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'jubeat-prop':
+        return JubeatPropClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'jubeat-qubell':
+        return JubeatQubellClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'jubeat-clan':
+        return JubeatClanClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'iidx-sinobuz':
+        return IIDXSinobuzClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'iidx-copula':
+        return IIDXCopulaClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'iidx-pendual':
+        return IIDXPendualClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'iidx-spada':
+        return IIDXSpadaClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'iidx-tricoro':
+        return IIDXTricoroClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'bishi':
+        return TheStarBishiBashiClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'ddr-x2':
+        return DDRX2Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'ddr-x3':
+        return DDRX3Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'ddr-2013':
+        return DDR2013Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'ddr-2014':
+        return DDR2014Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'ddr-ace':
+        return DDRAceClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'sdvx-booth':
+        return SoundVoltexBoothClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'sdvx-infinite-infection':
+        return SoundVoltexInfiniteInfectionClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'sdvx-gravity-wars-s1':
+        return SoundVoltexGravityWarsS1Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'sdvx-gravity-wars-s2':
+        return SoundVoltexGravityWarsS2Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'sdvx-heavenly-haven':
+        return SoundVoltexHeavenlyHavenClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'museca-1':
+        return Museca1Client(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'museca-1+1/2':
+        return Museca1PlusClient(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'reflec':
+        return ReflecBeat(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'reflec-limelight':
+        return ReflecBeatLimelight(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'reflec-colette':
+        return ReflecBeatColette(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'reflec-groovin-upper':
+        return ReflecBeatGroovinUpper(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'reflec-volzza':
+        return ReflecBeatVolzza(
+            proto,
+            pcbid,
+            config,
+        )
+    if game == 'reflec-volzza2':
+        return ReflecBeatVolzza2(
+            proto,
+            pcbid,
+            config,
+        )
+
+    raise Exception('Unknown game {}'.format(game))
+
+
+def mainloop(address: str, port: int, configfile: str, action: str, game: str, cardid: Optional[str], verbose: bool) -> None:
+    games = {
+        'pnm-tune-street': {
+            'name': "Pop'n Music Tune Street",
+            'model': "K39:J:B:A:2010122200",
+            'old_profile_model': "J39:J:A:A",
+            'avs': None,
+        },
+        'pnm-fantasia': {
+            'name': "Pop'n Music Fantasia",
+            'model': "L39:J:B:A:2012091900",
+            'old_profile_model': "K39:J:A:A",
+            'avs': "2.13.6 r4921",
+        },
+        'pnm-sunny-park': {
+            'name': "Pop'n Music Sunny Park",
+            'model': "M39:J:B:A:2014061900",
+            'old_profile_model': "L39:J:A:A",
+            'avs': "2.15.8 r6631",
+        },
+        'pnm-lapistoria': {
+            'name': "Pop'n Music Lapistoria",
+            'model': "M39:J:B:A:2015081900",
+            'old_profile_model': "M39:J:B:A",
+            'avs': "2.15.8 r6631",
+        },
+        'pnm-eclale': {
+            'name': "Pop'n Music Eclale",
+            'model': "M39:J:B:A:2016100500",
+            'old_profile_model': "M39:J:B:A",
+            'avs': "2.15.8 r6631",
+        },
+        'pnm-usaneko': {
+            'name': "Pop'n Music Usagi to Neko to Shounen no Yume",
+            'model': "M39:J:B:A:2018101500",
+            'old_profile_model': "M39:J:B:A",
+            'avs': "2.15.8 r6631",
+        },
+        'jubeat-saucer': {
+            'name': "Jubeat Saucer",
+            'model': "L44:J:A:A:2014012802",
+            'avs': "2.15.8 r6631",
+        },
+        'jubeat-saucer-fulfill': {
+            'name': "Jubeat Saucer Fulfill",
+            'model': "L44:J:B:A:2014111800",
+            'avs': "2.15.8 r6631",
+        },
+        'jubeat-prop': {
+            'name': "Jubeat Prop",
+            'model': "L44:J:B:A:2016031700",
+            'avs': "2.15.8 r6631",
+        },
+        'jubeat-qubell': {
+            'name': "Jubeat Qubell",
+            'model': "L44:J:D:A:2016111400",
+            'avs': "2.15.8 r6631",
+        },
+        'jubeat-clan': {
+            'name': "Jubeat Clan",
+            'model': "L44:J:E:A:2018070901",
+            'avs': "2.17.3 r8311",
+        },
+        'iidx-sinobuz': {
+            'name': "Beatmania IIDX SINOBUZ",
+            'model': "LDJ:J:A:A:2017082800",
+            'avs': "2.16.1 r6901",
+        },
+        'iidx-copula': {
+            'name': "Beatmania IIDX copula",
+            'model': "LDJ:J:A:A:2016083100",
+            'avs': "2.16.1 r6901",
+        },
+        'iidx-pendual': {
+            'name': "Beatmania IIDX PENDUAL",
+            'model': "LDJ:A:A:A:2015080500",
+            'avs': "2.16.1 r6901",
+        },
+        'iidx-spada': {
+            'name': "Beatmania IIDX SPADA",
+            'model': "LDJ:A:A:A:2014071600",
+            'avs': "2.16.1 r6901",
+        },
+        'iidx-tricoro': {
+            'name': "Beatmania IIDX Tricoro",
+            'model': "LDJ:J:A:A:2013090900",
+            'avs': "2.15.8 r6631",
+        },
+        'bishi': {
+            'name': "The★BishiBashi",
+            'model': "IBB:A:A:A:2009092900",
+            'avs': None,
+        },
+        'ddr-x2': {
+            'name': "DanceDanceRevolution X2",
+            'model': "JDX:J:A:A:2010111000",
+            'avs': None,
+        },
+        'ddr-x3': {
+            'name': "DanceDanceRevolution X3 VS 2ndMIX",
+            'model': "KDX:J:A:A:2012112600",
+            'avs': "2.13.6 r4921",
+        },
+        'ddr-2013': {
+            'name': "DanceDanceRevolution (2013)",
+            'model': "MDX:J:A:A:2014032700",
+            'avs': "2.15.8 r6631",
+        },
+        'ddr-2014': {
+            'name': "DanceDanceRevolution (2014)",
+            'model': "MDX:A:A:A:2015122100",
+            'avs': "2.15.8 r6631",
+        },
+        'ddr-ace': {
+            'name': "DanceDanceRevolution A",
+            'model': "MDX:U:D:A:2017121400",
+            'avs': "2.15.8 r6631",
+        },
+        'sdvx-booth': {
+            'name': "SOUND VOLTEX BOOTH",
+            'model': "KFC:J:A:A:2013052900",
+            'avs': "2.15.8 r6631",
+        },
+        'sdvx-infinite-infection': {
+            'name': "SOUND VOLTEX II -infinite infection-",
+            'model': "KFC:J:A:A:2014102200",
+            'avs': "2.15.8 r6631",
+        },
+        'sdvx-gravity-wars-s1': {
+            'name': "SOUND VOLTEX III GRAVITY WARS Season 1",
+            'model': "KFC:J:A:A:2015111602",
+            'avs': "2.15.8 r6631",
+        },
+        'sdvx-gravity-wars-s2': {
+            'name': "SOUND VOLTEX III GRAVITY WARS Season 2",
+            'model': "KFC:J:A:A:2016121900",
+            'avs': "2.15.8 r6631",
+        },
+        'sdvx-heavenly-haven': {
+            'name': "SOUND VOLTEX IV HEAVENLY HAVEN",
+            'model': "KFC:J:A:A:2019020600",
+            'avs': "2.15.8 r6631",
+        },
+        'museca-1': {
+            'name': "MÚSECA",
+            'model': "PIX:J:A:A:2016071300",
+            'avs': "2.17.0 r7883",
+        },
+        'museca-1+1/2': {
+            'name': "MÚSECA 1+1/2",
+            'model': "PIX:J:A:A:2017042600",
+            'avs': "2.17.0 r7883",
+        },
+        'reflec': {
+            'name': "REFLEC BEAT",
+            'model': "KBR:A:A:A:2011112300",
+            'avs': None,
+        },
+        'reflec-limelight': {
+            'name': "REFLEC BEAT limelight",
+            'model': "LBR:A:A:A:2012082900",
+            'avs': "2.13.6 r4921",
+        },
+        'reflec-colette': {
+            'name': "REFLEC BEAT colette",
+            'model': "MBR:J:A:A:2014011600",
+            'avs': "2.15.8 r6631",
+        },
+        'reflec-groovin-upper': {
+            'name': "REFLEC BEAT groovin'!! Upper",
+            'model': "MBR:J:A:A:2015102100",
+            'avs': "2.15.8 r6631",
+        },
+        'reflec-volzza': {
+            'name': "REFLEC BEAT VOLZZA",
+            'model': "MBR:J:A:A:2016030200",
+            'avs': "2.15.8 r6631",
+        },
+        'reflec-volzza2': {
+            'name': "REFLEC BEAT VOLZZA 2",
+            'model': "MBR:J:A:A:2016100400",
+            'avs': "2.15.8 r6631",
+        },
+    }
+    if action == 'list':
+        for game in sorted([game for game in games]):
+            print('{} - {}'.format(game, games[game]['name']))
+        sys.exit(0)
+    if action == 'game':
+        if game not in games:
+            print('Unknown game {}'.format(game))
+            sys.exit(2)
+
+        config = yaml.safe_load(open(configfile))  # type: ignore
+
+        print('Emulating {}'.format(games[game]['name']))
+        emu = get_client(
+            ClientProtocol(
+                address,
+                port,
+                config['core']['encryption'],
+                config['core']['compression'],
+                verbose,
+            ),
+            config['core']['pcbid'],
+            game,
+            games[game],
+        )
+
+        emu.verify(cardid)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to generate game-like traffic for testing an eAmusement server.")
+    parser.add_argument("-p", "--port", help="Port to talk to. Defaults to 80", type=int, default=80)
+    parser.add_argument("-a", "--address", help="Address to talk to. Defaults to 127.0.0.1", type=str, default="127.0.0.1")
+    parser.add_argument("-c", "--config", help="Core configuration. Defaults to trafficgen.yaml", type=str, default="trafficgen.yaml")
+    parser.add_argument("-g", "--game", help="The game that should be emulated. Should be one of the games returned by --list", type=str, default=None)
+    parser.add_argument("-l", "--list", help="List all known games and exit.", action="store_true")
+    parser.add_argument("-i", "--cardid", help="Use this card ID instead of a random one.", type=str, default=None)
+    parser.add_argument("-v", "--verbose", help="Print packets that are sent/received.", action='store_true', default=False)
+    args = parser.parse_args()
+
+    if args.list:
+        action = 'list'
+        game = None
+    elif args.game:
+        action = 'game'
+        game = args.game
+    else:
+        print("Unknown action to perform. Please specify --game <game> or --list")
+        sys.exit(1)
+
+    game = {
+        'pnm-19': 'pnm-tune-street',
+        'pnm-20': 'pnm-fantasia',
+        'pnm-21': 'pnm-sunny-park',
+        'pnm-22': 'pnm-lapistoria',
+        'pnm-23': 'pnm-eclale',
+        'pnm-24': 'pnm-usaneko',
+        'iidx-20': 'iidx-tricoro',
+        'iidx-21': 'iidx-spada',
+        'iidx-22': 'iidx-pendual',
+        'iidx-23': 'iidx-copula',
+        'iidx-24': 'iidx-sinobuz',
+        'jubeat-5': 'jubeat-saucer',
+        'jubeat-5+': 'jubeat-saucer-fulfill',
+        'jubeat-6': 'jubeat-prop',
+        'jubeat-7': 'jubeat-qubell',
+        'jubeat-8': 'jubeat-clan',
+        'ddr-12': 'ddr-x2',
+        'ddr-13': 'ddr-x3',
+        'ddr-14': 'ddr-2013',
+        'ddr-15': 'ddr-2014',
+        'ddr-16': 'ddr-ace',
+        'sdvx-1': 'sdvx-booth',
+        'sdvx-2': 'sdvx-infinite-infection',
+        'sdvx-3s1': 'sdvx-gravity-wars-s1',
+        'sdvx-3s2': 'sdvx-gravity-wars-s2',
+        'sdvx-4': 'sdvx-heavenly-haven',
+        'reflec-1': 'reflec',
+        'reflec-2': 'reflec-limelight',
+        'reflec-3': 'reflec-colette',
+        'reflec-4': 'reflec-groovin-upper',
+        'reflec-5': 'reflec-volzza',
+        'reflec-6': 'reflec-volzza2',
+    }.get(game, game)
+
+    mainloop(args.address, args.port, args.config, action, game, args.cardid, args.verbose)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/utils/twodxutils.py b/bemani/utils/twodxutils.py
new file mode 100644
index 0000000..84e9f63
--- /dev/null
+++ b/bemani/utils/twodxutils.py
@@ -0,0 +1,82 @@
+import argparse
+import os
+
+from bemani.format import TwoDX
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="A utility to extract/build 2dx files.")
+    parser.add_argument(
+        "file",
+        help="2dx file to extract/build.",
+        type=str,
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        help="Directory to extract to.",
+        default=None,
+    )
+    parser.add_argument(
+        "-w",
+        "--wavfile",
+        help="ADPCM wave file to add to archive.",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "-n",
+        "--name",
+        help="Name of the archive when updating.",
+        default=None,
+    )
+    args = parser.parse_args()
+
+    if args.directory is not None:
+        root = args.directory
+        if root[-1] != '/':
+            root = root + '/'
+        root = os.path.realpath(root)
+
+        fp = open(args.file, 'rb')
+        data = fp.read()
+        fp.close()
+
+        twodx = TwoDX(data)
+
+        for fn in twodx.filenames:
+            print('Extracting {} to disk...'.format(fn))
+            realfn = os.path.join(root, fn)
+            dirof = os.path.dirname(realfn)
+            os.makedirs(dirof, exist_ok=True)
+            with open(realfn, 'wb') as fp:
+                fp.write(twodx.read_file(fn))
+
+    if len(args.wavfile) > 0:
+        try:
+            fp = open(args.file, 'rb')
+            data = fp.read()
+            fp.close()
+
+            twodx = TwoDX(data)
+        except FileNotFoundError:
+            twodx = TwoDX()
+            if args.name is not None:
+                twodx.set_name(args.name)
+            else:
+                twodx.set_name(os.path.splitext(os.path.basename(args.file))[0])
+
+        for fn in args.wavfile:
+            fp = open(fn, 'rb')
+            data = fp.read()
+            fp.close()
+
+            twodx.write_file(os.path.basename(fn), data)
+
+        fp = open(args.file, 'wb')
+        fp.write(twodx.get_new_data())
+        fp.close()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/bemani/wsgi/api.wsgi b/bemani/wsgi/api.wsgi
new file mode 100644
index 0000000..823a8a8
--- /dev/null
+++ b/bemani/wsgi/api.wsgi
@@ -0,0 +1,6 @@
+from bemani.utils.api import app, load_config
+
+# Assumes a production server yaml in the same directory as this WSGI
+# file. Also assumes that your uWSGI instance is configured with a
+# virtualenv that includes the installed version of this repo.
+load_config('server.yaml')
diff --git a/bemani/wsgi/frontend.wsgi b/bemani/wsgi/frontend.wsgi
new file mode 100644
index 0000000..c688329
--- /dev/null
+++ b/bemani/wsgi/frontend.wsgi
@@ -0,0 +1,8 @@
+from bemani.utils.frontend import app, load_config, register_blueprints, register_games
+
+# Assumes a production server yaml in the same directory as this WSGI
+# file. Also assumes that your uWSGI instance is configured with a
+# virtualenv that includes the installed version of this repo.
+load_config('server.yaml')
+register_blueprints()
+register_games()
diff --git a/bemani/wsgi/proxy.wsgi b/bemani/wsgi/proxy.wsgi
new file mode 100644
index 0000000..770a6df
--- /dev/null
+++ b/bemani/wsgi/proxy.wsgi
@@ -0,0 +1,6 @@
+from bemani.utils.proxy import app, load_config
+
+# Assumes a proxy yaml in the same directory as this WSGI
+# file. Also assumes that your uWSGI instance is configured with a
+# virtualenv that includes the installed version of this repo.
+load_config('proxy.yaml')
diff --git a/bemani/wsgi/services.wsgi b/bemani/wsgi/services.wsgi
new file mode 100644
index 0000000..6839037
--- /dev/null
+++ b/bemani/wsgi/services.wsgi
@@ -0,0 +1,7 @@
+from bemani.utils.services import app, load_config, register_games
+
+# Assumes a production server yaml in the same directory as this WSGI
+# file. Also assumes that your uWSGI instance is configured with a
+# virtualenv that includes the installed version of this repo.
+load_config('server.yaml')
+register_games()
diff --git a/bemanishark b/bemanishark
new file mode 100755
index 0000000..6050ad1
--- /dev/null
+++ b/bemanishark
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.bemanishark "$@"
diff --git a/binutils b/binutils
new file mode 100755
index 0000000..1cf0bab
--- /dev/null
+++ b/binutils
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.binutils "$@"
diff --git a/bootstrap b/bootstrap
new file mode 100755
index 0000000..0e07bf3
--- /dev/null
+++ b/bootstrap
@@ -0,0 +1,60 @@
+#! /bin/bash
+
+# Die if we fail to do an import. If you're bootstrapping
+# from a network with partial support, kill this line to
+# do a best-effort.
+set -e
+
+# Init Pop'n Music
+./read --series pnm --version 19 "$@"
+./read --series pnm --version 20 "$@"
+./read --series pnm --version 21 "$@"
+./read --series pnm --version 22 "$@"
+./read --series pnm --version 23 "$@"
+./read --series pnm --version 24 "$@"
+
+# Init Jubeat
+./read --series jubeat --version saucer "$@"
+./read --series jubeat --version saucer-fulfill "$@"
+./read --series jubeat --version prop "$@"
+./read --series jubeat --version qubell "$@"
+./read --series jubeat --version clan "$@"
+
+# Init IIDX
+./read --series iidx --version 20 "$@"
+./read --series iidx --version 21 "$@"
+./read --series iidx --version 22 "$@"
+./read --series iidx --version 23 "$@"
+./read --series iidx --version 24 "$@"
+
+# Init IIDX Omnimix
+./read --series iidx --version omni-20 "$@"
+./read --series iidx --version omni-21 "$@"
+./read --series iidx --version omni-22 "$@"
+./read --series iidx --version omni-23 "$@"
+./read --series iidx --version omni-24 "$@"
+
+# Init DDR
+./read --series ddr --version 12 "$@"
+./read --series ddr --version 13 "$@"
+./read --series ddr --version 14 "$@"
+./read --series ddr --version 15 "$@"
+./read --series ddr --version 16 "$@"
+
+# Init SDVX
+./read --series sdvx --version 1 "$@"
+./read --series sdvx --version 2 "$@"
+./read --series sdvx --version 3 "$@"
+./read --series sdvx --version 4 "$@"
+
+# Init Museca
+./read --series museca --version 1 "$@"
+./read --series museca --version 1+1/2 "$@"
+
+# Init Reflec Beat
+./read --series reflec --version 1 "$@"
+./read --series reflec --version 2 "$@"
+./read --series reflec --version 3 "$@"
+./read --series reflec --version 4 "$@"
+./read --series reflec --version 5 "$@"
+./read --series reflec --version 6 "$@"
diff --git a/cardconvert b/cardconvert
new file mode 100755
index 0000000..7d23969
--- /dev/null
+++ b/cardconvert
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.cardconvert "$@"
diff --git a/config/proxy.yaml b/config/proxy.yaml
new file mode 100644
index 0000000..93687ba
--- /dev/null
+++ b/config/proxy.yaml
@@ -0,0 +1,25 @@
+local:
+    # Advertised server IP or DNS entry games will connect to, overwrites remote host.
+    host: '192.168.0.1'
+    # Advertised port games will connect to, overwrites remote port.
+    port: 80,
+
+remote:
+    # List of servers that we recognized, with the host and port that the service is
+    # located at for each server.
+    server1:
+        host: '127.0.0.1'
+        port: 1234
+    server2:
+        host: '127.0.0.1'
+        port: 1573
+
+# Default server, when PCBID doesn't match below. Should be one of the above remote servers.
+default: 'server1'
+# Whether we log verbosely to web server logs.
+verbose: true
+
+# List of PCBIDs and the server they should be redirected to. Servers should be one of the
+# above remote servers.
+pcbid:
+    00010203040506070809: 'server2'
diff --git a/config/server.yaml b/config/server.yaml
new file mode 100644
index 0000000..da52536
--- /dev/null
+++ b/config/server.yaml
@@ -0,0 +1,59 @@
+database:
+    # IP or DNS entry for MySQL instance
+    address: "localhost"
+    # Database that will be used
+    database: "bemani"
+    # User who has full credentials to the above DB
+    user: "bemani"
+    # Password of said user
+    password: "bemani"
+
+server:
+    # Advertised server IP or DNS entry games will connect to
+    address: "192.168.0.1"
+    # Advertised keepalive address, must be globally pingable
+    keepalive: "127.0.0.1"
+    # What port games will connect to
+    port: 80
+    # Whether games should connect over HTTPS
+    https: False
+    # Advertised frontend URI. Delete this to mask the frontend address.
+    uri: "https://eagate.573.jp"
+    # URI that users hitting the GET interface will be redirected to.
+    # Delete this to return an HTTP error instead.
+    redirect: "https://eagate.573.jp"
+    # Whether PCBIDs must be added to the network before games will work.
+    enforce_pcbid: False
+
+paseli:
+    # Whether PASELI is enabled on the network.
+    enabled: True
+    # Whether infinite PASELI balance is enabled on the network.
+    infinite: True
+
+support:
+    # Bishi Bashi frontend/backend enabled
+    bishi: True
+    # DDR frontend/backend enabled
+    ddr: True
+    # IIDX frontend/backend enabled
+    iidx: True
+    # Jubeat frontend/backend enabled
+    jubeat: True
+    # Museca frontend/backend enabled
+    museca: True
+    # Pop'n Music frontend/backend enabled
+    pnm: True
+    # Reflec Beat frontend/backend enabled
+    reflec: True
+    # SDVX frontend/backend enabled
+    sdvx: True
+
+# Key used to encrypt cookies, should be unique per instance
+secret_key: 'this_is_a_secret_please_change_me'
+# Name of this network
+name: 'e-AMUSEMENT Network'
+# Administrative contact for this network
+email: 'nobody@nowhere.com'
+# Cache DIR, should point somewhere other than /tmp for production instances
+cache_dir: '/tmp'
diff --git a/config/trafficgen.yaml b/config/trafficgen.yaml
new file mode 100644
index 0000000..06bf534
--- /dev/null
+++ b/config/trafficgen.yaml
@@ -0,0 +1,7 @@
+core:
+    # The PCBID that is used for all communication between the server and us
+    pcbid: '00010203040506070809'
+    # Whether we request to encrypt when talking to the server
+    encryption: True
+    # Whether we compress when talking to the server
+    compression: False
diff --git a/data/iidx.tsv b/data/iidx.tsv
new file mode 100644
index 0000000..a8d902d
--- /dev/null
+++ b/data/iidx.tsv
@@ -0,0 +1,19 @@
+9042	LOVE♥SHINE		
+9045	Sweet Sweet ♥ Magic		
+15014			OUVERTÜRE
+15061	Übertreffen		
+15214		kobo vs kr:agué	
+16034	Punch Love♡仮面		
+17035		上野圭市(transforming into Masao♥Lovely) feat. 星野奏子	
+18065	Love♥km		
+20007	キャトられ♥恋はモ～モク	ギュ～っとしたい♥Prim	
+20027	Präludium		
+21002	旋律のドグマ～Misérables～		
+21023	Atröpøs		
+21030	超!!遠距離らぶ♡メ～ル		
+21060	ÆTHER		
+21227			OUVERTÜRE
+21254	Punch Love♡仮面		
+22009	表裏一体！？怪盗いいんちょの悩み♥		
+24008	¡Viva!		
+24023	焱影		
diff --git a/data/jubeat.tsv b/data/jubeat.tsv
new file mode 100644
index 0000000..38b1b43
--- /dev/null
+++ b/data/jubeat.tsv
@@ -0,0 +1,1119 @@
+10000001	ちっぽけな勇気	FUNKY MONKEY BABYS
+10000002	風になりたい	THE BOOM
+10000003	4	mihimaru GT
+10000004	PLAY THE GAME	ロードオブメジャー
+10000005	一色	
+10000006	粉雪	
+10000007	Love so sweet	
+10000008	全力少年	
+10000009	抱いてセニョリータ	
+10000010	キューティーハニー	
+10000011	ふがいないや	
+10000012	こんなに近くで...	
+10000013	POP STAR	
+10000014	天体観測	
+10000015	endscape	
+10000016	負けないで	
+10000017	My Love	川嶋あい
+10000018	Good bye little girl	Mi
+10000019	A Perfect Sky	
+10000020	シャナナ☆	MINMI
+10000021	SPEED KING	
+10000022	Real voice	
+10000023	魁！ミッドナイト	RIKI
+10000024	FREE FREE	鈴木亜美 joins 中田ヤスタカ(capsule)
+10000025	冒険者たち	Do As Infinity
+10000026	キスしてほしい	
+10000027	光のロック	
+10000028	BELIEVE IN LOVE	
+10000029	BLOOD on FIRE	AAA
+10000030	BLUE BIRD	
+10000031	I my me mine	
+10000032	太陽の地図	
+10000033	PEACH	
+10000034	YELL ～エール～	
+10000035	rose	ANNA inspi' NANA(BLACK STONES)
+10000036	bass 2 bass	Ryu☆
+10000037	天国と地獄	Mutsuhiko Izumi
+10000038	GIGA BREAK	96
+10000039	Icicles	Jimmy Weckl
+10000040	Jumping Boogie	Kozo Nakamura
+10000041	Snow Goose	Mutsuhiko Izumi
+10000042	Polaris	Mutsuhiko Izumi
+10000043	Happy Happy	ki☆ki
+10000044	I love マミー	荒牧陽子
+10000045	Chance and Dice	日本少年
+10000046	Y.M.C.A.	Village People
+10000047	I'M IN THE MOOD FOR DANCING	
+10000048	Scatman (Ski Ba Bop Ba Dop Bop)	Scatman John
+10000051	IN THE NAME OF LOVE	Y&Co. feat. Erica
+10000052	Special One	kors k feat. Suzuyo Miyamoto
+10000053	Sandstorm	
+10000062	Crosswind	Mutsuhiko Izumi
+10000064	あいのうた	肥塚良彦
+10000065	Evans	DJ YOSHITAKA
+10000066	In Scottish Highlands	Thomas Howard Lichtenstein
+10000067	SigSig	kors k
+10000068	凛として咲く花の如く	紅色リトマス
+10000069	TRUE♥LOVE	jun feat. Schanita
+10000070	Slang	Kozo Nakamura
+20000001	ロボットハニー	Aira Mitsuki
+20000002	情熱大陸	
+20000003	にんげんっていいな	ガガガSP
+20000004	Musical Messenger	九州男
+20000006	今	ET-KING
+20000007	Kiss & Ride	中塚武
+20000008	愛 NEED	キマグレン
+20000009	バカサバイバー	ウルフルズ
+20000010	Garden of Love	
+20000011	素直になれたら	
+20000012	労働 CALLING	怒髪天
+20000013	パンキッシュ☆	mihimaru GT
+20000014	鬼帝の剣	ALI PROJECT
+20000015	キミ、メグル、ボク	
+20000016	HOT LIMIT	
+20000017	PROMiSE	
+20000018	My SunShine	
+20000019	明日ハレルヤ！	岡本真夜x大橋卓弥(from スキマスイッチ)
+20000020	Fantasista	Dragon Ash
+20000021	星に願いを	flumpool
+20000022	夏祭り	
+20000023	ワープ	lego big morl
+20000024	フルカラープログラム	UNISON SQUARE GARDEN
+20000025	ちょうどいいとこにいたい	たむらぱん
+20000026	友達に贈る歌	Sonar Pocket
+20000027	マスタッシュ	木村カエラ
+20000028	チャクラ	BENNIE K
+20000029	ふりぃ	阿部真央
+20000030	Clover	Yum!Yum!ORANGE
+20000031	空色デイズ	
+20000032	Lovin' Life	
+20000033	more more more	capsule
+20000034	愛をとりもどせ!!	
+20000037	ウィリアム・テル序曲	W.T.Orchestra
+20000038	隅田川夏恋歌	seiya-murai feat. ALT
+20000039	AREA 51	96
+20000040	eyes	小野秀幸
+20000041	STARLIT DUST/スティルに捧ぐ	Des-ROW+ANT
+20000042	Queen's Paradise	Nanako
+20000043	coming true	GUHROOVY Vs. L.E.D.
+20000044	Shining Star	Sota Fujimori feat. Nagisa
+20000045	Good-bye Chalon	猫叉Master+
+20000046	SWEET ANGEL	古川もとあき
+20000047	INVISIBLE WORLD	SILKY F
+20000048	Russian Snowy Dance	Mutsuhiko Izumi
+20000049	恋のメリーゴーランド	森野くま子
+20000050	ECO FIGHTER	入尾信充
+20000051	Macuilxochitl	TOMOSUKE
+20000053	Haru Haru	BIGBANG
+20000055	Control	kary ng
+20000056	Golden House	bma 群星
+20000057	GyaShan	Lollipop
+20000100	MR.アンディ	UNISON SQUARE GARDEN
+20000101	そらとぶひかり	COLTEMÖNIKHA
+20000102	Secret Word	GOLLBETTY
+20000103	理由なき反抗	おとぎ話
+20000104	A Dance & A Beer	REDEMPTION 97
+20000105	Infinity	GIRL NEXT DOOR
+20000106	夢見る少女じゃいられない	相川七瀬
+20000107	Love You	Q;indivi
+20000108	夢	鴉
+20000109	Share The World	東方神起
+20000110	a fact of life	FACT
+20000111	アンビリ一バボ一 feat.TAKUYA	mihimaru GT
+20000112	紅空	lecca
+20000113	Jump Pump	miray
+20000114	歩いて帰ろう	斉藤和義
+20000120	AIR RAID FROM THA UNDAGROUND	GUHROOVY
+20000121	スペースカーニバル	shooting star
+20000122	Lead Me	SHOGO
+20000123	少年リップルズ	常盤ゆう
+20000124	コイノチカラ	石阪久美子
+20000125	ALBIDA	DJ YOSHITAKA
+30000001	大都会交響楽	PIZZICATO FIVE
+30000002	NEU!	√thumm
+30000003	Supernova	9mm Parabellum Bullet
+30000004	only my railgun	fripSide
+30000005	Love Space Ship	SHANADOO
+30000006	An imitation's superstar	VOLA & THE ORIENTAL MACHINE
+30000007	サマータイム	DigiCut
+30000008	paparuwa	Fantastic Plastic Machine
+30000009	アルクアラウンド	サカナクション
+30000010	銀河	フジファブリック
+30000011	元気でやってるのかい?	イルリメ
+30000012	Kick It Out	ブンブンサテライツ
+30000012	Kick It Out	ブンブンサテライツ
+30000013	SHINE×SHINE×SHINE×SHINE	エイプリルズ
+30000014	B・M・W	SNAIL RAMP
+30000015	Runner	爆風スランプ
+30000016	スマイル一番 イイ♀	アンティック-珈琲店-
+30000017	大迷惑	UNICORN
+30000018	Supercalifragilisticexpialidocious	
+30000019	Lost Boy	SEAMO
+30000020	Promise	NEW STRIKE ZIPPER
+30000021	Whatever	SOULHEAD
+30000022	lovely my girl	シュクレット
+30000023	キラキラ☆	Mizca
+30000024	LOVE & JOY	木村由姫
+30000025	Walkin', runnin', singin', fightin'	BREMEN
+30000026	HOT DOG	THE BAWDIES
+30000027	じょいふる	
+30000028	だから一歩前へ踏み出して	Hi-Fi CAMP
+30000029	BRANDNEW DAYS	Purple Days
+30000030	city talk	Half-Life
+30000031	日進月歩	Jeepta
+30000032	HALLUCINATION	UZUMAKI
+30000033	SAMURAI GROOVE	DUFF
+30000034	Are U Ready?	mini
+30000035	メンドクサイ愛情	大島麻衣
+30000036	白鳥の湖	Swan Lake Orchestra
+30000037	Green Green Dance	Mutsuhiko Izumi
+30000038	Ready Go!!	荒牧陽子
+30000039	Shining Wizard	96
+30000040	ALL MY HEART -この恋に、私の全てを賭ける-	SUPER HEROINE 彩香-AYAKA-
+30000041	Love♥km	dj TAKA feat. REN
+30000042	fellow	ピンクターボ
+30000043	KUNG-FU MAMA	seiya-murai feat.ALT
+30000044	さよならトリップ	Dormir
+30000045	Far east nightbird	猫叉Master
+30000046	Prophet Vibe	Sota Fujimori feat. Calin
+30000047	STREET DANCER	SILKY F
+30000048	I'm so Happy	Ryu☆
+30000049	Shine On Me	kors k
+30000050	Sweet Rain	Y&Co. feat. Karin
+30000051	勝って泣こうゼッ!	T-Pistonz+KMC
+30000052	カーニバる？	ナオト・インティライミ
+30000101	SOS	たむらぱん
+30000102	タイムラグ	つしまみれ
+30000103	LISTEN TO THE STEREO!!	GOING UNDER GROUND
+30000104	トラヴェルマシン	Hilcrhyme
+30000105	Sunshine Girl	moumoon
+30000106	今すぐKiss Me	JURIAN BEAT CRISIS
+30000107	君をのせて feat.sayurina	新井大樹
+30000108	となりのトトロ feat.sayurina	新井大樹
+30000109	hammer ska	10-FEET
+30000110	ニンジャマンジャパンのテーマ	ニンジャマンジャパン
+30000111	Dough-nut's Town's Map	Plus-Tech Squeeze Box
+30000112	MIND SHIFT	WORLD ORDER
+30000113	Cake House (Korean.Ver)	TENSI LOVE
+30000114	R.P.G.~Rockin' Playing Game	SuG
+30000115	ファンタジー	世界の終わり
+30000116	CAT'S EYE	杏里
+30000121	FLOWER	DJ YOSHITAKA
+30000122	Theory of Eternity	TAG
+30000123	Jailbreak	Kozo Nakamura
+30000124	キルト	Des-Sana+wpt9
+30000125	STELLAR WIND	L.E.D.
+30000126	うらもからだも落花微塵	Nanako
+30000127	concon	S-C-U
+30000128	愛と勇気の三度笠ポン太	荒牧陽子
+40000001	Love Train	Marin&Riena
+40000002	恋のダイヤル6700	Dream5
+40000003	Calling	紗羅マリー
+40000004	PASSPORT	MEG
+40000005	キャッチーを科学する	アルカラ
+40000006	がんばれよ	TEE
+40000007	SUPER∞STREAM	
+40000008	グローランプ	banbi
+40000009	Rocknrolla!	[Champagne]
+40000010	ヘビーローテーション	AKB48
+40000011	きみはキョンシー RAM RIDER REMIX	シトラスラベンダー
+40000012	come again	m-flo
+40000013	Baroque Hoedown	
+40000014	CARTOON HEROES	
+40000015	Love at First Sight	Fear, and Loathing in Las Vegas
+40000016	女々しくて	ゴールデンボンバー
+40000017	コネクト	♪♪♪♪♪
+40000018	Diver	
+40000019	シャカビーチ～Laka Laka la～	
+40000020	MirrorDance	androp
+40000021	僕らの永遠 ～何度生まれ変わっても、手を繋ぎたいだけの愛だから～	WEAVER
+40000022	Let's ダバダバ	
+40000023	フレンズ	
+40000024	15 Doors	moumoon
+40000025	LOVE LOVE SHOW	THE YELLOW MONKEY
+40000026	ダンデライオン	
+40000027	PRIME TIME	capsule
+40000028	マスターピース	mihimaru GT
+40000029	アイデンティティ	サカナクション
+40000030	Parachute	トクマルシューゴ
+40000031	纒	ET-KING
+40000032	タッチ	
+40000033	ESCAPE	Moon Child
+40000034	On and On	中塚武
+40000035	GOOD LUCKY!!!!!	グッキー
+40000036	SWEET CUBE	plazma
+40000037	オムライス	オーロラ三人娘
+40000038	Universe Universe	avengers in sci-fi
+40000039	猫がニャ～て、犬がワンッ!	neco眠る with 二階堂和美
+40000040	maximum the hormone	マキシマム ザ ホルモン
+40000041	防衛本脳	Daisy×Daisy
+40000042	Real Clothes<Album Mix>	Jazztronik
+40000044	陽炎	星野奏子
+40000045	WONDER WALKER	L.E.D.
+40000046	Red Goose	Mutsuhiko Izumi
+40000047	トルコ行進曲	T.M.Orchestra
+40000048	Starlight Parade	肥塚良彦
+40000049	yellow head joe	S-C-U
+40000050	Devil Fish Dumpling	96
+40000051	アルストロメリア	TAG
+40000052	FRIENDSHIP	PON
+40000053	瞬	小野秀幸
+40000054	流砂の嵐	劇団レコード
+40000055	[E]	dj MAX STEROID
+40000056	polygon	Sota Fujimori
+40000057	量子の海のリントヴルム	黒猫ダンジョン
+40000058	THIS NIGHT (jubeat EDITION)	TЁЯRA
+40000059	electro peaceful	Mr.T
+40000060	HEAVENLY MOON	Tatsh
+40000101	Gravity	HaKU
+40000102	くちばしにチェリー	EGO-WRAPPIN'
+40000103	Heart of Gold	Alice Nine
+40000104	CRAZY FOR YOU	
+40000105	this storyends	winnie
+40000106	こどなの階段	南波志帆
+40000107	オリオンをなぞる	UNISON SQUARE GARDEN
+40000108	ダイナマイト	→ Pia-no-jaC ←
+40000109	FIGHTERS	三代目 J Soul Brothers
+40000110	PONPONPON	きゃりーぱみゅぱみゅ
+40000111	やさしくなりたい	斉藤和義
+40000112	以心伝心	Little Blue boX
+40000113	HEKIREKI	LAST ALLIANCE
+40000114	WAVES; Q;indivi+WISE	Q;indivi+
+40000115	ダダパラ!!	girl next door
+40000116	女子力←パラダイス	SUPER☆GiRLS
+40000121	cloche	Qrispy Joybox
+40000122	TWINKLE♡HEART	jun
+40000123	幸せのかたち	あさき
+40000124	HEAT-BIT-HIT-BEAT	V.C.O.
+40000125	532nm	Ryu☆
+40000126	candii	八王子P
+40000127	JOMANDA	DJ YOSHITAKA
+40000128	ナナホシ	S-C-U
+40000129	The Wind of Gold	kors k
+40000151	Rush!!	kors k feat. 吉河順央
+40000152	DOUBLE IMPACT	DOUBLE IMPACT
+40000153	歌の翼	あーたん
+40000154	Summer Holiday	達見 恵 featured by 佐野宏晃
+40000155	逆ナンされたのにドタキャン!!	good-cool ft. すわひでお
+40000156	800nm	Another Infinity (Ryu☆×Starving Trancer)
+40000157	RePrise	SHOGO
+40000158	Plum	肥塚良彦
+40000159	Riot of Color	TAG
+40000160	ギタ・ドラ・jubeat大夏祭りのテーマ	DNM盛り上げ隊
+50000001	Synchrogazer	
+50000002	newsong	
+50000003	Buddy	坂本真綾
+50000004	MAMORE!!!	アイドリング!!!
+50000005	ひかり	KREVA
+50000006	a burning bullet	LAST ALLIANCE
+50000007	風一揆	風男塾
+50000008	新たな幕開け	新井大樹
+50000009	Just Awake	Fear,and Loathing in Las Vegas
+50000010	猛烈宇宙交響曲・第七楽章「無限の愛」	ももいろクローバーZ
+50000011	つけまつける	きゃりーぱみゅぱみゅ
+50000012	シンデレラ	奥華子
+50000013	RIGHT NOW	GOOD4NOTHING
+50000014	INFORMER	lecca
+50000015	サブリナ	家入レオ
+50000016	GO	オワリカラ
+50000017	愛	OverTheDogs
+50000018	Switch On!	土屋アンナ
+50000019	NO WAVE≒斜陽”	0.8秒と衝撃。
+50000021	squall	猫叉Master+
+50000022	Vermilion	Remo-con
+50000023	アストライアの双皿	ZODIACSYNDICATE
+50000024	フー・フローツ	Nanako
+50000025	Mother Ship	Sota Fujimori
+50000026	NIGHT FLIGHT	小野秀幸
+50000027	我が麗しのバレンシア	劇団レコード feat. Mille Face
+50000029	Mirage	Mutsuhiko Izumi
+50000030	PRANA	TAG
+50000031	quaver♪	Risk Junk
+50000032	Fantasia	TËЯRA
+50000033	Dragontail Butterfly	Tom-H@ck feat.Nadia
+50000034	Amalgamation	Mystic Moon
+50000035	DIAVOLO	度胸兄弟
+50000036	Beastie Starter	GUHROOVY
+50000037	亡国のヒストリア	劇団レコード
+50000038	†渚の小悪魔ラヴリィ～レイディオ†	夏色ビキニのPrim
+50000039	Happy	Sota Fujimori
+50000040	恋閃繚乱	2B-Waves
+50000041	Magnetic	Sota Fujimori
+50000042	Baby Bleep March	seiya-murai
+50000043	Vanity	Vivian
+50000044	Asterism	ZUKI
+50000045	attack in the minor key	Mr.T
+50000046	BLUE STRAGGLER	L.E.D.
+50000047	POINT ZERO	猫叉Master+
+50000048	405nm (Ryu☆mix)	Another Infinity
+50000049	Little Star	REDALiCE feat. Ayumi Nomiya
+50000050	LUV CAN SAVE U	HIDEKI NAGANUMA
+50000051	One Night Carnival	氣志團
+50000052	いっぽんでもニンジン	なぎらけんいち
+50000053	オレンジ	
+50000054	Find your way	J.Speaks
+50000055	FANTASTIC★DREAMER feat.SO-TA,Rhyzm Horse,Yoonji	MAYA feat.SO-TA,Rhyzm Horse,Yoonji
+50000056	SEED	DJ YOSHITAKA
+50000057	Twinkle Wonderland	Qrispy Joybox feat. Sana
+50000058	キラキラ☆ステーション	Tatsh feat. Prico
+50000059	milky ice bear	S-C-U
+50000060	Daily Lunch Special	Lucky Vacuum
+50000061	愛する覚悟	シシド・カフカ
+50000062	LANA - キロクノカケラ -	TOMOSUKE×Jazzin'park
+50000063	嘘憑きとサルヴァドール	小南泰葉
+50000064	マジLOVE1000%	ST☆RISH
+50000065	スリル	布袋寅泰
+50000066	From Noon Till Dawn feat.Tabu Zombie & Kunikazu Tanaka	ストレイテナー
+50000067	ETERNAL BLAZE	
+50000068	Dance My Generation	ゴールデンボンバー
+50000069	Get Off of My Way	MAN WITH A MISSION
+50000070	恋とキングコング	日向美ビタースイーツ♪
+50000071	朧	HHH×MM×ST
+50000072	Mynarco	positive MAD-crew
+50000073	spring pony	S-C-U
+50000074	この子の七つのお祝いに	あさき
+50000075	Across the nightmare	Jimmy Weckl
+50000076	SILVER☆DREAM	jun
+50000077	Holy Snow	Mutsuhiko Izumi
+50000078	True Blue	dj TAKA feat. AiMEE
+50000079	Cassis	肥塚良彦
+50000080	蒼天	Tatsh
+50000081	snow prism	Qrispy Joybox
+50000082	紅焔	PON
+50000083	Cosmic Hurricane	TAG
+50000084	Pink Rose	Kiyommy+Seiya
+50000085	記憶の欠片	Sana
+50000086	HEART BEAT FORMULA	TAG
+50000087	天上の果て	マジックアカデミー管弦楽部×劇団レコード
+50000088	闘いの刻-jubeatREMIX-	マジックアカデミー管弦楽部×劇団レコード
+50000089	Chronos	TAG
+50000090	O JIYA	ASMAT & emi
+50000091	Concertino in Blue	佐々木博史
+50000092	雨ノチHello	TLION69
+50000093	紅蓮の焔	劇団レコード feat. 浅葉リオ
+50000094	LANA - Answer I -	TOMOSUKE×Jazzin'park
+50000095	LANA - ヒトリノウタ -	TOMOSUKE×Jazzin'park
+50000096	トリカゴノ鳳凰	L.E.D. Vs. 幽閉サテライト
+50000097	Proof of the existence	猫叉Master+
+50000098	Thor's Hammer	ユニバーサル度胸兄弟
+50000099	Plan 8	Ryu☆
+50000100	Sol Cosine Job 2	DJ TECHNORCH
+50000101	Rainbow after snow	猫叉Master feat. 林ももこ
+50000102	Confiserie	L.E.D. vs S-C-U
+50000103	No pain, No game	nano
+50000104	ハートに火をつけて	9mm Parabellum Bullet
+50000105	Go to the top	倖田來未
+50000106	V.I.P	
+50000107	此岸の戯事	Akhuta
+50000108	OVERHEAT -Type J-	DOUBLE IMPACT
+50000109	ヒーロー	鈴木友里絵
+50000110	君の元へ	久保田祥平
+50000111	Move That Body	Expander
+50000112	Arousing	DJ TOTTO feat. 吉河順央
+50000113	Sakura Sunrise	Ryu☆
+50000114	New Decade	Sota F.
+50000115	Go For The Top	U1 overground
+50000116	華爛漫 -Flowers-	TЁЯRA
+50000117	heron	S-C-U
+50000118	New Gravity	Starving Trancer
+50000119	梅雪夜	Qrispy Joybox feat. mao
+50000120	Clumsy thoughts	猫叉Master feat.*spiLa*
+50000121	この青空の下で	TAG meets eimy
+50000122	anemone	S-C-U feat.Qrispy Joybox
+50000123	VALLIS-NERIA	DJ YOSHITAKA
+50000124	Our Faith	kors k
+50000125	愛は不死鳥の様に	真紅の薔薇の騎士Prim
+50000126	Lisa-RICCIA	DJ YOSHITAKA
+50000127	Broken	dj TAKA feat. AiMEE
+50000128	ストレイ・マーチ	少年ゾディアック
+50000129	ZZ	D.J.Amuro
+50000130	キミ記念日～生まれて来てくれてアリガトウ。～	ソナーポケット
+50000131	LANA - Answer II -	TOMOSUKE×Jazzin'park
+50000132	Wow Wow VENUS	VENUS
+50000133	DRAGON KILLER	96 vs. Mutsuhiko Izumi
+50000134	Elemental Creation	dj TAKA meets DJ YOSHITAKA
+50000135	ラキラキ	Mutsuhiko Izumi & S-C-U
+50000136	晴天Bon Voyage	TOMOSUKE × seiya-murai feat. ALT
+50000137	STULTI	MAX MAXIMIZER VS DJ TOTTO
+50000138	虹色の花	Akhuta y OJ
+50000139	お米の美味しい炊き方、そしてお米を食べることによるその効果。	大日本鉄倶楽部 【あさき&96】
+50000140	創世ノート	PON+wac
+50000141	Synergy For Angels	TAG×U1-ASAMi
+50000142	Empathetic	Sota÷Des
+50000143	GAIA	猫叉L.E.D.Master+
+50000144	とってもとっても、ありがとう。	日向美ビタースイーツ♪
+50000145	Lifetime Journey	J.Speaks
+50000146	ふしぎなくすり	上野圭市 feat. SATOE
+50000147	I/O	Ryu☆
+50000148	つぼみ	達見 恵 featured by 佐野宏晃
+50000149	RED ZONE	Tatsh&NAOKI
+50000150	Flip Flap	kors k
+50000151	イブの時代っ!	日向美ビタースイーツ♪
+50000152	めうめうぺったんたん!!	日向美ビタースイーツ♪
+50000153	にんじゃりばんばん	きゃりーぱみゅぱみゅ
+50000154	切ないほど	ゴールデンボンバー
+50000155	灼熱の翼	マジックアカデミー管弦楽部×劇団レコード
+50000156	sola	小野秀幸
+50000157	le mirage	Vivian
+50000158	Never Look Back in Sorrow	AIKO OI
+50000159	chaplet	DJ TOTTO
+50000160	Little Flipper	S-C-U
+50000161	HEART BEAT	加藤ミリヤ
+50000162	スーパーフレア	The Mirraz
+50000163	Ahead Of The Light	MIYAVI
+50000164	「善悪の彼岸」	小南泰葉
+50000165	LANA - ココロノキオク -	TOMOSUKE×Jazzin'park
+50000166	LANA - セカイノハズレ -	TOMOSUKE×Jazzin'park
+50000167	GOLD	UVERworld
+50000168	sister's noise	fripSide
+50000169	RPG	SEKAI NO OWARI
+50000170	ギャグ	星野 源
+50000171	サヨナラ・ヘヴン	猫叉Master
+50000172	リメンバーリメンバー	rino & m@sumi from plastic penguin
+50000173	恋はどう？モロ◎波動OK☆方程式!!	あべにゅうぷろじぇくと feat.佐倉沙織 produced by ave;new
+50000174	Snowfield Express	TIME CAPSULE Lab.
+50000175	Brand New World	VENUS
+50000176	防人恋歌	Ax feat.夏川陽子
+50000177	黒髪乱れて修羅となりて	村正クオリア
+50000178	カラルの月	猫叉劇団
+50000179	neu	少年ラジオ
+50000180	少年は空を辿る	Power Of Nature
+50000181	終末を追う者	S-C-U×PON
+50000182	Windy Fairy	DJ TOTTO
+50000183	PULSE LASER	ヒゲドライバー
+50000184	TYCOON	SOUND HOLIC feat. Nana Takahashi
+50000185	caramel ribbon	P*Light
+50000186	Dynasty	Yooh
+50000187	Hello world!	Music by 源屋, Vocal by SOPHY
+50000188	虚空と光明のディスクール	日向美ビタースイーツ♪
+50000189	Straight Oath	矢鴇つかさ feat. 三澤秋
+50000190	モンスターのかくれんぼ	Rihwa
+50000192	ViViD	May'n
+50000193	マジLOVE2000%	ST☆RISH
+50000194	Baby Sweet Berry Love	小倉 唯
+50000195	Triple Journey -S-C-U EDITION-	Triumvirate
+50000196	Fly with me	TAG
+50000197	キケンな果実	達見 恵 featured by 佐野宏晃
+50000198	Right on time (Ryu☆Remix)	Ryu☆
+50000199	万華鏡	Jimmy Weckl
+50000200	Dragon Blade	Kozo Nakamura
+50000201	夏・KOI・ムッシュ!!	ビーチサンダルズ
+50000202	TSAR BOMBA	L.E.D.
+50000203	encounter	猫叉Master+
+50000204	イ号零型	あさき
+50000205	Life Connection	world sequence
+50000206	We're so Happy	Ryu☆
+50000207	Gimme a Big Beat	kors k
+50000208	Stand Alone Beat Masta	GUHROOVY
+50000209	回レ! 雪月花	歌組雪月花
+50000210	Romancing Layer	TAG
+50000211	インベーダーインベーダー	きゃりーぱみゅぱみゅ
+50000212	凛として咲く花の如く～ひなビタ♪edition～	日向美ビタースイーツ♪
+50000213	robin	S-C-U
+50000214	カラフルミニッツ	Qrispy Joybox feat.mao
+50000215	Water Horizon	青龍
+50000216	優勢オーバードーズ	PON
+50000217	Take Your Way	livetune adding Fukase(from SEKAI NO OWARI)
+50000218	でんでんぱっしょん	でんぱ組.inc
+50000219	1 2 3 ～恋がはじまる～	
+50000220	影縫い胤撒き	Akhuta
+50000221	最終回STORY	MY FIRST STORY
+50000222	キセキ	
+50000223	人生は素晴らしい物語。(Dear Japan Remix)	ハジ→
+50000224	Follow Me	E-girls
+50000225	リーゼントブルース	RIKI
+50000226	METROPOLIS	→Pia-no-jaC←
+50000227	DNA狂詩曲	ももいろクローバーZ
+50000228	セツナトリップ	Last Note. feat. GUMI
+50000229	ドリームメイカー	TRIPLANE
+50000230	ジャパンパン～日本全国地元化計画～	C&K
+50000231	eternal reality	fripSide
+50000232	Endless Chain ～2人でトリガーをひこう～	私立BEMANI学園軽音楽部
+50000233	天ノ弱	164 feat. GUMI
+50000234	ちくわパフェだよ☆CKP	日向美ビタースイーツ♪
+50000235	ほしふり	Sana
+50000236	Sky Is The Limit	Sota F. feat.Anna
+50000237	ツキミチヌ	CULTVOICE by S.S.D. PRODUCTS
+50000238	ポップミュージック論	ギラギラメガネ団
+50000239	ZED	USAO
+50000240	CHEAT DANCER - short ver -	X.I.P.
+50000241	Show up ! - short ver -	3 Majesty
+50000242	athletic meet of sound toy	Mr.T
+50000243	LANA - キロクノカケラ (sasakure.UK Framework Remix) -	TOMOSUKE×Jazzin'park
+50000244	HYDRA	96
+50000245	カタルシスの月	日向美ビタースイーツ♪
+50000246	SAVIOR OF SONG(feat. MY FIRST STORY)	ナノ
+50000247	ブルー・フィールド	Trident (渕上 舞・沼倉愛美・山村 響)
+50000248	Ray	源屋
+50000249	Gott	Hommarju
+50000250	Unicorn tail Dustboxxxx RMX	Dustboxxxx
+50000251	unisonote	onoken
+50000252	Mono Logic	DJ NAGAI feat. Ayumi Nomiya
+50000253	Nature (jubeat version)	Mutsuhiko Izumi
+50000254	Stella Sinistra	Akhuta Philharmonic Orchestra
+50000255	マインド・ゲーム	96 with メカショッチョー
+50000256	PUNISHER	TAG×PON
+50000257	HYENA	Hommarju
+50000258	Squeeze	VENUS feat. Mutsuhiko Izumi
+50000259	デッドボヲルdeホームラン	猫叉Masterβ2
+50000260	野球の遊び方　そしてその歴史　～決定版～	あさき大監督
+50000261	轟け！恋のビーンボール！！	ダイナミック野球兄弟 v.s. クロスファイヤーPrim
+50000262	IX	dj TAKA VS DJ TOTTO feat.藍
+50000263	恋愛観測	NU-KO
+50000264	December Breeze	dj silverberg
+50000265	8 -eight-	Tom-H@ck feat.Nadia
+50000266	Condor	Remo-con
+50000267	いーあるふぁんくらぶ	みきとP
+50000268	ロストワンの号哭	Neru
+50000269	smooooch・∀・	kors k
+50000270	Second Heaven	Ryu☆
+50000271	V	TAKA
+50000272	恋する☆宇宙戦争っ!!	Prim
+50000273	Dispersion Star	ZUKI
+50000274	星屑のキロク	小野秀幸
+50000275	Engraved Mark	Ryu☆ ∞ Des-ROW
+50000276	Milchstraße	Buluka & Nilo
+50000277	DANCE ALL NIGHT	Sota Fujimori
+50000278	Thank You Merry Christmas	VENUS
+50000280	time granular	ZUKI
+50000281	Energy	SAYA
+50000282	ホーンテッド★メイドランチ	日向美ビタースイーツ♪
+50000283	Born to be	ナノ
+50000284	閃光のPRISONER	南里侑香
+50000285	カーニバル	ケツメイシ
+50000286	BLUE DRAGON	青龍
+50000287	Follow Tomorrow	HHH×MM×ST
+50000288	SHION	DJ YOSHITAKA
+50000289	101回目の呪い	ゴールデンボンバー
+50000290	もったいないとらんど	きゃりーぱみゅぱみゅ
+50000291	ラクガキスト	cosMo@暴走P feat.GUMI
+50000292	ファントムヴァイブレーション	キュウソネコカミ
+50000293	aura	Expander
+50000294	走れメロンパン	日向美ビタースイーツ♪
+50000295	滅びに至るエランプシス	日向美ビタースイーツ♪
+50000296	My HERO	chairmans
+50000297	Everybody Say EDOGAWA	EDOist
+50000298	HAPPY☆きたかた	KIRA☆GIRL
+50000299	ルシャナの気持ち	Le Siana
+50000300	my cosmic world	silQ
+50000301	Dong! Dong!	Star☆T
+50000302	マーメイド	T!P
+50000303	ドリームキャッチャー	アイくるガールズ
+50000304	僕は君に恋をした	アイドル教室
+50000305	Field on!	サザン☆クロス
+50000306	LUCKY-YO!!	だいやぁ☆もんど
+50000307	Boom! Boom! Miracle Emotion	ひろしま MAPLE★S
+50000308	CAPTIVE	フルーティー♡
+50000309	We are チャリンコエンジェルス	浦安マリンエンジェルス
+50000310	乙女の真骨頂	乙女の純情
+50000311	川崎純情音頭	川崎純情小町☆
+50000312	Determination	柊木りお
+50000313	瞬間 I LOVE YOU	H&A.
+50000314	MITOれて！いばらきっしゅだ～りん	水戸ご当地アイドル(仮)
+50000315	LoveLove DokiDoki	水戸ご当地アイドル(仮)
+50000316	think about you	HaKU
+50000317	dye it white	HaKU
+50000318	A to Z	OSAKA翔GANGS
+50000319	ザッツ！KAIYODO	はちきんガールズ
+50000320	全城熱愛 -Feel the Love-	羅志祥 -Show Lo-
+50000321	大藝術家 -The Great Artist-	蔡依林 -Jolin Tsai-
+50000323	ドーパミン	U1 overground
+50000324	Timberwolves	S-C-U
+50000325	枝に結ぶ願い	Akhuta
+50000326	アイネクライネ	→Pia-no-jaC←
+50000327	バンブーソード・ガール	cosMo＠暴走P
+50000328	幻想系世界修復少女	Last Note.
+50000329	Idola	iconoclasm feat.GUMI
+50000330	STERLING SILVER	TAG
+50000332	Blue Goose	Mutsuhiko Izumi
+50000333	十面相	YM feat.GUMI
+50000334	ケッペキショウ	すこっぷ feat.GUMI
+50000335	ルービックキューブ	otetsu feat.GUMI
+50000336	非公開日誌	みきとP feat.GUMI
+50000337	きょうもハレバレ	ふわりP feat. GUMI's
+50000338	Metric	Hommarju
+50000339	FUNKY SUMMER BEACH	P*Light
+50000340	電司 -DANCE-	LOLLIPOP F
+50000341	Don't stop the music	Dream Girls
+50000342	嗶嗶嗶 -Bi Bi Bi-	謝金燕 -Jeannie Hsieh-
+50000343	都会征服Girls☆	日向美ビタースイーツ♪
+50000344	Cleopatrysm	ピラミッ℃
+50000345	御千手メディテーション	昇天家族
+50000346	KHAMEN BREAK	くふおー
+50000347	passionate fate	Ryu☆
+50000348	猫侍の逆襲	猫叉Master
+50000349	ポチコの幸せな日常	NU-KO
+50000350	Resurrection	Dormir
+50000351	ハンガリー舞曲 第5番 (jubeat version)	H.D.5 Orchestra
+50000352	ごめんなさいのKissing You	E-Girls
+50000353	Che Che Chelip～魔法のコトバ～	Chelip
+50000355	らいらら	KRD8
+50000357	HeartLatte	TnyGinA
+50000358	キライじゃないのぉ	まなみのりさ
+50000359	ラブラブキュートなハピハピサンデー	Lisapyon♡
+50000360	Daydream café	Petit Rabbit's
+50000361	キラーボール	下衆の極み乙女。
+50000362	とまどい→レシピ	みかくにんぐッ！
+50000363	black bullet	fripSide
+50000367	温故知新でいこっ！	日向美ビタースイーツ♪
+50000368	10000000000	TAG feat. 96
+50000369	きたさいたま2000	LindaAI-CUE (BNGI) 「太鼓の達人」より
+50000370	Garakuta Doll Play	t+pazolite 「maimai」より
+50000371	Got more raves?	E.G.G. 「グルーヴコースター」より
+50000372	Scars of FAUNA	猫叉Master
+50000373	Ignis Danse	Yuji Masubuchi「太鼓の達人」より
+50000374	VERTeX	Hiro「maimai」より
+50000375	FUJIN Rumble	COSIO(ZUNTATA)「グルーヴコースター」より
+50000376	EXORCISM	SOUND HOLIC feat. Nana Takahashi
+50000380	滅亡天使 † にこきゅっぴん	日向美ビタースイーツ♪
+50000381	High School Love	DJ YOSHITAKA feat.DWP
+50000382	planarian	S-C-U
+50000383	7 Colors	kors k feat. 吉河順央
+50000384	コドモライブ	onoken feat.asami
+50000385	Spanish Snowy Dance	Mutsuhiko Izumi
+50000386	Ha・lle・lu・jah	SOUND HOLIC feat. Nana Takahashi
+50000387	まるでマトリョーシカ	seiya-murai feat. ALT
+50000388	フレッフレー♪熱血チアガール	裏マドンナだ！Primちゃん
+50000399	朱と碧のランページ	NU-KO
+50000400	乙女繚乱 舞い咲き誇れ	日向美ビタースイーツ♪
+60000001	Niflheimr	Qrispy Joybox
+60000002	glacia	DJ TOTTO
+60000003	Ausretious#1-まどろみ、或いは嘆色の夢-	EOOZ
+60000004	アレスの楯	劇団レコード
+60000005	Two Pianists	小野秀幸
+60000006	Braid & Blade	SHAMDEL
+60000007	prop the world	S-C-U
+60000008	overcomplexification	かめりあ
+60000009	Too Late Snow	movies (moimoi×Xceon×Dai.)
+60000010	アガット	Bazole
+60000011	炎のDiargos	Mutsuhiko Izumi
+60000012	MATATABISTEP	パスピエ
+60000013	Dragon Night	SEKAI NO OWARI
+60000014	天国と地獄	UNISON SQUARE GARDEN
+60000015	不可逆リプレイス	MY FIRST STORY
+60000016	Amazing Parade	Czecho No Republic
+60000017	Highschool ♡ love	E-girls
+60000018	Wake up!	AAA
+60000019	レット・イット・ゴー～ありのままで～	
+60000020	This game	鈴木このみ
+60000021	水月鏡花のコノテーション	日向美ビタースイーツ♪
+60000022	サンキュー。	大原櫻子
+60000023	シルエット	KANA-BOON
+60000024	エクストラ・マジック・アワー	AKINO with bless4
+60000025	過食性:アイドル症候群	スズム feat.GUMI＆MAYU
+60000026	白い雪のプリンセスは	のぼる↑
+60000027	キモチコネクト	東雲心菜 meets 日向美ビタースイーツ♪
+60000028	ツーマンライブ	東雲夏陽 meets 日向美ビタースイーツ♪
+60000038	朝色の紙飛行機	かめりあ
+60000039	女言葉の消失	Sota Fujimori
+60000040	M.A.Y.U.	Ryu☆ feat.MAYU
+60000041	NEON WORLD	SOUND HOLIC feat. Nana Takahashi
+60000042	Scarlet Moon	REDALiCE feat. Ayumi Nomiya
+60000043	Russian Caravan Rhapsody	Power Of Nature
+60000044	ほおずき程度には赤い頭髪	Akhuta
+60000045	取り残された美術(Arranged:HiZuMi)	幽閉サテライト feat. senya
+60000046	Struggle	Masayoshi Minoshima(ALR)
+60000047	ホメ猫☆センセーション	P*Light feat. mow*2
+60000048	妖隠し -あやかしかくし-	DJ TOTTO feat.3L
+60000049	BEAT-NEW-WORLD	ビートまりお（COOL&CREATE）
+60000050	プレインエイジア -PHQ remix-	PHQUASE
+60000051	竹取飛翔 ～ Lunatic Princess (Ryu☆Remix)	Ryu☆
+60000052	千年ノ理	猫叉Master
+60000053	チョコレートスマイル	日向美ビタースイーツ♪ & ここなつ
+60000054	croiX	TeamGrimoire+あま猫
+60000055	きらきらタイム☆	さわわ
+60000056	SWEET HOME PARTY	劇団レコード
+60000057	ミライプリズム	ここなつ
+60000058	EBONY & IVORY	OSTER project
+60000059	パ→ピ→プ→Yeah!	ヒゲドライバー join. shully & Nimo
+60000060	ビビットストリーム	DJ TOTTO
+60000061	リトライ☆ランデヴー	にゃ～たん (CV:村川梨衣)
+60000062	blue moment	ソルラルBOB
+60000063	KHAMEN BREAK -SDVX Infinity MashUp-	くふおー effected by Megacycle
+60000064	In The Breeze	96 & Sota ft. Mayumi Morinaga
+60000065	天空の華	S-C-U × U1 overground
+60000066	TWINKLING	猫叉Master feat.ミミニャミ
+60000067	惑星☆ロリポップ	SOUND HOLIC feat. Nana Takahashi
+60000068	citrus	kamome sano
+60000069	夏色DIARY 俺のjubeat編	猫叉王子 feat.時を駆けるショッチョー
+60000070	Towards the TOWER	SHAMDEL
+60000071	twinkle noise	ZUKI
+60000072	Slluuddggee	Hommarju
+60000073	Sacrifice for Justice	RoughSketch
+60000074	Rock The Club	Expander
+60000075	日天悦扇紊舞	Akhuta
+60000076	霖が哭く	Power Of Nature
+60000077	Diargosの森	Mutsuhiko Izumi
+60000078	ススススペースハリネズミ	S-C-U
+60000079	ナイト・オブ・ナイツ	ビートまりお(COOL&CREATE)
+60000080	Bad Apple!! feat. nomico	Masayoshi Minoshima
+60000081	チルノのパーフェクトさんすう教室	ARM(IOSYS)
+60000082	neko*neko	日向美ビタースイーツ♪
+60000083	MAGICAL SUMMER SMILE	wac feat. VENUS
+60000084	マジLOVEレボリューションズ	ST☆RISH
+60000085	シャイン	宮野真守
+60000086	シュガーソングとビターステップ	UNISON SQUARE GARDEN
+60000087	MURASAKI	蒼井翔太
+60000088	STATIC	164 feat.GUMI
+60000089	恋をしたい、もう一度	デッドボールP feat.GUMI
+60000090	激アツ☆マジヤバ☆チアガール	日向美ビタースイーツ♪
+60000091	フレ降レミライ	北高文芸部女子会
+60000092	はなまるぴっぴはよいこだけ	A応P
+60000093	こんがらガール	Charisma.com
+60000094	漆黒のスペシャルプリンセスサンデー	日向美ビタースイーツ♪
+60000095	メギツネ	BABYMETAL
+60000096	バリ3共和国	でんぱ組.inc
+60000097	MEGA SHAKE IT !	キュウソネコカミ
+60000098	世界五分前仮説	有形ランペイジ
+60000099	からっぽカプセル	内田真礼
+60000100	かくしん的☆めたまるふぉ～ぜっ！	土間うまる（CV:田中あいみ）
+60000101	freaky freak	kamome sano
+60000102	Lovesick Lovetune	VALLEYSTONE feat. 紫崎 雪
+60000103	超越してしまった彼女と其を生み落した理由	Ayatsugu_Otowa
+60000104	最終鬼畜妹フランドール・S	ビートまりお(COOL&CREATE)
+60000105	魔理沙は大変なものを盗んでいきました	ARM(IOSYS)
+60000106	地方創生☆チクワクティクス	日向美ビタースイーツ♪
+60000107	龍と少女とデコヒーレンス	黒猫ダンジョン
+60000108	フラッター現象の顛末と単一指向性の感情論	日向美ビタースイーツ♪
+60000109	僕ガ壊レル前ニ	ゲーム実況もっと！わくわく荘
+60000110	Chloé	DJ Totoriott
+60000113	Just Believe	小寺可南子
+60000115	Crack Traxxxx	Lite Show Magic (t+pazolite vs C-Show)
+60000116	雪女	かねこちはる
+60000119	完全無欠の無重力ダイブ	日向美ビタースイーツ♪
+60000120	ぽかぽかレトロード	日向美ビタースイーツ♪
+60000121	エキサイティング！！も・ちゃ・ちゃ☆	日向美ビタースイーツ♪
+60000122	とびっきりのふわっふわ	日向美ビタースイーツ♪
+60000123	3 A.M. ディテクティブ・ゲーム	日向美ビタースイーツ♪
+60000124	全力バタンキュー	A応P
+60001001	Love♥km [2]	dj TAKA feat. REN
+60001002	Robin [2]	S-C-U
+60001003	FLOWER [2]	DJ YOSHITAKA
+60001004	We're so Happy [2]	Ryu☆
+60001005	†渚の小悪魔ラヴリィ～レイディオ† [2]	夏色ビキニのPrim
+60001006	Too Late Snow [2]	movies (moimoi×Xceon×Dai.)
+60001007	トリカゴノ鳳凰 [2]	L.E.D. Vs. 幽閉サテライト
+60001008	走れメロンパン [2]	日向美ビタースイーツ♪
+60001009	glacia [2]	DJ TOTTO
+60001010	君をのせて feat.sayurina ～天空の城ラピュタ～ [2]	新井大樹
+60001011	Daydream café [2]	Petit Rabbit's
+60001012	Synchrogazer [2]	
+60001013	女々しくて [2]	ゴールデンボンバー
+60001014	キセキ [2]	PooooN
+60001015	にんじゃりばんばん [2]	きゃりーぱみゅぱみゅ
+60001017	天ノ弱 [2]	164 feat. GUMI
+60001018	レット・イット・ゴー～ありのままで～ [2]	
+60001019	Dragon Night [2]	SEKAI NO OWARI
+60001023	イ号零型 [2]	あさき
+70000001	Just a Game	Y&Co.
+70000002	UROBOROS OVERDIVE	L.E.D. feat. YURiCa/花たん
+70000003	変じゃない!!	good-cool ft. すわひでお
+70000004	Ark	kors k
+70000005	RHYZING BEAT	PHQUASE
+70000006	天嘩乱舞	栗須承之介
+70000007	Hunny Bunny	U1 overground
+70000008	運命	No.5 Orchestra
+70000009	CIRCUS U CRIC	Nanako
+70000010	Mirage of the Mirror	SHAMDEL
+70000011	Glitter Flatter Scatter	Project B-
+70000012	きゅん×きゅんばっきゅん☆LOVE	松下feat.Sota & wac
+70000013	混ぜるな危険	筋肉少女帯
+70000015	夏にキスしていいですか？	アルスマグナ
+70000016	Famous Day	[Alexandros]
+70000017	Beautiful	Superfly
+70000018	ディアブロ	水曜日のカンパネラ
+70000019	あなたに恋をしてみました	chay
+70000020	ANTI-HERO	SEKAI NO OWARI
+70000022	勇敢な髑髏	新井大樹
+70000024	新宝島	サカナクション
+70000026	HERO	ソナーポケット
+70000027	ふ・れ・ん・ど・し・た・い	学園生活部
+70000028	GO! GO! MANIAC	放課後ティータイム
+70000029	もってけ！セーラーふく	泉こなた、柊かがみ、柊つかさ、高良みゆき
+70000030	ちょちょちょ！ゆるゆり☆かぷりっちょ！！！	七森中☆ごらく部
+70000033	Two souls -toward the truth-	fripSide
+70000034	Clattanoia	OxT
+70000035	君の知らない物語	
+70000036	衝動	HaKU
+70000039	ハッピーシンセサイザ	EasyPop
+70000042	paranoia	つなまる
+70000043	炉心融解	iroha
+70000045	僕は空気が嫁ない	cosMo@暴走P
+70000046	放課後ストライド	Last Note.
+70000047	月に叢雲華に風	幽閉サテライト feat. senya
+70000048	響縁	豚乙女
+70000049	蒼空に舞え、墨染の桜	Silver Forest feat. さゆり
+70000050	Endless, Sleepless Night	samfree feat. (V)・∀・(V) かにぱん。
+70000051	Scream out! (SDVX EDIT)	A-One
+70000052	お嫁にしなさいっ！	ARM+夕野ヨシミ
+70000053	Runway Drive	FELT
+70000054	DesireDrive	岸田教団＆THE明星ロケッツ
+70000055	Silent Story	発熱巫女～ず
+70000056	SUSHI食べたい feat.ソイソース	ORANGE RANGE
+70000057	ワタリドリ	[Alexandros]
+70000058	Girl A	[Alexandros]
+70000059	アンビリーバーズ	米津玄師
+70000060	Synchronized Love J Rap Jam	ジョー・リノイエ
+70000061	黒髪乱れし修羅となりて～凛 edition～	日向美ビタースイーツ♪
+70000062	キミヱゴサーチ	ここなつ
+70000063	ミライプリズム	ここなつ
+70000064	ポメグラネイト	ここなつ
+70000065	ロンロンへ ライライライ！	ここなつ
+70000066	Good bye, Summer～さよならは言わない～	私立BEMANI学園軽音部 OB
+70000067	星宿る空の下で	Akhuta
+70000068	六花にくちづけ	Akhuta
+70000069	ひだまりデイズ	妹S
+70000070	勇者うまるの華麗なる生活	土間うまる(CV:田中あいみ)
+70000071	T・S・F in にっぽん！	橘・シルフィンフォード(CV:古川由利奈)
+70000072	My Precious	本場切絵(CV:白石晴香)
+70000073	sweet sweet everytime sweet	海老名菜々(CV:影山灯)
+70000074	Entrapment	Expander
+70000075	不可説不可説転	OSTER project
+70000076	FUJIMORI -祭- FESTIVAL	VENUS
+70000077	NISHIMURA -祭- CARNIVAL	S-C-U x U1 feat. VENUS
+70000078	零の位相	kradness
+70000079	SAKURAスキップ	fourfolium
+70000080	Now Loading!!!!	fourfolium
+70000081	Shake!	fourfolium
+70000082	ほっしーの！	fourfolium
+70000083	Boss Rush	USAO
+70000084	倉野川音頭	日向美ビタースイーツ♪＆ひなちくん
+70000085	負けないよ･･･-Runners High-	猫大樹
+70000086	男と女の言い合いのうた	猫大樹
+70000087	夏休み is freedom!!	猫大樹
+70000088	制作現場での出来事	猫大樹
+70000089	反撃	猫大樹
+70000090	眼光	猫大樹
+70000091	厳冬記	猫大樹
+70000092	JACK THE RIPPER feat. Iceon	猫大樹
+70000093	Grand Chariot	xi
+70000094	StrayedCatz	削除
+70000095	Sephirot	SHIKI
+70000096	Angelic Jelly	t+pazolite
+70000097	ZEPHYRANTHES	TAG
+70000098	Triple Counter	DJ YOSHITAKA meets dj TAKA
+70000099	じもとっこスイーツ♪	ホララ・ホリック with 日向美ビタースイーツ♪
+70000100	KHAMEN BREAK -SDVX Infinity MashUp-	くふおー effected by Megacycle
+70000101	時の妖花	ゲーム実況者わくわくバンド
+70000102	aleatrik	nc ft. NRGFactory
+70000103	Cosminflation	山本真央樹
+70000104	Invisible Border	world sequence
+70000105	The Omen	RoughSketch
+70000106	ULTRA HAPPY MEGAMIX	DJ Genki
+70000107	檄	Ryu☆ feat.青龍
+70000108	Against the vulgar aggressor	GUHROOVY
+70000109	Giant Otter Family	S-C-U
+70000110	Megalara Garuda	SYUNN
+70000111	Saturday Night Love	Sota feat. Brenda V.
+70000112	New York EVOLVED	NC underground
+70000113	Destiny lovers	くにたけみゆき
+70000114	Vampire Killer	浅田 靖
+70000115	夢有	Des-ROW・組
+70000116	Bleep Beep Bop	kors k
+70000117	Knell	Project B-
+70000118	Hollywood Galaxy	dj TAKA
+70000119	Daisuke	Y&Co.
+70000120	KAMAITACHI	DJ TECHNORCH fw. GUHROOVY
+70000121	BLACK or WHITE?	BlackYooh vs. siromaru
+70000122	琥珀のくちづけ	日向美ビタースイーツ♪&日向美ブルームーン
+70000123	そこはかとなくロマンセ	日向美ビタースイーツ♪
+70000125	エイリアンエイリアン	ナユタン星人
+70000126	Dreamland。feat. RED RICE（from 湘南乃風）, CICO（from BENNIE K）	ハジ→
+70000127	マホロバケーション	ももいろクローバーZ
+70000128	今夜はパジャマパーティ	日向美ビタースイーツ♪
+70000129	インフェルノ	9mm Parabellum Bullet
+70000130	Ψです I LIKE YOU	でんぱ組.inc
+70000131	ハイパーリアリスト	パスピエ
+70000132	NANIMONO（feat.米津玄師）	中田ヤスタカ
+70000133	ロプノールの商隊	Akhuta
+70000134	蟲の棲む処	かめりあ feat. Nana Takahashi
+70000135	Phlox	Sota Fujimori 2nd Season
+70000136	Lost wing at.0	猫叉Master+
+70000138	SPACE VILLAGE	サイバー劇レコ
+70000139	キミとワタシのオンガク	seiya-murai feat. ALT
+70000140	スカイダイバー	ヒゲドライバー feat.ヒゲドライVAN
+70000141	トキメキストリーム	Qrispy Joybox
+70000142	爆なな☆てすとロイヤー	ARM feat.ななひら
+70000143	バビロニア	劇団レコード
+70000144	バビロニアの旅人たち	Babylonian Vates
+70000145	旅の終わりと祝祭の夜	月船古書堂
+70000146	それは花火のような恋	夏色バーニングラブ☆Prim
+70000147	分けるな危険！モモモモモモーイズム	ARM×狐夢想 feat. 桃井はるこ
+70000148	翡翠の狼	米津玄師
+70000149	LOSER	米津玄師
+70000150	CARNIVOROUS	SOUND HOLIC feat. Nana Takahashi
+70000151	月風魔伝 ～ ビーストメドレー ～	Akhuta
+70000152	がんばれゴエモン ～ ビーストメドレー ～	96
+70000153	GRADIUS II ～ ビーストメドレー ～	Sota Fujimori
+70000155	お茶づけ☆パラダイス	A応P
+70000156	ちょちょいとちょいだよ夢浪漫	A応P
+70000157	椀・of・Relaxation	A応P
+70000158	マトリョシカ	ハチ
+70000159	パンダヒーロー	ハチ
+70000160	ドーナツホール	ハチ
+70000161	怪盗BisCoの予告状！！	Qrispy Joybox
+70000162	びいすと！	ビートまりおとARM
+70000163	にゃんのパレードマーチ♪	DJ TOTTO feat.にゃん
+70000164	nostos	Setaria Virtuoso
+70000165	Four Leaves	Endorfin.
+70000166	crêpe suzette	kamome sano
+70000167	veRtrageS	Riz vs. Shiron
+70000168	Twinbee's Home Town Song	Sota Fujimori
+70000169	CHERNOBOG	漆黒のEBONY
+70000170	ケンぱ！ケンぱ！拳拳ぱん打！	ぱんぱんぱん打
+70000171	アキネイション	ビートまりお(COOL&CREATE)
+70000172	秘密がーる♡乙女	MaMiKa(松下×mitsu×T.kakuta)
+70000173	Sky High	Cuvelia
+70000174	ぱんだしんけん１、２、３ ～ちえ！おっしょさんにはかなわないや！～	おひさまくらぶ
+70000177	Qubellic Prism	Nazzo-Non-Heat
+70000178	FLOOR INFECTION Medley from SOUND VOLTEX×jubeat	United Composers from SOUND VOLTEX
+70000179	POLICY BREAK Medley from SOUND VOLTEX×jubeat	United Composers from jubeat
+70000180	Valanga	DJ TOTTO
+70000181	見習い天使と星降りの丘	DJ TOTTO
+70000182	Ding Dong Bell	A応P
+70000183	拙者はSAMURAI FOOD	S-C-U a.k.a. Food Samurai × A応P
+70001001	枝に結ぶ願い [2]	Akhuta
+70001002	イ号零型 [2]	あさき
+70001005	炉心融解 [2]	iroha
+70001007	Windy Fairy [2]	DJ TOTTO
+80000003	トキメキメカニクス	ARM × 狐夢想 feat. nomico
+80000007	Blue Sky	Sota F.
+80000008	レゾンデートル、前線より	中島由貴
+80000009	Wandering Gravity	Nazzo-Non-Heat
+80000010	Passion	KAN TAKAHIKO
+80000013	星を飛び越えて	Liz Triangle
+80000014	paranoia	DiGiTAL WiNG feat. 花たん
+80000015	超人ひじりのエアマッソー	IOSYS feat. ビートまりお
+80000016	ガヴリールドロップキック	ガヴリール、ヴィーネ、サターニャ、ラフィエル
+80000017	Morning Glory	(K)NoW_NAME
+80000018	STEP by STEP UP↑↑↑↑	fourfolium
+80000019	JUMPin' JUMP UP!!!!	fourfolium
+80000020	ススメRunner!!	fourfolium
+80000021	パピポペピプペパ	P*Light
+80000022	Wowie Zowie!	Hommarju
+80000023	Midnight City Warfare	sky_delta
+80000024	アドレナリン	U1 overground
+80000025	Jazz is Rad	ARM (IOSYS) + Brasscapsule
+80000026	Welcome!!	kors k
+80000027	みたらしプラトニック (feat. nicamoq)	Yunomi
+80000028	Sulk	SYUNN
+80000029	現世の彼方	猫大樹
+80000030	Claidheamh Soluis-光の剣- feat.はるの	猫大樹
+80000031	シャルル	バルーン
+80000032	ようこそジャパリパークへ	どうぶつビスケッツ×PPP
+80000033	Shadow and Truth	ONE III NOTES
+80000034	Glorious days	GRANRODEO
+80000035	脱法ロック	Neru
+80000036	ユメイロコンパス	fourfolium
+80000037	千本桜	黒うさP
+80000038	CandyPop★Showcase	OSTER project
+80000039	Don't Break Me Down	A-One
+80000040	PF flowing	dj TAKA
+80000041	ミラクル・スイート・スイーツ・マジック！！	日向美ビタースイーツ♪
+80000042	ナイト・オブ・ロンド	日向美ビタースイーツ♪
+80000043	Drizzly Venom	日向美ビタースイーツ♪
+80000044	けもののおうじゃ★めうめう	日向美ビタースイーツ♪
+80000045	銃弾は解を撃ち抜いて	日向美ビタースイーツ♪
+80000046	キリステゴメン	東雲夏陽
+80000047	シノビシノノメ	東雲心菜
+80000048	水槽のクジラ	テヅカ feat. 大西あみみ
+80000049	Fox4-Raise-	Getty vs. DJ DiA
+80000050	Prayer	ぺのれり
+80000051	DREAMING-ING!!	ときめきアイドル project
+80000052	向日葵サンセット	ARM・まろん (IOSYS) × ランコ・パプリカ(豚乙女)
+80000053	EXUSIA	L.E.D.-G
+80000054	Another Phase	TAG
+80000055	In The Ruins	Good-cool feat.CHiCO
+80000056	羽根亡キ少女唄	純情ディスコード
+80000057	虹の先に何があるか	あさき
+80000058	From⑨Girl	uno (IOSYS) × 越田Rute隆人&あき (A-One)
+80000059	君氏危うくも近うよれ	A応P
+80000060	にめんせい☆ウラオモテライフ!	土間うまる (CV.田中あいみ)
+80000061	うまるん体操	妹S
+80000062	変わりゆく時間とノスタルジアと	あずときだしゅんすけ
+80000063	Fly far bounce	猫叉Master
+80000064	Pee-wee Boogie	ARM
+80000065	Evans ～NOSTALGIA Ver. ～	DJ YOSHITAKA Arranged by まらしぃ
+80000066	エレシュキガル	Noah
+80000067	birth	Yu_Asahina
+80000068	If	Pa's Lam System
+80000069	たからもの	セリカ&エリカ
+80000070	STAR SHIP☆HERO	Lucky Vacuum
+80000071	ヤマトなでなで♡かぐや姫	ロマンチック♡Prim姫
+80000072	Shout!!	Qrispy Joybox feat.mao
+80000073	Aerial Skydive	Dirty Androids
+80000074	恋のパズルマジック	ときめきアイドル project Rhythmixxx
+80000075	Strawberry Chu♡Chu♡	ときめきアイドル project クッキーパラダイス
+80000076	Be a Hero!	中島由貴
+80000077	ハルイチバン	ときめきアイドル project
+80000078	闘え！ダダンダーンV	ときめきアイドル project
+80000079	しゃかりきリレーション	ときめきアイドル project 結城秋葉
+80000080	ルミナスデイズ	ここなつ
+80000081	AI	BEMANI Sound Team “Sota F.”
+80000082	Necroxis Girl	"BEMANI Sound Team ""HuΣeR"" "
+80000083	狂髪天を撫でて綴れ雲の綻び　五体北風に散りて痕も無し	"BEMANI Sound Team ""Akhuta Works"" "
+80000084	No One Can Reach The Truth	BEMANI Sound Team “TAG”
+80000085	Never See You Again	BEMANI Sound Team “U1 overground”
+80000086	Diastrophism	かめりあ
+80000087	Roll the Dice	lapix
+80000088	Last Dress	はるなば
+80000089	ヘンゼルとグレーテル	RoughSketch ft.Aikapin & Chiyoko
+80000090	Couleur=Blanche	#FFFFFF
+80000091	ハッピーウェディング前ソング	ヤバイTシャツ屋さん
+80000092	Initial song	40mP
+80000093	リバースユニバース	ナユタン星人
+80000094	快晴	Orangestar
+80000095	フレーフレーわたし	足立佳奈
+80000096	Spring Rouge	izna
+80000097	ロールプレイングゲーム	そらまふうらさか
+80000098	まぼろしウインク	A応P
+80000099	問答無用でＧｏ！！	A応P
+80000101	Everybody's Rich	REMO-CON
+80000102	One More Reason	GUHROOVY
+80000106	Rampage☆Rag	かめりあ
+80000110	Fairy Fair	ぺのれり
+80000112	Northern Wind	Nhato
+80000113	Alive in my Soul	aran
+80000117	Pale Garden	Dirty Androids
+80000118	Singularity	xi
+80000119	飽和世界	猫叉Master
+80000120	セカイがカフェになっちゃった!	Petit Rabbit's with beans
+80000121	脳みそ夫体操メインテーマ	脳みそ夫
+80000122	フィクサー	ぬゆり
+80000123	恋時雨	ときめきアイドル project
+80000124	花のやくそく	日向美ビタースイーツ♪
+80000125	ピースサイン	米津玄師
+80000126	砂の惑星 feat.初音ミク	ハチ
+80000128	ミカヅキ:コネクト	かゆき
+80000129	Chocolate Planet	Freezer feat. 妃苺
+80000130	Spirit of the Beast	ikaruga_nex fw.tcheb
+80000131	Xibercannon	隣の庭は青い(庭師+Aoi)
+80000132	星座が恋した瞬間を。	"BEMANI Sound Team ""DJ TOTTO feat.MarL"" "
+80000133	Puberty Dysthymia	"BEMANI Sound Team ""person09"" "
+80000134	Life is beautiful	"BEMANI Sound Team ""猫叉Master"" "
+80000135	SUPER SUMMER SALE	"BEMANI Sound Team ""U1 overground"" "
+80000136	風鈴花火	"BEMANI Sound Team ""劇団レコード""feat.結良まり "
+80000137	Prey	"BEMANI Sound Team ""Dustup"" "
+80000138	Rejoin	"BEMANI Sound Team ""HuΣeR feat.PON"" "
+80000300	やんややんやNight ～踊ろよ日本～	ゴールデンボンバー
+80000301	やんややんやNight ～踊ろよ※※～	ゴールデンボンバー
+80001001	炉心融解 [ 2 ]	iroha
+80001002	イ号零型 [ 2 ]	あさき
+80001003	SEED [ 2 ]	DJ YOSHITAKA
+80001004	smooooch・∀・ [ 2 ]	kors k
+80001005	Pink Rose [ 2 ]	Kiyommy+Seiya
+80001006	Ausretious#1-まどろみ、或いは嘆色の夢- [ 2 ]	EOOZ
+80001007	HEAVENLY MOON [ 2 ]	Tatsh
+80001008	カラルの月 [ 2 ]	猫叉劇団
+80001009	君の知らない物語 [ 2 ]	
+80001010	白い雪のプリンセスは [ 2 ]	のぼる↑
+80001011	月に叢雲花に風 [ 2 ]	幽閉サテライト feat. senya
+80001013	Scars of FAUNA [ 2 ]	猫叉Master
+80001014	chaplet [ 2 ]	DJ TOTTO
+80001015	アガット [ 2 ]	Bazole
+90000002	インドがパッカーン！！煩悩マハラジャドリーム	ARM × かたほとり ft. 柊木りお
+90000003	ロミとロボの宇宙飛行	onoken
+90000004	Sahara	Hommarju
+90000005	Phantasmagoria	Maozon
+90000006	EMOTiON TRiPPER	sky_delta
diff --git a/dbutils b/dbutils
new file mode 100755
index 0000000..84b3e3f
--- /dev/null
+++ b/dbutils
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.dbutils "$@"
diff --git a/examples/crontab b/examples/crontab
new file mode 100644
index 0000000..fac41ff
--- /dev/null
+++ b/examples/crontab
@@ -0,0 +1,5 @@
+www-data
+*/5 * * * * /path/to/your/root/scheduler --config /path/to/your/root/server.yaml
+
+root
+5 0 * * *            mysqldump -h localhost <database> --extended-insert=FALSE --result-file /path/to/backup/backup_$(date +"\%Y_\%m_\%d").sql
diff --git a/examples/install b/examples/install
new file mode 100755
index 0000000..d10b4d7
--- /dev/null
+++ b/examples/install
@@ -0,0 +1,17 @@
+#! /bin/bash
+# A utility that will install the latest version of the code in the repo
+# to your virtualenv, run any upgrade scripts to update your production
+# MySQL instance and then preload the JSX cache. Effectively, a one-liner
+# to deploying a new version.
+
+set -e
+
+pushd /path/to/git/checkout
+source /path/to/your/virtualenv/bin/activate
+pip install --upgrade pip
+pip install . -U --force-reinstall
+
+./dbutils --config /path/to/your/root/server.yaml upgrade
+deactivate
+popd
+sudo service uwsgi restart && ./preload
diff --git a/examples/nginx/api b/examples/nginx/api
new file mode 100644
index 0000000..58bb633
--- /dev/null
+++ b/examples/nginx/api
@@ -0,0 +1,17 @@
+server {
+    server_name your-domain.com;
+    listen 9573 ssl;
+    server_tokens off;
+
+    gzip on;
+    gzip_types application/json;
+    gzip_min_length 1000;
+
+    ssl_certificate /path/to/certboot/your-domain.com/fullchain.pem;
+    ssl_certificate_key /path/to/certboot/your-domain.com/privkey.pem;
+
+    location / {
+        include uwsgi_params;
+        uwsgi_pass unix:/path/to/your/root/api.sock;
+    }
+}
diff --git a/examples/nginx/frontend.nginx b/examples/nginx/frontend.nginx
new file mode 100644
index 0000000..4e16693
--- /dev/null
+++ b/examples/nginx/frontend.nginx
@@ -0,0 +1,22 @@
+server {
+    server_name your-domain.com;
+    listen 8573 ssl;
+    server_tokens off;
+
+    gzip on;
+    gzip_types text/html text/css text/plain application/javascript application/xml application/json;
+    gzip_min_length 1000;
+
+    ssl_certificate /path/to/certboot/your-domain.com/fullchain.pem;
+    ssl_certificate_key /path/to/certboot/your-domain.com/privkey.pem;
+
+    location / {
+        include uwsgi_params;
+        uwsgi_pass unix:/path/to/your/root/frontend.sock;
+    }
+
+    location ^~ /static/ {
+        include  /etc/nginx/mime.types;
+        root /path/to/your/virtualenv/lib/python3.6/site-packages/bemani/frontend/;
+    }
+}
diff --git a/examples/nginx/proxy b/examples/nginx/proxy
new file mode 100644
index 0000000..cccd513
--- /dev/null
+++ b/examples/nginx/proxy
@@ -0,0 +1,9 @@
+server {
+    listen 80;
+    server_tokens off;
+
+    location / {
+        include uwsgi_params;
+        uwsgi_pass unix:/path/to/your/root/proxy.sock;
+    }
+}
diff --git a/examples/nginx/services.nginx b/examples/nginx/services.nginx
new file mode 100644
index 0000000..036f690
--- /dev/null
+++ b/examples/nginx/services.nginx
@@ -0,0 +1,9 @@
+server {
+    listen 573;
+    server_tokens off;
+
+    location / {
+        include uwsgi_params;
+        uwsgi_pass unix:/path/to/your/root/services.sock;
+    }
+}
diff --git a/examples/preload b/examples/preload
new file mode 100755
index 0000000..aa80d06
--- /dev/null
+++ b/examples/preload
@@ -0,0 +1,13 @@
+#! /bin/bash
+# A utility that hits your web frontend, causing the cache for JSX
+# translations to be rendered. Call this after/during your installation
+# so that the first web request after an installation doesn't need to
+# warm the cache.
+
+cd /path/to/your/virtualenv/lib/python3.6/site-packages/bemani/frontend/static
+for url in $(find -name "*.react.js" | sed 's,^\.,https://your-domain.com/jsx,'); do
+    echo "Priming $url..."
+    curl $url --silent -H 'Cache-Control: no-cache' > /dev/null
+done
+
+echo "Done!"
diff --git a/examples/scheduler b/examples/scheduler
new file mode 100755
index 0000000..63129fc
--- /dev/null
+++ b/examples/scheduler
@@ -0,0 +1,6 @@
+#! /bin/bash
+# Version of the scheduler utility that can be called from a crontab.
+# Place this in the root of your installation to run scheduled events.
+
+source /path/to/your/virtualenv/bin/activate
+python3 -m bemani.utils.scheduler "$@"
diff --git a/examples/uwsgi/api.ini b/examples/uwsgi/api.ini
new file mode 100644
index 0000000..d10a6e6
--- /dev/null
+++ b/examples/uwsgi/api.ini
@@ -0,0 +1,10 @@
+[uwsgi]
+plugins = python3
+socket = /path/to/your/root/api.sock
+processes = 4
+threads = 2
+
+virtualenv = /path/to/your/virtualenv
+chdir = /path/to/your/root
+wsgi-file = api.wsgi
+callable = app
diff --git a/examples/uwsgi/frontend.ini b/examples/uwsgi/frontend.ini
new file mode 100644
index 0000000..8e77d34
--- /dev/null
+++ b/examples/uwsgi/frontend.ini
@@ -0,0 +1,10 @@
+[uwsgi]
+plugins = python3
+socket = /path/to/your/root/frontend.sock
+processes = 4
+threads = 2
+
+virtualenv = /path/to/your/virtualenv
+chdir = /path/to/your/root
+wsgi-file = frontend.wsgi
+callable = app
diff --git a/examples/uwsgi/proxy.ini b/examples/uwsgi/proxy.ini
new file mode 100644
index 0000000..ecc56f9
--- /dev/null
+++ b/examples/uwsgi/proxy.ini
@@ -0,0 +1,10 @@
+[uwsgi]
+plugins = python3
+socket = /path/to/your/root/proxy.sock
+processes = 4
+threads = 2
+
+virtualenv = /path/to/your/virtualenv
+chdir = /path/to/your/root
+wsgi-file = proxy.wsgi
+callable = app
diff --git a/examples/uwsgi/services.ini b/examples/uwsgi/services.ini
new file mode 100644
index 0000000..b5b4281
--- /dev/null
+++ b/examples/uwsgi/services.ini
@@ -0,0 +1,10 @@
+[uwsgi]
+plugins = python3
+socket = /path/to/your/root/services.sock
+processes = 4
+threads = 2
+
+virtualenv = /path/to/your/virtualenv
+chdir = /path/to/your/root
+wsgi-file = services.wsgi
+callable = app
diff --git a/frontend b/frontend
new file mode 100755
index 0000000..0a91423
--- /dev/null
+++ b/frontend
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.frontend "$@"
diff --git a/ifsutils b/ifsutils
new file mode 100755
index 0000000..f47eb41
--- /dev/null
+++ b/ifsutils
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.ifsutils "$@"
diff --git a/iidxutils b/iidxutils
new file mode 100755
index 0000000..a5351ad
--- /dev/null
+++ b/iidxutils
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.iidxutils "$@"
diff --git a/proxy b/proxy
new file mode 100755
index 0000000..3dba2c3
--- /dev/null
+++ b/proxy
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.proxy "$@"
diff --git a/psmap b/psmap
new file mode 100755
index 0000000..ccafd9e
--- /dev/null
+++ b/psmap
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.psmap "$@"
diff --git a/read b/read
new file mode 100755
index 0000000..c5b5a4c
--- /dev/null
+++ b/read
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.read "$@"
diff --git a/replay b/replay
new file mode 100755
index 0000000..ad252f5
--- /dev/null
+++ b/replay
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.replay "$@"
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..778f71f
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,19 @@
+PyYAML
+Flask
+Requests
+mysqlclient
+passlib
+mypy
+flake8==3.5.0
+typed-ast
+SQLAlchemy
+alembic
+freezegun
+pyreact
+Flask-Caching
+blinker
+pycrypto
+jaconv
+pefile
+pillow
+Cython
diff --git a/responsegen b/responsegen
new file mode 100755
index 0000000..dd96d2a
--- /dev/null
+++ b/responsegen
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.responsegen "$@"
diff --git a/scheduler b/scheduler
new file mode 100755
index 0000000..b4401d7
--- /dev/null
+++ b/scheduler
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.scheduler "$@"
diff --git a/services b/services
new file mode 100755
index 0000000..eae92cd
--- /dev/null
+++ b/services
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.services "$@"
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..d8a335e
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,85 @@
+from setuptools import setup
+from Cython.Build import cythonize
+
+setup(
+    name='bemani',
+    version='1.0',
+    description='Code and utilities for talking to BEMANI games',
+    author='DragonMinded',
+    license='Public Domain',
+    packages=[
+        # Core packages
+        'bemani',
+        'bemani.common',
+        'bemani.data',
+        'bemani.data.api',
+        'bemani.data.mysql',
+        'bemani.protocol',
+
+        # Wrapper scripts and WSGI imports
+        'bemani.utils',
+
+        # Frontend packages
+        'bemani.frontend',
+        'bemani.frontend.account',
+        'bemani.frontend.admin',
+        'bemani.frontend.arcade',
+        'bemani.frontend.home',
+        'bemani.frontend.static',
+        'bemani.frontend.templates',
+
+        # Game frontends
+        'bemani.frontend.iidx',
+        'bemani.frontend.popn',
+        'bemani.frontend.jubeat',
+        'bemani.frontend.bishi',
+        'bemani.frontend.ddr',
+        'bemani.frontend.sdvx',
+        'bemani.frontend.reflec',
+        'bemani.frontend.museca',
+
+        # Backend packages
+        'bemani.backend',
+        'bemani.backend.core',
+        'bemani.backend.ess',
+        'bemani.backend.iidx',
+        'bemani.backend.jubeat',
+        'bemani.backend.popn',
+        'bemani.backend.bishi',
+        'bemani.backend.ddr',
+        'bemani.backend.sdvx',
+        'bemani.backend.reflec',
+        'bemani.backend.museca',
+
+        # API packages
+        'bemani.api',
+        'bemani.api.objects',
+
+        # Testing game client packages
+        'bemani.client',
+        'bemani.client.iidx',
+        'bemani.client.jubeat',
+        'bemani.client.popn',
+        'bemani.client.bishi',
+        'bemani.client.ddr',
+        'bemani.client.sdvx',
+        'bemani.client.reflec',
+        'bemani.client.museca',
+    ],
+    install_requires=[
+        req for req in open('requirements.txt').read().split('\n') if len(req) > 0
+    ],
+    ext_modules=cythonize(
+        # Compile various low-level portions of the protocol to get a massive
+        # per-packet speed boost.
+        [
+            "bemani/protocol/binary.py",
+            "bemani/protocol/lz77.py",
+            "bemani/protocol/stream.py",
+            "bemani/protocol/xml.py",
+        ],
+        language_level=3,
+    ),
+    include_package_data=True,
+    zip_safe=False,
+)
diff --git a/shell b/shell
new file mode 100755
index 0000000..9c7d11d
--- /dev/null
+++ b/shell
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3
diff --git a/struct b/struct
new file mode 100755
index 0000000..fdb7574
--- /dev/null
+++ b/struct
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.struct "$@"
diff --git a/trafficgen b/trafficgen
new file mode 100755
index 0000000..b99c4f6
--- /dev/null
+++ b/trafficgen
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m bemani.utils.trafficgen "$@"
diff --git a/verifylibs b/verifylibs
new file mode 100755
index 0000000..83e943e
--- /dev/null
+++ b/verifylibs
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+export PYTHONPATH=$(python -c "import os; print(os.path.realpath('.'))")
+python3 -m unittest discover -s bemani/tests "$@"
diff --git a/verifylint b/verifylint
new file mode 100755
index 0000000..97798a1
--- /dev/null
+++ b/verifylint
@@ -0,0 +1,3 @@
+#! /bin/bash
+
+flake8 bemani/ --ignore E501 | grep -v "migrations\/" | grep -v "__init__.*F401"
diff --git a/verifytraffic b/verifytraffic
new file mode 100755
index 0000000..e884b87
--- /dev/null
+++ b/verifytraffic
@@ -0,0 +1,46 @@
+#! /bin/bash
+
+set -e
+
+declare -a arr=(
+    "pnm-19"
+    "pnm-20"
+    "pnm-21"
+    "pnm-22"
+    "pnm-23"
+    "pnm-24"
+    "iidx-20"
+    "iidx-21"
+    "iidx-22"
+    "iidx-23"
+    "iidx-24"
+    "jubeat-5"
+    "jubeat-5+"
+    "jubeat-6"
+    "jubeat-7"
+    "jubeat-8"
+    "ddr-12"
+    "ddr-13"
+    "ddr-2013"
+    "ddr-2014"
+    "ddr-ace"
+    "bishi"
+    "sdvx-1"
+    "sdvx-2"
+    "sdvx-3s1"
+    "sdvx-3s2"
+    "sdvx-4"
+    "museca-1"
+    "museca-1+1/2"
+    "reflec-1"
+    "reflec-2"
+    "reflec-3"
+    "reflec-4"
+    "reflec-5"
+    "reflec-6"
+)
+
+for project in "${arr[@]}"
+do
+    ./trafficgen --game $project "$@"
+done
diff --git a/verifytyping b/verifytyping
new file mode 100755
index 0000000..6432674
--- /dev/null
+++ b/verifytyping
@@ -0,0 +1,40 @@
+#! /bin/bash
+
+declare -a arr=(
+    "api"
+    "arcutils"
+    "bemanishark"
+    "binutils"
+    "cardconvert"
+    "dbutils"
+    "frontend"
+    "ifsutils"
+    "iidxutils"
+    "proxy"
+    "psmap"
+    "read"
+    "replay"
+    "responsegen"
+    "scheduler"
+    "services"
+    "struct"
+    "trafficgen"
+    "twodxutils"
+)
+
+declare -a cmdline=()
+
+for project in "${arr[@]}"
+do
+    cmdline+=('-m')
+    cmdline+=("bemani.utils.$project")
+done
+
+echo "Verifying type information..."
+MYPYPATH=$(python -c "import os; print(os.path.realpath('.'))") mypy \
+    "${cmdline[@]}" \
+    --warn-redundant-casts \
+    --disallow-untyped-calls \
+    --disallow-untyped-defs \
+    --no-strict-optional
+echo "Done!"