Fix build warning

ruby: improve SDL audio sync on non-stereo devices
Use the application stream format rather than the physical device format. Some outputs, such as HDMI/TV devices with Dolby processing enabled, may expose a multichannel device format even though ares is submitting stereo float audio to SDL. Using the device format for queue sizing and drain timing could make the blocking sync path sleep for the wrong amount of time, causing the emulator to run too slowly. General cleanup: - avoid heap allocation for every audio packet - add proper failure checks - correctly teardown SDL_Audio on shutdown
2026-11-09 09:19:42 -10:00 · 2026-05-28 13:42:30 +01:00 · 2026-05-28 08:47:04 +01:00 · 2026-05-28 08:10:27 +01:00 · 2026-05-25 16:23:20 +01:00 · 2026-05-25 16:16:05 +01:00
6416 changed files with 78890 additions and 774480 deletions
@@ -1,11 +1,8 @@
 # yaml-language-server: $schema=https://raw.githubusercontent.com/BlankSpruce/gersemi/master/gersemi/configuration.schema.json

-color: false
 definitions: [ares/CMakeLists.txt]
 line_length: 120
 indent: 2
 list_expansion: favour-inlining
-quiet: false
 unsafe: false
 warn_about_unknown_commands: false
-workers: 10
@@ -0,0 +1,2 @@
+# When archiving, export a version file containing tag/commit information
+cmake/common/.archive-version.json export-subst
@@ -0,0 +1,31 @@
+# dummy GitHub target used to enable editing of GitHub files within generated IDE projects
+
+add_library(.github INTERFACE)
+
+set(.github_sources
+    ISSUE_TEMPLATE/bug_report.md
+    ISSUE_TEMPLATE/feature_request.md
+    ISSUE_TEMPLATE/game-issue-report.md
+    scripts/build_macos.sh
+    scripts/build_ubuntu.sh
+    scripts/build_windows.sh
+    scripts/package_artifacts.sh
+    workflows/build-aux.yml
+    workflows/build.yml
+    workflows/pr.yml
+    workflows/push.yml
+    workflows/release.yml
+)
+
+target_sources(
+  .github
+  PRIVATE
+  ${.github_sources}
+  ../.gitignore
+  ../.gitattributes
+  ../README.md
+  ../LICENSE
+)
+
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${.github_sources})
+
@@ -10,6 +10,7 @@ pushd build
 # build; pipe output to render warnings neatly
 xcodebuild -configuration RelWithDebInfo \
            DEBUG_INFORMATION_FORMAT="dwarf-with-dsym" \
+            -parallelizeTargets \
            2>&1 | xcbeautify --renderer github-actions

 popd
@@ -13,7 +13,7 @@ cmake --preset $TARGET_PRESET
 pushd build
 cmake --build . --config RelWithDebInfo

-if [ "$CROSS_COMPILE" = true ]; then
+if [ "$CROSS_COMPILE" = true ] || [ "$ARES_PLATFORM_NAME" = "windows-arm64" ]; then
  cp ../.deps/ares-deps-windows-arm64/lib/*.pdb desktop-ui/rundir/
 else
  cp ../.deps/ares-deps-windows-x64/lib/*.pdb desktop-ui/rundir/
@@ -21,13 +21,12 @@ do
  mkdir ${outdir}-dSYMs
  cp -a ${bindir}/ares-${package}-dSYMs/*.dSYM ${outdir}-dSYMs
  cp -a ${bindir}/ares-${package}/*.app ${outdir}
-  zip -r ../ares-${package}.zip ${outdir}
-  zip -r ../ares-${package}-dSYMs.zip ${outdir}-dSYMs
-
+  zip -r -y ../ares-${package}.zip ${outdir}
+  zip -r -y ../ares-${package}-dSYMs.zip ${outdir}-dSYMs
  cd -
 done

-for package in windows-x64 windows-clang-cl-x64 windows-clang-cl-arm64
+for package in windows-x64 windows-clang-cl-arm64
 do
  mkdir "${package}"
  cd "${package}"
@@ -43,3 +42,8 @@ do
  zip -r ../ares-${package}.zip ${outdir}
  cd -
 done
+
+# Package the source archive
+pushd src
+git archive --format=tar.gz -o ../ares-source.tar.gz HEAD
+popd
@@ -0,0 +1,132 @@
+name: Build (Auxiliary)
+on:
+  workflow_call
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        program:
+        - ares
+        config:
+        - RelWithDebInfo
+        platform:
+        - name: windows-x64-gcc
+          os: windows-latest
+          shell: 'msys2 {0}'
+          msystem: mingw64
+          install: make git cmake ccache ninja mingw-w64-x86_64-toolchain
+          target-cmake-preset: windows-ci-mingw-native
+        - name: windows-clang-cl-x64
+          os: windows-latest
+          windres: rc
+          shell: bash
+          target-cmake-preset: windows-ci-cl-native
+        - name: windows-arm64
+          os: windows-11-arm
+          compiler: clang++
+          shell: 'msys2 {0}'
+          msystem: clangarm64
+          install: mingw-w64-clang-aarch64-make git mingw-w64-clang-aarch64-cmake mingw-w64-clang-aarch64-ccache mingw-w64-clang-aarch64-ninja  mingw-w64-clang-aarch64-clang
+          target-cmake-preset: windows-ci-mingw-native
+        - name: windows-msvc-x64
+          os: windows-latest
+          windres: rc
+          shell: bash
+          target-cmake-preset: windows-ci-msvc-native
+        - name: windows-msvc-arm64
+          os: windows-latest
+          windres: rc
+          shell: bash
+          target-cmake-preset: windows-ci-msvc-cross
+          native-cmake-preset: windows-ci-msvc-native
+        - name: ubuntu-gcc-x64
+          os: ubuntu-24.04
+          shell: bash
+          target-cmake-preset: ubuntu-ci
+        - name: ubuntu-gcc-arm64
+          os: ubuntu-24.04-arm
+          shell: bash
+          target-cmake-preset: ubuntu-ci
+        - name: ubuntu-clang-x64
+          os: ubuntu-24.04
+          shell: bash
+          target-cmake-preset: ubuntu-ci-clang
+        - name: ubuntu-clang-arm64
+          os: ubuntu-24.04-arm
+          shell: bash
+          target-cmake-preset: ubuntu-ci-clang
+        - name: ubuntu-gcc-arm64-qt
+          os: ubuntu-24.04-arm
+          shell: bash
+          target-cmake-preset: ubuntu-ci-qt
+        - name: freebsd
+          os: ubuntu-24.04
+          shell: bash
+          target-cmake-preset: ubuntu-ci-clang
+    name: ${{ matrix.program }}-${{ matrix.platform.name }}
+    runs-on: ${{ matrix.platform.os }}
+    defaults:
+      run:
+        shell: ${{ matrix.platform.shell }}
+    steps:
+    - name: Install MSYS2 Dependencies
+      if: matrix.platform.shell == 'msys2 {0}'
+      uses: msys2/setup-msys2@40677d36a502eb2cf0fb808cc9dec31bf6152638
+      with:
+        msystem: ${{ matrix.platform.msystem }}
+        install: ${{ matrix.platform.install }}
+    - name: Checkout source code
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      with:
+        fetch-tags: true
+        fetch-depth: 0
+    - name: Setup MSYS2 Git Environment
+      if: matrix.platform.shell == 'msys2 {0}'
+      run: |
+        git config core.autocrlf true
+    - name: Install Linux Dependencies
+      if: runner.os == 'Linux' && matrix.platform.name != 'freebsd'
+      run: |
+        sudo apt-get update -y -qq
+        sudo apt-get install cmake ccache ninja-build libsdl2-dev libgtk-3-dev libao-dev libopenal-dev qt6-base-dev
+    - name: "Build: Linux"
+      if: runner.os == 'Linux' && matrix.platform.name != 'freebsd'
+      run: .github/scripts/build_ubuntu.sh
+      env:
+        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
+    - name: "Build: Windows"
+      if: runner.os != 'macOS' && runner.os != 'Linux'
+      run: .github/scripts/build_windows.sh
+      env:
+        ARES_PLATFORM_NAME: ${{ matrix.platform.name }}
+        CROSS_COMPILE: ${{ matrix.platform.native-cmake-preset != '' }}
+        NATIVE_PRESET: ${{ matrix.platform.native-cmake-preset }}
+        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
+    - name: "Build: FreeBSD"
+      if: matrix.platform.name == 'freebsd'
+      uses: cross-platform-actions/action@492b0c80085400348c599edace11141a4ee73524
+      env:
+        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
+      with:
+        operating_system: freebsd
+        version: '15.0'
+        environment_variables: TARGET_PRESET
+        run: |
+          sudo pkg install -y cmake pkgconf ccache ninja gtk3 libX11 libXext libXrandr libXrender libglvnd alsa-lib libao libudev-devd librashader openal-soft pulseaudio sdl3 vulkan-loader
+          .github/scripts/build_ubuntu.sh
+    - name: "Compress Build Artifacts (Windows)"
+      if: runner.os != 'macOS' && runner.os != 'Linux'
+      run: |
+        tar -cvJf ares-${{ matrix.platform.name }}.tar.xz -C build/desktop-ui/rundir/ .
+    - name: Upload Build
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+      with:
+        name: ${{ matrix.program }}-${{ matrix.platform.name }}
+        path: ares-${{ matrix.platform.name }}.tar.xz
+    - name: Upload Debug Symbols (Windows)
+      if: runner.os != 'macOS' && runner.os != 'Linux'
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+      with:
+        name: ${{ matrix.program }}-${{ matrix.platform.name }}-PDBs
+        path: build/PDBs/*
@@ -1,10 +1,17 @@
-name: Build
+name: Build (Primary)
 on:
-  push:
-    branches: [ master ]
-    tags: [ 'v*' ]
-  pull_request:
-    branches: [ master ]
+  workflow_call:
+    inputs:
+      codesign:
+        description: Enable codesigning
+        required: false
+        default: false
+        type: boolean
+      official:
+        description: Use official version strings
+        required: true
+        default: true
+        type: boolean
 jobs:
  build:
    strategy:
@@ -12,53 +19,28 @@ jobs:
      matrix:
        program:
        - ares
+        config:
+        - RelWithDebInfo
        platform:
-        - name: windows
+        - name: windows-x64
          os: windows-latest
          compiler: clang++
-          windres: windres
          shell: 'msys2 {0}'
          msystem: clang64
-          install: mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-pkgconf mingw-w64-clang-x86_64-SDL2
-        - name: windows-arm64
+          install: make git cmake ccache ninja mingw-w64-clang-x86_64-clang
+          target-cmake-preset: windows-ci-mingw-native
+        - name: windows-clang-cl-arm64
          os: windows-latest
-          compiler: clang++ --target=aarch64-w64-windows-gnu --sysroot=/clangarm64 -resource-dir=/clangarm64/lib/clang/$(basename "$(clang++ -print-resource-dir)")
-          windres: windres --target=aarch64-w64-windows-gnu
-          shell: 'msys2 {0}'
-          msystem: clang64
-          install: mingw-w64-clang-x86_64-clang mingw-w64-clang-aarch64-clang mingw-w64-clang-aarch64-pkgconf mingw-w64-clang-aarch64-SDL2
-        - name: windows-msvc-x64
-          os: windows-latest
-          compiler: clang++
-          windres: llvm-rc
-          shell: bash
-          msvc-arch: x64
-        - name: windows-msvc-arm64
-          os: windows-latest
-          compiler: clang++ --target=aarch64-w64-windows-msvc
-          windres: llvm-rc
-          shell: bash
-          msvc-arch: x64_arm64
-        - name: windows-cl-x64
-          os: windows-latest
-          compiler: cl
          windres: rc
          shell: bash
-          msvc-arch: x64
-        - name: windows-cl-arm64
-          os: windows-latest
-          compiler: cl
-          windres: rc
-          shell: bash
-          msvc-arch: x64_arm64
+          target-cmake-preset: windows-ci-cl-cross
+          native-cmake-preset: windows-ci-cl-native
        - name: macos-universal
          os: macos-15
          compiler: clang++
          shell: sh
-        - name: ubuntu
-          os: ubuntu-latest
-          compiler: g++
-          shell: sh
+          install: cmake ccache xcbeautify
+          target-cmake-preset: macos-ci-universal
    name: ${{ matrix.program }}-${{ matrix.platform.name }}
    runs-on: ${{ matrix.platform.os }}
    defaults:
@@ -67,250 +49,86 @@ jobs:
    steps:
    - name: Install MSYS2 Dependencies
      if: matrix.platform.shell == 'msys2 {0}'
-      uses: msys2/setup-msys2@v2
+      uses: msys2/setup-msys2@40677d36a502eb2cf0fb808cc9dec31bf6152638
      with:
        msystem: ${{ matrix.platform.msystem }}
-        install: make ${{ matrix.platform.install }}
+        install: ${{ matrix.platform.install }}
+    - name: "macOS: Import Certificate"
+      if: runner.os == 'macOS' && inputs.codesign
+      uses: apple-actions/import-codesign-certs@65cfbc37e1464d733524cb555b724878f278b8c3
+      continue-on-error: ${{ secrets.MACOS_CERTIFICATE_NAME == '' }}
+      with:
+        p12-file-base64: ${{ secrets.MACOS_CERTIFICATE_DATA }}
+        p12-password: ${{ secrets.MACOS_CERTIFICATE_PASSPHRASE }}
+    - name: Checkout source code
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      with:
+        fetch-tags: true
+        fetch-depth: 0
+    - name: Setup MSYS2 Git Environment
+      if: matrix.platform.shell == 'msys2 {0}'
+      run: |
+        git config core.autocrlf true
    - name: Install Linux Dependencies
      if: runner.os == 'Linux'
      run: |
        sudo apt-get update -y -qq
-        sudo apt-get install libsdl2-dev libgtk-3-dev libao-dev libopenal-dev
-    - name: "macOS: Import Certificate"
-      if: runner.os == 'macOS' && github.event_name != 'pull_request'
-      continue-on-error: ${{ github.repository != 'ares-emulator/ares' }}
-      uses: wpilibsuite/import-signing-certificate@2ac4f44d28045073d23153256efbb4c4b2d8aa22    # Don't use rolling branch for security reasons
-      with:
-        certificate-data: ${{ secrets.MACOS_CERTIFICATE_DATA }}
-        certificate-passphrase: ${{ secrets.MACOS_CERTIFICATE_PASSPHRASE }}
-        keychain-name: ares-macos-keychain
-        keychain-password: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
-    - name: Checkout source code
-      uses: actions/checkout@v4
-    - name: Install Windows Dependencies
-      if: runner.os == 'Windows'
-      run: |
-        export PATH="/c/Users/runneradmin/.cargo/bin:$PATH" # correct on windows-latest as of 2024-02-19 
-        if [[ ${{ matrix.platform.name }} == *-arm64 ]]; then
-          rustup toolchain install nightly
-          rustup default nightly
-          rustup target add aarch64-pc-windows-msvc        
-          pushd thirdparty/librashader
-          ./build-librashader.sh aarch64-pc-windows-msvc
-          popd        
-        else
-          rustup toolchain install nightly
-          rustup default nightly
-          pushd thirdparty/librashader
-          ./build-librashader.sh
-          popd
-        fi
-    - name: "macOS: recover MoltenVK cache"
-      if: runner.os == 'macOS'
-      uses: actions/cache@v4
-      env:
-          cache-name: moltenvk
-      with:
-          path: thirdparty/MoltenVK/MoltenVK
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('thirdparty/MoltenVK/HEAD') }}
+        sudo apt-get install ${{ matrix.platform.install }}
    - name: Install macOS Dependencies
      if: runner.os == 'macOS'
      run: |
-        sudo xcode-select -s /Applications/Xcode_16.1.0.app/Contents/Developer
-        export MACOSX_DEPLOYMENT_TARGET=10.13
-        brew install ninja cmake
-        pip install --no-input setuptools
-        rustup toolchain install nightly
-        rustup default nightly
-        rustup target add x86_64-apple-darwin
-        rustup target add aarch64-apple-darwin
-        pushd thirdparty/SDL
-        ./build-SDL.sh
-        popd
-        pushd thirdparty/MoltenVK
-        ./build-moltenvk.sh
-        popd
-        export MACOSX_DEPLOYMENT_TARGET=10.15
-        pushd thirdparty/librashader
-        ./build-librashader.sh
-        popd
-    - name: Set up MSVC environment
-      if: matrix.platform.msvc-arch != ''
-      uses: ilammy/msvc-dev-cmd@v1
-      with:
-        arch: ${{ matrix.platform.msvc-arch }}
-    - name: Make
-      if: runner.os != 'macOS'
-      run: ${MAKE:-make} -j4 -C desktop-ui build=optimized local=false compiler="${{ matrix.platform.compiler }}" windres="${{ matrix.platform.windres }}"
-    - name: "macOS: Make universal app"
-      if: runner.os == 'macOS'
-      run: scripts/macos-make-universal.sh build=optimized local=false
+        brew uninstall --ignore-dependencies cmake
+        brew install ${{ matrix.platform.install }}
+    - name: "Build: Windows"
+      if: runner.os != 'macOS' && runner.os != 'Linux'
+      run: .github/scripts/build_windows.sh
      env:
-        MAKEFLAGS: -j3
-        MACOS_CERTIFICATE_NAME: ${{ secrets.MACOS_CERTIFICATE_NAME }}
-        MACOS_KEYCHAIN_NAME: ares-macos-keychain
-        MACOS_KEYCHAIN_PASSWORD: ${{ secrets.MACOS_KEYCHAIN_PASSWORD }}
+        ARES_BUILD_OFFICIAL: ${{ inputs.official }}
+        ARES_PLATFORM_NAME: ${{ matrix.platform.name }}
+        CROSS_COMPILE: ${{ matrix.platform.native-cmake-preset != '' }}
+        NATIVE_PRESET: ${{ matrix.platform.native-cmake-preset }}
+        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
    - name: "Windows: sign"
-      if: runner.os == 'Windows' && github.event_name != 'pull_request'
+      if: runner.os == 'Windows' && inputs.codesign
+      continue-on-error: true
      uses: DanaBear/code-sign-action@98c79121b376beab8d6a9484f445089db4461bca
      with:
        certificate: '${{ secrets.WIN_CERTIFICATE }}'
        password: '${{ secrets.WIN_PASSWORD }}'
        certificatesha1: '${{ secrets.WIN_CERTHASH }}'
        certificatename: '${{ secrets.WIN_CERTNAME }}'
-        folder: 'desktop-ui/out'
+        folder: 'build/desktop-ui/rundir/'
        timestampUrl: 'http://timestamp.digicert.com'
-    - name: "macOS: notarize"
-      if: false
-      continue-on-error: ${{ github.repository != 'ares-emulator/ares' }}
-      run: |
-        ditto -c -k --keepParent desktop-ui/out/ares.app /tmp/ares.zip
-        xcrun notarytool submit /tmp/ares.zip --apple-id "$MACOS_NOTARIZATION_USERNAME" --password "$MACOS_NOTARIZATION_PASSWORD" --team-id "$MACOS_NOTARIZATION_TEAMID" --wait
-        xcrun stapler staple desktop-ui/out/ares.app
+    - name: "Build: macOS"
+      if: runner.os == 'macOS'
+      run: .github/scripts/build_macos.sh
      env:
-        MACOS_NOTARIZATION_USERNAME: ${{ secrets.MACOS_NOTARIZATION_USERNAME }}
-        MACOS_NOTARIZATION_PASSWORD: ${{ secrets.MACOS_NOTARIZATION_PASSWORD }}
+        ARES_BUILD_OFFICIAL: ${{ inputs.official }}
+        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
+        MACOS_CERTIFICATE_NAME: ${{ secrets.MACOS_CERTIFICATE_NAME }}
        MACOS_NOTARIZATION_TEAMID: ${{ secrets.MACOS_NOTARIZATION_TEAMID }}
-    - name: Upload
-      uses: actions/upload-artifact@v4
+    - name: "Compress Build Artifact (macOS)"
+      if: runner.os == 'macOS'
+      run: |
+        tar -cvJf ares-${{ matrix.platform.name }}.tar.xz -C build/desktop-ui/RelWithDebInfo/ .
+    - name: "Compress Build Artifacts (Windows)"
+      if: runner.os != 'macOS' && runner.os != 'Linux'
+      run: |
+        tar -cvJf ares-${{ matrix.platform.name }}.tar.xz -C build/desktop-ui/rundir/ .
+    - name: Upload Build
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
      with:
        name: ${{ matrix.program }}-${{ matrix.platform.name }}
-        path: desktop-ui/out/*
-
-     
-  release:
-    if: false
-    runs-on: ubuntu-latest
-    needs:
-    - build
-    steps:
-    - uses: actions/checkout@v4
+        path: ares-${{ matrix.platform.name }}.tar.xz
+    - name: Upload Debug Symbols (Windows)
+      if: runner.os != 'macOS' && runner.os != 'Linux'
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
      with:
-        path: 'src'
-    - name: Download Artifacts
-      uses: actions/download-artifact@v4
+        name: ${{ matrix.program }}-${{ matrix.platform.name }}-PDBs
+        path: build/PDBs/*
+    - name: Upload Debug Symbols (macOS)
+      if: runner.os == 'macOS'
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
      with:
-        path: 'bin'
-    - name: Package Artifacts
-      run: |
-        set -eu
-        case ${GITHUB_REF} in
-          refs/tags/*) suffix="-${GITHUB_REF#refs/tags/}" ;;
-          refs/heads/master) suffix="-nightly" ;;
-          *) suffix="" ;;
-        esac
-
-        srcdir="${GITHUB_WORKSPACE}/src"
-        bindir="${GITHUB_WORKSPACE}/bin"
-
-        # Hack: Workaround for GitHub artifacts losing attributes.
-        chmod +x ${bindir}/ares-macos-universal/ares.app/Contents/MacOS/ares
-
-        for package in windows windows-msvc-arm64 macos-universal
-        do
-          mkdir "${package}"
-          cd "${package}"
-
-          # Package ares.
-          outdir=ares${suffix}
-          mkdir ${outdir}
-          cp -ar ${bindir}/ares-${package}/* ${outdir}
-          zip -r ../ares-${package}.zip ${outdir}
-
-          cd -
-        done
-    - name: Create Release
-      id: release
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        set -eu
-        github_rest()
-        {
-          local method="${1}"
-          local url="https://api.github.com${2}"
-          shift 2
-          >&2 echo "${method} ${url}"
-          curl \
-            --fail \
-            -H "Accept: application/vnd.github.v3+json" \
-            -H "Authorization: token ${GITHUB_TOKEN}" \
-            -X "${method}" \
-            "${url}" \
-            "$@"
-        }
-        github_get_release_id_for_tag()
-        {
-          payload=$(github_rest GET "/repos/${GITHUB_REPOSITORY}/releases/tags/${1}") || return
-          echo "${payload}" | jq .id
-        }
-        github_delete_release_by_id()
-        {
-          github_rest DELETE "/repos/${GITHUB_REPOSITORY}/releases/${1}"
-        }
-        github_create_release()
-        {
-          local payload="{
-            \"tag_name\": \"${1}\",
-            \"target_commitish\": \"${2}\",
-            \"name\": \"${3}\",
-            \"body\": \"${4}\",
-            \"draft\": ${5},
-            \"prerelease\": ${6}
-          }"
-          github_rest POST "/repos/${GITHUB_REPOSITORY}/releases" -d "${payload}"
-        }
-        make_nightly_release()
-        {
-          github_create_release \
-            nightly \
-            "${GITHUB_SHA}" \
-            "ares nightly $(date +"%Y-%m-%d")" \
-            "Auto-generated nightly release on $(date -u +"%Y-%m-%d %T %Z")" \
-            false \
-            true
-        }
-        make_version_release()
-        {
-          github_create_release \
-            "${1}" \
-            "${GITHUB_SHA}" \
-            "ares ${1}" \
-            "This is ares ${1}, released on $(date +"%Y-%m-%d")." \
-            false \
-            false
-        }
-        case ${GITHUB_REF} in
-          refs/tags/*)
-            # Create a new version release using the current revision.
-            echo "UPLOAD_URL=$(make_version_release ${GITHUB_REF#refs/tags/} | jq -r .upload_url)" >> $GITHUB_ENV
-            ;;
-          refs/heads/master)
-            # Check for an existing nightly release.
-            { release_id=$(github_get_release_id_for_tag nightly); status=$?; } || true
-            # Delete existing nightly release if it exists.
-            case ${status} in
-              0) github_delete_release_by_id "${release_id}" ;;
-              22) >&2 echo "No current nightly release; skipping tag deletion." ;;
-              *) >&2 echo "API call failed unexpectedly." && exit 1 ;;
-            esac
-            # Create a new nightly release using the current revision.
-            echo "UPLOAD_URL=$(make_nightly_release | jq -r .upload_url)" >> $GITHUB_ENV
-            ;;
-        esac
-    - name: Upload ares-windows
-      uses: actions/upload-release-asset@v1
-      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-windows.zip', asset_name: 'ares-windows.zip', asset_content_type: 'application/zip' }
-    - name: Upload ares-windows-msvc-arm64
-      uses: actions/upload-release-asset@v1
-      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-windows-msvc-arm64.zip', asset_name: 'ares-windows-msvc-arm64.zip', asset_content_type: 'application/zip' }
-    - name: Upload ares-macos-universal
-      uses: actions/upload-release-asset@v1
-      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-macos-universal.zip', asset_name: 'ares-macos-universal.zip', asset_content_type: 'application/zip' }
-#  - name: Upload ares-ubuntu
-#      uses: actions/upload-release-asset@v1
-#      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-#      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-ubuntu.zip', asset_name: 'ares-ubuntu.zip', asset_content_type: 'application/zip' }
+        name: ${{ matrix.program }}-${{ matrix.platform.name }}-dSYMs
+        path: build/dSYMs/*
@@ -1,153 +0,0 @@
-name: Build (New)
-on:
-  workflow_call:
-    inputs:
-      codesign:
-        description: Enable codesigning
-        required: false
-        default: false
-        type: boolean
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        program:
-        - ares
-        config:
-        - RelWithDebInfo
-        platform:
-        - name: windows-x64
-          os: windows-latest
-          compiler: clang++
-          shell: 'msys2 {0}'
-          msystem: clang64
-          install: mingw-w64-clang-x86_64-clang
-          target-cmake-preset: windows-ci-mingw-native
-        - name: windows-x64-gcc
-          os: windows-latest
-          compiler: g++
-          shell: 'msys2 {0}'
-          msystem: mingw64
-          install: mingw-w64-x86_64-toolchain
-          target-cmake-preset: windows-ci-mingw-native
-        - name: windows-clang-cl-x64
-          os: windows-latest
-          windres: rc
-          shell: bash
-          target-cmake-preset: windows-ci-cl-native
-        - name: windows-clang-cl-arm64
-          os: windows-latest
-          windres: rc
-          shell: bash
-          target-cmake-preset: windows-ci-cl-cross
-          native-cmake-preset: windows-ci-cl-native
-        - name: windows-msvc-x64
-          os: windows-latest
-          windres: rc
-          shell: bash
-          target-cmake-preset: windows-ci-msvc-native
-        - name: windows-msvc-arm64
-          os: windows-latest
-          windres: rc
-          shell: bash
-          target-cmake-preset: windows-ci-msvc-cross
-          native-cmake-preset: windows-ci-msvc-native
-        - name: macos-universal
-          os: macos-15
-          compiler: clang++
-          shell: sh
-          install: cmake ccache xcbeautify
-          target-cmake-preset: macos-ci-universal
-        - name: ubuntu
-          os: ubuntu-latest
-          compiler: g++
-          shell: bash
-          install: cmake ccache ninja-build libsdl2-dev libgtk-3-dev libao-dev libopenal-dev
-          target-cmake-preset: ubuntu-ci
-    name: ${{ matrix.program }}-${{ matrix.platform.name }}
-    runs-on: ${{ matrix.platform.os }}
-    defaults:
-      run:
-        shell: ${{ matrix.platform.shell }}
-    steps:
-    - name: Install MSYS2 Dependencies
-      if: matrix.platform.shell == 'msys2 {0}'
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.platform.msystem }}
-        install: make git cmake ccache ninja ${{ matrix.platform.install }}
-    - name: "macOS: Import Certificate"
-      if: runner.os == 'macOS' && inputs.codesign
-      uses: apple-actions/import-codesign-certs@v3
-      continue-on-error: ${{ !inputs.codesign }}
-      with:
-        p12-file-base64: ${{ secrets.MACOS_CERTIFICATE_DATA }}
-        p12-password: ${{ secrets.MACOS_CERTIFICATE_PASSPHRASE }}
-    - name: Checkout source code
-      uses: actions/checkout@v4
-      with:
-        fetch-tags: true
-        fetch-depth: 0
-    - name: Install Linux Dependencies
-      if: runner.os == 'Linux'
-      run: |
-        sudo apt-get update -y -qq
-        sudo apt-get install ${{ matrix.platform.install }}
-    - name: Install macOS Dependencies
-      if: runner.os == 'macOS'
-      run: |
-        brew install ${{ matrix.platform.install }}
-    - name: "Build: Linux"
-      if: runner.os == 'Linux'
-      run: .github/scripts/build_ubuntu.sh
-      env:
-        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
-    - name: "Build: Windows"
-      if: runner.os != 'macOS' && runner.os != 'Linux'
-      run: .github/scripts/build_windows.sh
-      env:
-        CROSS_COMPILE: ${{ matrix.platform.native-cmake-preset != '' }}
-        NATIVE_PRESET: ${{ matrix.platform.native-cmake-preset }}
-        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
-    - name: "Windows: sign"
-      if: runner.os == 'Windows' && inputs.codesign
-      uses: DanaBear/code-sign-action@98c79121b376beab8d6a9484f445089db4461bca
-      with:
-        certificate: '${{ secrets.WIN_CERTIFICATE }}'
-        password: '${{ secrets.WIN_PASSWORD }}'
-        certificatesha1: '${{ secrets.WIN_CERTHASH }}'
-        certificatename: '${{ secrets.WIN_CERTNAME }}'
-        folder: 'build/desktop-ui/rundir/'
-        timestampUrl: 'http://timestamp.digicert.com'
-    - name: "Build: macOS"
-      if: runner.os == 'macOS'
-      run: .github/scripts/build_macos.sh
-      env:
-        TARGET_PRESET: ${{ matrix.platform.target-cmake-preset }}
-        MACOS_CERTIFICATE_NAME: ${{ secrets.MACOS_CERTIFICATE_NAME }}
-        MACOS_NOTARIZATION_TEAMID: ${{ secrets.MACOS_NOTARIZATION_TEAMID }}
-    - name: Upload Build (Windows)
-      if: runner.os != 'macOS' && runner.os != 'Linux'
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.program }}-${{ matrix.platform.name }}
-        path: build/desktop-ui/rundir/*
-    - name: Upload Build (macOS)
-      if: runner.os == 'macOS'
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.program }}-${{ matrix.platform.name }}
-        path: build/desktop-ui/RelWithDebInfo/
-    - name: Upload Debug Symbols (Windows)
-      if: runner.os != 'macOS' && runner.os != 'Linux'
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.program }}-${{ matrix.platform.name }}-PDBs
-        path: build/PDBs/*
-    - name: Upload Debug Symbols (macOS)
-      if: runner.os == 'macOS'
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.program }}-${{ matrix.platform.name }}-dSYMs
-        path: build/dSYMs/*
@@ -11,7 +11,13 @@ concurrency:
  cancel-in-progress: true
 jobs:
  build-project:
-    name: Build
-    uses: ./.github/workflows/build_new.yml
+    name: Build ares (primary)
+    uses: ./.github/workflows/build.yml
    permissions:
      contents: read
+    with:
+      official: false
+  build-aux:
+    name: Build ares (auxiliary)
+    uses: ./.github/workflows/build-aux.yml
+    secrets: inherit
@@ -1,8 +1,6 @@
 name: Push
 on:
-  push:
-    branches: [ '*' ]
-    tags: [ 'v*' ]
+  push
 concurrency:
  group: '${{ github.workflow }} @ ${{ github.head_ref || github.ref }}'
  cancel-in-progress: true
@@ -10,11 +8,16 @@ permissions:
  contents: write
 jobs:
  build:
-    name: Build ares
-    uses: ./.github/workflows/build_new.yml
+    name: Build ares (primary)
+    uses: ./.github/workflows/build.yml
    secrets: inherit
    with:
      codesign: true
+      official: ${{ github.ref_name == 'master' || github.ref_type == 'tag' }}
+  build-aux:
+    name: Build ares (auxiliary)
+    uses: ./.github/workflows/build-aux.yml
+    secrets: inherit
  release:
    name: Release
    needs: build
@@ -12,13 +12,22 @@ jobs:
    if: github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/')
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
      with:
        path: 'src'
    - name: Download Artifacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
      with:
        path: 'bin'
+    - name: "Decompress Build Artifacts"
+      if: runner.os == 'macOS'
+      run: |
+        for package in macos-universal windows-x64 windows-clang-cl-arm64; do
+          pushd bin/ares-${package}
+          tar -xJf ares-${package}.tar.xz
+          rm -f ares-${package}.tar.xz
+          popd
+        done
    - name: "macOS: notarize"
      if: inputs.notarize
      run: |
@@ -48,21 +57,26 @@ jobs:
            description="This is ares ${GITHUB_REF_NAME}, released on ${now}."
            echo "description=${description}" >> $GITHUB_OUTPUT
          fi
-          
+    - name: Update Git Tag
+      if: steps.check.outputs.tag == 'nightly'
+      id: update-tag
+      run: |
+          git -C src tag -f ${{ steps.check.outputs.tag }}
+          git -C src push -f origin ${{ steps.check.outputs.tag }}
+
    - name: Create Release 🛫
      id: create_release
      uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191
      with:
-        draft: ${{ github.ref != 'refs/heads/master' }}
+        prerelease: ${{ steps.check.outputs.tag == 'nightly' }}
        tag_name: ${{ steps.check.outputs.tag }}
        name: ares ${{ steps.check.outputs.versionName }}
        body: ${{ steps.check.outputs.description }}
        files: |
+          ${{ github.workspace }}/ares-source.tar.gz
          ${{ github.workspace }}/ares-macos-universal.zip
          ${{ github.workspace }}/ares-macos-universal-dSYMs.zip
          ${{ github.workspace }}/ares-windows-x64.zip
          ${{ github.workspace }}/ares-windows-x64-PDBs.zip
-          ${{ github.workspace }}/ares-windows-clang-cl-x64.zip
-          ${{ github.workspace }}/ares-windows-clang-cl-x64-PDBs.zip
          ${{ github.workspace }}/ares-windows-clang-cl-arm64.zip
          ${{ github.workspace }}/ares-windows-clang-cl-arm64-PDBs.zip
@@ -26,10 +26,10 @@
 !CMakeLists.txt
 !CMakePresets.json

-thirdparty/SDL/SDL
-thirdparty/SDL/libSDL2-2.0.0.dylib
-desktop-ui/out
-desktop-ui/obj
+# Exclude old macOS Finder metadata
+.DS_Store
+
+# Exclude generated sources that still reside in-tree
 ruby/video/metal/shaders.metallib
 ruby/video/metal/shaders.ir
 ares/ares/resource/resource.cpp
@@ -38,5 +38,16 @@ hiro/resource/resource.cpp
 hiro/resource/resource.hpp
 desktop-ui/resource/resource.cpp
 desktop-ui/resource/resource.hpp
+mia/resource/resource.cpp
+mia/resource/resource.hpp
+
+# Exclude Qt generated MOC file
+hiro/qt/qt.moc
+
+# Exclude fetched third-party processor test binaries
 tests/arm7tdmi/tests
 tests/m68000/tests
+
+# Exclude unused legacy zlib header that is renamed by CMake
+thirdparty/libchdr/deps/zlib-*/zconf.h
+thirdparty/libchdr/deps/zlib-*/zconf.h.included
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.28...3.30)
+cmake_minimum_required(VERSION 3.28...4.1)

 include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/common/bootstrap.cmake" NO_POLICY_SCOPE)

@@ -8,11 +8,9 @@ include(compilerconfig)
 include(defaults)
 include(helpers)

-add_subdirectory(cmake)
-
 add_subdirectory(thirdparty)

-add_subdirectory(nall)
+add_subdirectory(nall/nall)
 add_subdirectory(libco)
 add_subdirectory(ruby)
 add_subdirectory(hiro)
@@ -21,7 +19,7 @@ add_subdirectory(hiro)
 set(
  ARES_CORES
  a26 fc sfc sg ms md ps1 pce ng msx cv myvision gb gba ws ngp spec n64
-  CACHE STRING LIST
+  CACHE STRING "List of systems to be built by the project"
 )
 # gersemi: on

@@ -35,7 +33,7 @@ if(ARES_BUILD_OPTIONAL_TARGETS)
  add_subdirectory(tests/arm7tdmi)
  add_subdirectory(tests/i8080)
  add_subdirectory(tests/m68000)
-  if(NOT OS_WINDOWS AND NOT OS_MACOS)
+  if(HIRO_BACKEND STREQUAL "GTK3")
    add_subdirectory(tools/genius)
  else()
    target_disable_subproject(genius "genius (database editor)")
@@ -52,4 +50,7 @@ endif()
 add_subdirectory(tools/sourcery)

 message_configuration()
+
+add_subdirectory(.github)
+add_subdirectory(cmake)
 return()
@@ -12,7 +12,8 @@
      "cacheVariables": {
        "ARES_PROFILE_ACCURACY": false,
        "ARES_BUILD_LOCAL": true,
-        "ENABLE_CCACHE": true
+        "ENABLE_CCACHE": true,
+        "ARES_BUILD_OFFICIAL": {"type": "BOOL", "value": "$penv{ARES_BUILD_OFFICIAL}"}
      }
    },
    {
@@ -81,7 +82,7 @@
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_OSX_ARCHITECTURES": {"type": "STRING", "value": "x86_64;arm64"},
-        "CMAKE_OSX_DEPLOYMENT_TARGET": {"type": "STRING", "value": "10.13"},
+        "CMAKE_OSX_DEPLOYMENT_TARGET": {"type": "STRING", "value": "11.0"},
        "ARES_CODESIGN_IDENTITY": {"type": "STRING", "value": "$penv{MACOS_CERTIFICATE_NAME}"},
        "ARES_CODESIGN_TEAM": {"type": "STRING", "value": "$penv{MACOS_NOTARIZATION_TEAMID}"},
        "ENABLE_CCACHE": true,
@@ -101,7 +102,9 @@
        "ARES_BUILD_LOCAL": false,
        "ARES_BUILD_OPTIONAL_TARGETS": true,
        "ARES_UNITY_CORES": true,
-        "ARES_PRECOMPILE_HEADERS": true
+        "ARES_PRECOMPILE_HEADERS": true,
+        "CMAKE_MSVC_RUNTIME_LIBRARY": {"type": "STRING", "value": "MultiThreaded"},
+        "CMAKE_IGNORE_PATH": {"type": "STRING", "value": "C:/Strawberry/c/bin/"}
      }
    },
    {
@@ -158,10 +161,31 @@
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": {"type": "STRING", "value": "RelWithDebInfo"},
        "ENABLE_CCACHE": true,
+        "ENABLE_IPO": false,
        "ARES_BUILD_LOCAL": false,
        "ARES_BUILD_OPTIONAL_TARGETS": true,
        "ARES_PRECOMPILE_HEADERS": false
      }
+    },
+    {
+      "name": "ubuntu-ci-clang",
+      "displayName": "Ubuntu CI (clang)",
+      "description": "Single-arch binary for building on Github Actions",
+      "inherits": ["ubuntu-ci"],
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "clang",
+        "CMAKE_CXX_COMPILER": "clang++"
+      }
+    },
+    {
+      "name": "ubuntu-ci-qt",
+      "displayName": "Ubuntu CI (arm64, gcc, Qt)",
+      "description": "Single-arch binary for building on Github Actions",
+      "inherits": ["ubuntu-ci"],
+      "cacheVariables": {
+        "USE_QT6": true,
+        "ARES_BUILD_OPTIONAL_TARGETS": false
+      }
    }
  ],
  "buildPresets": [
@@ -1,6 +0,0 @@
-targets = all clean install uninstall verbose
-
-$(targets):
-	@$(MAKE) -C desktop-ui $@
-
-.PHONY: $(targets)
@@ -1,7 +1,7 @@
 ----------------------------------------------------------------------
 ares

-Copyright (c) 2004-2024 ares team, Near et al
+Copyright (c) 2004-2025 ares team, Near et al

 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
@@ -828,4 +828,32 @@ You may add additional accurate notices of copyright ownership.
    This Source Code Form is "Incompatible With Secondary Licenses", as
    defined by the Mozilla Public License, v. 2.0.

----------------------------------------------------------------------
+----------------------------------------------------------------------
+
+----------------------------------------------------------------------
+qoi/qon
+
+Copyright (c) 2025, Roger Sanders
+Revised QOI format, achieving higher compression with equivalent performance.
+
+Based on the "Quite OK Image" format for fast, lossless image compression
+Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+----------------------------------------------------------------------
@@ -5,6 +5,8 @@
 **ares** is a multi-system emulator that began development on October 14th, 2004.
 It is a descendant of [higan](https://github.com/higan-emu/higan) and [bsnes](https://github.com/bsnes-emu/bsnes/), and focuses on accuracy and preservation.

+It's worth noting that ares takes some uncommon design approaches that essentially trade speed for code clarity. We avoid state machines and bitmasks (when possible). Most cores end up being half the amount of code, but slower. The code is clearer and less spaghettified, especially for systems with lots of processors. C bitfields being non-portable incurs a speedhit. Windows also has a speedhit over Linux due to its ABI needing more instructions to switch contexts.
+
 Official Releases
 -----------------

@@ -14,21 +16,19 @@ Official releases are available from
 Nightly Builds
 --------------

-Automated, untested builds of ares are available for Windows and macOS as a [pre-release](https://github.com/higan-emu/ares/releases/tag/nightly). 
+Automated, untested builds of ares are available for Windows and macOS as a [pre-release](https://github.com/ares-emulator/ares/releases/tag/nightly). 
 Only the latest nightly build is kept.

 Building ares
 -------------

-Build instructions are available on the ares wiki. See build instructions for:
+ares supports building on Windows, macOS, and various Linux/BSD distributions. See build instructions for:

 * [Windows](https://github.com/ares-emulator/ares/wiki/Build-Instructions-For-Windows)
 * [macOS](https://github.com/ares-emulator/ares/wiki/Build-Instructions-For-macOS)
 * [Linux](https://github.com/ares-emulator/ares/wiki/Build-Instructions-For-Linux)
 * [BSD](https://github.com/ares-emulator/ares/wiki/Build-Instructions-For-BSD)

-For legacy Makefile build instructions, see [here](https://github.com/ares-emulator/ares/wiki/Legacy-Build-Instructions).
-
 Command-line options
 --------------------

@@ -38,12 +38,18 @@ When started from the command-line, ares accepts a few options.
 Usage: ./ares [options] game(s)

  --help                 Displays available options and exit
+  --version              Displays the version string of the application
+  --terminal             Create new terminal window (Windows only)
  --fullscreen           Start in full screen mode
+  --pseudofullscreen     Start in pseudo full screen mode
+  --kiosk                Start in minimal UI mode (implies --no-file-prompt)
  --system system        Specify the system name
-  --shader shader        Specify GLSL shader name to load (requires OpenGL driver)
+  --shader shader        Specify a slang shader to load (requires OpenGL or Metal)
  --setting name=value   Specify a value for a setting
  --dump-all-settings    Show a list of all existing settings and exit
  --no-file-prompt       Do not prompt to load (optional) additional roms (eg: 64DD)
+  --settings-file path   Specify a settings file override (settings.bml)
+  --save-state slot      Specify a save state slot to load (1-9)
 ```

 The --system option is useful when the system type cannot be auto-detected.
@@ -1,5 +1,7 @@
 add_library(ares STATIC ares/ares.cpp ares/memory/fixed-allocator.cpp)

+configure_file(ares/ares.cpp.in ares/ares.cpp @ONLY)
+
 add_library(ares::ares ALIAS ares)

 option(ARES_PROFILE_ACCURACY "Build to prefer emulation accuracy over performance in certain specific areas" OFF)
@@ -19,7 +21,7 @@ if(ARES_PRECOMPILE_HEADERS)
  target_precompile_headers(ares PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:ares/ares.hpp>")
 endif()

-target_link_libraries(ares PUBLIC libco sljit nall)
+target_link_libraries(ares PRIVATE libco ares::nall::headers $<$<BOOL:${ARES_ENABLE_CHD}>:chdr-static> PUBLIC sljit)

 if(ARES_PROFILE_ACCURACY)
  target_compile_definitions(ares PUBLIC PROFILE_ACCURACY)
@@ -29,7 +31,7 @@ endif()

 target_sources(
  ares
-  PRIVATE ares/ares.cpp ares/ares.hpp ares/inline.hpp ares/platform.hpp ares/random.hpp ares/types.hpp
+  PRIVATE ares/ares.cpp ares/ares.cpp.in ares/ares.hpp ares/inline.hpp ares/platform.hpp ares/random.hpp ares/types.hpp
 )

 target_sources(
@@ -97,6 +99,18 @@ target_sources(
    ares/node/video/video.hpp
 )

+target_sources(
+  ares
+  PRIVATE
+    ares/node/debugger/debugger.hpp
+    ares/node/debugger/graphics.hpp
+    ares/node/debugger/memory.hpp
+    ares/node/debugger/properties.hpp
+    ares/node/debugger/tracer/tracer.hpp
+    ares/node/debugger/tracer/instruction.hpp
+    ares/node/debugger/tracer/notification.hpp
+)
+
 if(OS_WINDOWS)
  include(cmake/os-windows.cmake)
 elseif(OS_MACOS)
@@ -291,6 +305,13 @@ set_source_files_properties(
  n64/vulkan/parallel-rdp/vulkan/device.cpp
  n64/vulkan/parallel-rdp/vulkan/command_buffer.cpp
  n64/vulkan/parallel-rdp/vulkan/render_pass.cpp
+  n64/vulkan/parallel-rdp/vulkan/context.cpp
+  n64/vulkan/parallel-rdp/vulkan/memory_allocator.cpp
+  n64/vulkan/parallel-rdp/vulkan/semaphore.cpp
+  n64/vulkan/parallel-rdp/util/logging.cpp
+  n64/vulkan/parallel-rdp/util/environment.cpp
+  n64/vulkan/parallel-rdp/util/thread_name.cpp
+  n64/vulkan/parallel-rdp/util/timer.cpp
  PROPERTIES SKIP_PRECOMPILE_HEADERS ON
 )

@@ -1,108 +0,0 @@
-ifeq ($(platform),windows)
-  options += $(call lib,uuid kernel32 user32 gdi32 comctl32 comdlg32 shell32)
-else ifeq ($(platform),macos)
-else ifneq ($(filter $(platform),linux bsd),)
-  options += -Wl,-export-dynamic
-  options += -lX11 -lXext
-else
-  $(error "ares is a library and cannot be built directly.")
-endif
-
-ares.objects := ares ares-fixed-allocator
-
-$(object.path)/ares.o: $(ares.path)/ares/ares.cpp
-$(object.path)/ares-fixed-allocator.o: $(ares.path)/ares/memory/fixed-allocator.cpp
-
-ifeq ($(vulkan),true)
-  flags += -DVULKAN
-endif
-
-ifeq ($(profile),accuracy)
-  flags += -DPROFILE_ACCURACY
-endif
-
-ifeq ($(profile),performance)
-  flags += -DPROFILE_PERFORMANCE
-endif
-
-ifneq ($(filter $(cores),a26),)
-  include $(ares.path)/a26/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),fc),)
-  include $(ares.path)/fc/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),sfc),)
-  include $(ares.path)/sfc/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),n64),)
-  include $(ares.path)/n64/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),sg),)
-  include $(ares.path)/sg/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ms),)
-  include $(ares.path)/ms/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),md),)
-  include $(ares.path)/md/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),saturn),)
-  include $(ares.path)/saturn/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ps1),)
-  include $(ares.path)/ps1/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),pce),)
-  include $(ares.path)/pce/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),msx),)
-  include $(ares.path)/msx/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),cv),)
-  include $(ares.path)/cv/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),myvision),)
-  include $(ares.path)/myvision/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),gb),)
-  include $(ares.path)/gb/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),gba),)
-  include $(ares.path)/gba/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ws),)
-  include $(ares.path)/ws/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ng),)
-  include $(ares.path)/ng/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ngp),)
-  include $(ares.path)/ngp/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),spec),)
-  include $(ares.path)/spec/GNUmakefile
-endif
-
-include $(ares.path)/component/GNUmakefile
-
-flags += $(foreach c,$(call strupper,$(cores)),-DCORE_$c)
-
-ares.objects := $(ares.objects:%=$(object.path)/%.o)
@@ -1,15 +0,0 @@
-ares.components += mos6502
-
-ares.objects += ares-a26-system
-ares.objects += ares-a26-controller
-ares.objects += ares-a26-cartridge
-ares.objects += ares-a26-cpu
-ares.objects += ares-a26-tia
-ares.objects += ares-a26-riot
-
-$(object.path)/ares-a26-system.o:     	$(ares.path)/a26/system/system.cpp
-$(object.path)/ares-a26-controller.o: 	$(ares.path)/a26/controller/controller.cpp
-$(object.path)/ares-a26-cartridge.o:  	$(ares.path)/a26/cartridge/cartridge.cpp
-$(object.path)/ares-a26-cpu.o:     		$(ares.path)/a26/cpu/cpu.cpp
-$(object.path)/ares-a26-tia.o:     		$(ares.path)/a26/tia/tia.cpp
-$(object.path)/ares-a26-riot.o:     	$(ares.path)/a26/riot/riot.cpp
@@ -1,12 +1,13 @@
 #pragma once

 #include <ares/ares.hpp>
+#include <vector>

 #include <component/processor/mos6502/mos6502.hpp>

 namespace ares::Atari2600 {
  #include <ares/inline.hpp>
-  auto enumerate() -> vector<string>;
+  auto enumerate() -> std::vector<string>;
  auto load(Node::System& node, string name) -> bool;

  struct Region {
@@ -19,15 +19,15 @@ auto Cartridge::connect() -> void {
  information.region = pak->attribute("region");
  information.board  = pak->attribute("board");

-  if(information.board == "Linear") board = new Board::Linear{*this};
-  if(information.board == "Atari8k") board = new Board::Atari8k{*this};
-  if(information.board == "Atari16k") board = new Board::Atari16k{*this};
-  if(information.board == "Atari32k") board = new Board::Atari32k{*this};
-  if(information.board == "Commavid") board = new Board::Commavid{*this};
-  if(information.board == "ParkerBros8k") board = new Board::ParkerBros{*this};
-  if(information.board == "Tigervision") board = new Board::Tigervision{*this};
+  if(information.board == "Linear") board = std::make_unique<Board::Linear>(*this);
+  if(information.board == "Atari8k") board = std::make_unique<Board::Atari8k>(*this);
+  if(information.board == "Atari16k") board = std::make_unique<Board::Atari16k>(*this);
+  if(information.board == "Atari32k") board = std::make_unique<Board::Atari32k>(*this);
+  if(information.board == "Commavid") board = std::make_unique<Board::Commavid>(*this);
+  if(information.board == "ParkerBros8k") board = std::make_unique<Board::ParkerBros>(*this);
+  if(information.board == "Tigervision") board = std::make_unique<Board::Tigervision>(*this);

-  if(!board) board = new Board::Interface{*this};
+  if(!board) board = std::make_unique<Board::Interface>(*this);
  board->pak = pak;
  board->load();
  power();
@@ -22,7 +22,7 @@ struct Cartridge {
  //serialization.cpp
  auto serialize(serializer&) -> void;

-  unique_pointer<Board::Interface> board;
+  std::unique_ptr<Board::Interface> board;

 //private:
  struct Information {
@@ -20,7 +20,7 @@ auto ControllerPort::unload() -> void {
 }

 auto ControllerPort::allocate(string name) -> Node::Peripheral {
-  if(name == "Gamepad") device = new Gamepad(port);
+  if(name == "Gamepad") device = std::make_unique<Gamepad>(port);
  if(device) return device->node;
  return {};
 }
@@ -1,6 +1,6 @@
 struct ControllerPort {
  Node::Port port;
-  unique_pointer<Controller> device;
+  std::unique_ptr<Controller> device;

  //port.cpp
  ControllerPort(string name);
@@ -19,6 +19,12 @@ auto CPU::unload() -> void {
 }

 auto CPU::main() -> void {
+  if(io.resetPending) {
+    debugger.interrupt("Reset");
+    reset();
+    io.resetPending = 0;
+  }
+
  debugger.instruction();
  instruction();
 }
@@ -31,10 +37,11 @@ auto CPU::step(u32 clocks) -> void {

 auto CPU::power(bool reset) -> void {
  MOS6502::BCD = 1;
-  MOS6502::power();
-  Thread::create(system.frequency() / 3, {&CPU::main, this});
+  if(!reset) MOS6502::power();
+  Thread::create(system.frequency() / 3, std::bind_front(&CPU::main, this));

  io = {};
+  io.resetPending = 1;
 }

 }
@@ -5,9 +5,11 @@ struct CPU : MOS6502, Thread {
    //debugger.cpp
    auto load(Node::Object) -> void;
    auto instruction() -> void;
+    auto interrupt(string_view) -> void;

    struct Tracer {
      Node::Debugger::Tracer::Instruction instruction;
+      Node::Debugger::Tracer::Notification interrupt;
    } tracer;
  } debugger;

@@ -39,6 +41,7 @@ struct CPU : MOS6502, Thread {

 //protected:
  struct IO {
+    n1  resetPending = 0;
    n1  rdyLine = 1;
    n32 scanlineCycles = 0;
    n8 openBus = 0;
@@ -9,4 +9,8 @@ auto CPU::Debugger::instruction() -> void {
  }
 }

-
+auto CPU::Debugger::interrupt(string_view type) -> void {
+  if(tracer.interrupt->enabled()) {
+    tracer.interrupt->notify(type);
+  }
+}
@@ -1,6 +1,7 @@
 auto CPU::serialize(serializer& s) -> void {
  MOS6502::serialize(s);
  Thread::serialize(s);
+  s(io.resetPending);
  s(io.rdyLine);
  s(io.openBus);
 }
@@ -7,14 +7,24 @@ auto RIOT::writeRam(n8 address, n8 data) -> void {
 }

 auto RIOT::readIo(n8 address) -> n8 {
-  switch(address.bit(0, 2)) {
+  address &= 0x1f;
+
+  switch(address) {
  case 0x00: return readPortA();
  case 0x01: return port[0].direction;
  case 0x02: return readPortB();
  case 0x03: return port[1].direction;
-  case 0x04: timer.interruptFlag = address.bit(3); return timer.counter;
+  case 0x04: case 0x06: {
+    n8 data = timer.counter;
+
+    if(timer.interruptFlag && !timer.justWrapped) {
+      timer.interruptFlag = 0;
+    }
+
+    return data;
+  }
  case 0x05: case 0x07: {
-    n8 output = 0;
+    n8 output;
    output.bit(6) = 0; //TODO: PA7 IRQ Flag
    output.bit(7) = timer.interruptFlag;
    return output;
@@ -26,31 +36,38 @@ auto RIOT::readIo(n8 address) -> n8 {
 }

 auto RIOT::writeIo(n8 address, n8 data) -> void {
+  address &= 0x1f;
+
  switch(address) {
  case 0x00: writePortA(data);         return;
  case 0x01: port[0].direction = data; return;
  case 0x02: writePortB(data);         return;
  case 0x03: port[1].direction = data; return;
-  case 0x14: case 0x15: case 0x16: case 0x17:
-  case 0x1c: case 0x1d: case 0x1e: case 0x1f: {
-    const n16 intervals[] = {1, 8, 64, 1024};
-    timer.counter = data;
-    timer.interval = intervals[address.bit(0, 1)];
-    timer.reload = timer.interval;
-    timer.interruptFlag = 0;
-    timer.interruptEnable = address.bit(3);
-    return; }
+  case 0x14: reloadTimer(data,    1, 0); return;
+  case 0x15: reloadTimer(data,    8, 0); return;
+  case 0x16: reloadTimer(data,   64, 0); return;
+  case 0x17: reloadTimer(data, 1024, 0); return;
+  case 0x1c: reloadTimer(data,    1, 1); return;
+  case 0x1d: reloadTimer(data,    8, 1); return;
+  case 0x1e: reloadTimer(data,   64, 1); return;
+  case 0x1f: reloadTimer(data, 1024, 1); return;
  }

-  debug(unimplemented, "[RIOT] IO write ",hex(address), " = ", hex(data));
+  debug(unimplemented, "[RIOT] IO write ", hex(address), " = ", hex(data));
 }

 auto RIOT::readPortA() -> n8 {
-  n8 data;
-  // TODO: Handle when configured as outputs
-  data.bit(0, 3) = controllerPort2.read().bit(0, 4);
-  data.bit(4, 7) = controllerPort1.read().bit(0, 4);
-  return data;
+  n8 output = 0xff;
+
+  n8 input;
+  input.bit(0, 3) = controllerPort2.read().bit(0, 4);
+  input.bit(4, 7) = controllerPort1.read().bit(0, 4);
+
+  for(auto n : range(8)) {
+    output.bit(n) = port[0].direction.bit(n)? port[0].data.bit(n) : input.bit(n);
+  }
+
+  return output;
 }

 auto RIOT::writePortA(n8 data) -> void {
@@ -58,39 +75,41 @@ auto RIOT::writePortA(n8 data) -> void {
 }

 auto RIOT::readPortB() -> n8 {
-    system.controls.poll();
+  system.controls.poll();

-    n8 data;
+  n8 data = 0xff;

-    for(auto n : range(8)) if(port[1].direction.bit(n)) { data.bit(n) = port[1].data.bit(n); }
+  for(auto n : range(8)) {
+    if(port[1].direction.bit(n)) data.bit(n) = port[1].data.bit(n);
+  }

-    // Atari hard-wires these bits as input
-    data.bit(0) = !system.controls.reset->value();
-    data.bit(1) = !system.controls.select->value();
+  // Atari hard-wires these bits as input
+  data.bit(0) = !system.controls.reset->value();
+  data.bit(1) = !system.controls.select->value();

-    // These are toggle switches; flip the values on the rising edge
-    if(system.controls.tvType->value() && !tvTypeLatch) {
-      tvType = !tvType;
-    }
-    tvTypeLatch = system.controls.tvType->value();
+  // These are toggle switches; flip the values on the rising edge
+  if(system.controls.tvType->value() && !tvTypeLatch) {
+    tvType = !tvType;
+  }
+  tvTypeLatch = system.controls.tvType->value();

-    if(system.controls.leftDifficulty->value()  && !leftDifficultyLatch) {
-      leftDifficulty = !leftDifficulty;
-    }
-    leftDifficultyLatch = system.controls.leftDifficulty->value();
+  if(system.controls.leftDifficulty->value() && !leftDifficultyLatch) {
+    leftDifficulty = !leftDifficulty;
+  }
+  leftDifficultyLatch = system.controls.leftDifficulty->value();

-    if(system.controls.rightDifficulty->value() && !rightDifficultyLatch) {
-      rightDifficulty = !rightDifficulty;
-    }
-    rightDifficultyLatch = system.controls.rightDifficulty->value();
+  if(system.controls.rightDifficulty->value() && !rightDifficultyLatch) {
+    rightDifficulty = !rightDifficulty;
+  }
+  rightDifficultyLatch = system.controls.rightDifficulty->value();

-    data.bit(3) = tvType;
-    data.bit(6) = leftDifficulty;
-    data.bit(7) = rightDifficulty;
+  data.bit(3) = tvType;
+  data.bit(6) = leftDifficulty;
+  data.bit(7) = rightDifficulty;

-    return data;
+  return data;
 }

 auto RIOT::writePortB(n8 data) -> void {
-    port[1].data = data;
-}
+  port[1].data = data;
+}
@@ -9,7 +9,6 @@ RIOT riot;

 auto RIOT::load(Node::Object parent) -> void {
  node = parent->append<Node::Object>("RIOT");
-
  ram.allocate(128);
 }

@@ -18,13 +17,52 @@ auto RIOT::unload() -> void {
  node.reset();
 }

-auto RIOT::main() -> void {
-  if(--timer.counter == 0xff) {
+auto RIOT::reloadTimer(n8 data, n16 interval, n1 interruptEnable) -> void {
+  timer.counter = data;
+  timer.interval = interval;
+  timer.prescaler = interval;
+  timer.interruptEnable = interruptEnable;
+  timer.interruptFlag = 0;
+  timer.underflow = 0;
+  timer.holdZero = 0;
+  timer.justWrapped = 0;
+}
+
+auto RIOT::clockTimer() -> void {
+  timer.justWrapped = 0;
+
+  if(timer.prescaler == 0) timer.prescaler = 1;
+  if(--timer.prescaler) return;
+
+  timer.prescaler = timer.interval;
+
+  if(timer.holdZero) {
+    timer.holdZero = 0;
+    timer.underflow = 1;
+    timer.counter = 0xff;
    timer.interval = 1;
+    timer.prescaler = 1;
    timer.interruptFlag = 1;
+    timer.justWrapped = 1;
+    return;
  }

-  step(timer.interval);
+  if(timer.counter == 0x00) {
+    timer.holdZero = 1;
+    return;
+  }
+
+  timer.counter--;
+
+  if(timer.underflow) {
+    timer.interval = 1;
+    timer.prescaler = 1;
+  }
+}
+
+auto RIOT::main() -> void {
+  clockTimer();
+  step(1);
 }

 auto RIOT::step(u32 clocks) -> void {
@@ -33,15 +71,21 @@ auto RIOT::step(u32 clocks) -> void {
 }

 auto RIOT::power(bool reset) -> void {
-  Thread::create(system.frequency() / 3, {&RIOT::main, this});
+  Thread::create(system.frequency() / 3, std::bind_front(&RIOT::main, this));
  timer = {};
+  timer.interval = 1;
+  timer.prescaler = 1;
+  timer.counter = 0x00;
+
  port[0] = {};
  port[0].data = 0xff;
  port[1] = {};
  port[1].data = 0xff;
  leftDifficulty = 1;
+  leftDifficultyLatch = 0;
  rightDifficulty = 1;
+  rightDifficultyLatch = 0;
  tvType = 1;
+  tvTypeLatch = 0;
 }
-
 }
@@ -10,7 +10,8 @@ struct RIOT : Thread {
  auto step(u32 clocks) -> void;
  auto power(bool reset) -> void;

-  auto decrementTimer() -> void;
+  auto clockTimer() -> void;
+  auto reloadTimer(n8 data, n16 interval, n1 interruptEnable) -> void;

  //io.cpp
  auto readRam(n8 address) -> n8;
@@ -27,11 +28,14 @@ struct RIOT : Thread {
  auto serialize(serializer&) -> void;

  struct {
-    u8 counter;
+    n8  counter;
    n16 interval;
-    n16 reload;
-    n1 interruptEnable;
-    n1 interruptFlag;
+    n16 prescaler;
+    n1  interruptEnable;
+    n1  interruptFlag;
+    n1  underflow;
+    n1  holdZero;
+    n1  justWrapped;
  } timer;

  struct Port {
@@ -1,13 +1,16 @@
-//serialization.cpp
 auto RIOT::serialize(serializer& s) -> void {
  Thread::serialize(s);

  s(ram);
+
  s(timer.counter);
  s(timer.interval);
-  s(timer.reload);
+  s(timer.prescaler);
  s(timer.interruptEnable);
  s(timer.interruptFlag);
+  s(timer.underflow);
+  s(timer.holdZero);
+  s(timer.justWrapped);

  for(auto n : range(2)) {
    s(port[n].data);
@@ -1,4 +1,4 @@
-static const string SerializerVersion = "v139";
+static const string SerializerVersion = "v140";

 auto System::serialize(bool synchronize) -> serializer {
  if(synchronize) scheduler.enter(Scheduler::Mode::Synchronize);
@@ -1,8 +1,9 @@
 #include <a26/a26.hpp>
+#include <algorithm>

 namespace ares::Atari2600 {

-auto enumerate() -> vector<string> {
+auto enumerate() -> std::vector<string> {
  return {
    "[Atari] Atari 2600 (NTSC)",
    "[Atari] Atari 2600 (PAL)",
@@ -11,7 +12,8 @@ auto enumerate() -> vector<string> {
 }

 auto load(Node::System& node, string name) -> bool {
-  if(!enumerate().find(name)) return false;
+  auto list = enumerate();
+  if(std::find(list.begin(), list.end(), name) == list.end()) return false;
  return system.load(node, name);
 }

@@ -53,14 +55,15 @@ auto System::load(Node::System& root, string name) -> bool {
    information.frequency = 3546894;
  }

-  node = Node::System::create(information.name);
-  node->setGame({&System::game, this});
-  node->setRun({&System::run, this});
-  node->setPower({&System::power, this});
-  node->setSave({&System::save, this});
-  node->setUnload({&System::unload, this});
-  node->setSerialize({&System::serialize, this});
-  node->setUnserialize({&System::unserialize, this});
+  node = std::make_shared<Core::System>(information.name);
+  node->setAttribute("configuration", name);
+  node->setGame(std::bind_front(&System::game, this));
+  node->setRun(std::bind_front(&System::run, this));
+  node->setPower(std::bind_front(&System::power, this));
+  node->setSave(std::bind_front(&System::save, this));
+  node->setUnload(std::bind_front(&System::unload, this));
+  node->setSerialize([this](bool s){ return this->serialize(s); });
+  node->setUnserialize([this](serializer& s){ return this->unserialize(s); });
  root = node;

  scheduler.reset();
@@ -18,7 +18,7 @@ auto TIA::load(Node::Object parent) -> void {
  node = parent->append<Node::Object>("TIA");

  screen = node->append<Node::Video::Screen>("Screen", 180, displayHeight());
-  screen->colors(1 << 7, {&TIA::color, this});
+  screen->colors(1 << 7, std::bind_front(&TIA::color, this));
  screen->setSize(180, displayHeight());
  screen->setScale(2.0, 1.0);
  Region::PAL() ? screen->setAspect(38.0, 45.0) : screen->setAspect(4.0, 5.0);
@@ -123,7 +123,7 @@ auto TIA::step(u32 clocks) -> void {
 }

 auto TIA::power(bool reset) -> void {
-  Thread::create(system.frequency(), {&TIA::main, this});
+  Thread::create(system.frequency(), std::bind_front(&TIA::main, this));
  screen->power();
  io = {};
  playfield = {};
@@ -7,15 +7,15 @@
 namespace ares {

 Platform* platform = nullptr;
-bool _runAhead = false;
+atomic<bool> _runAhead = false;

-const string Name       = "ares";
-const string Version    = "142";
-const string Copyright  = "ares team, Near";
+const string Name       = "@ARES_NAME@";
+const string Version    = "@ARES_VERSION@";
+const string Copyright  = "@ARES_LEGAL_COPYRIGHT_SHORT@";
 const string License    = "ISC";
 const string LicenseURI = "https://opensource.org/licenses/ISC";
-const string Website    = "ares-emu.net";
-const string WebsiteURI = "https://ares-emu.net/";
+const string Website    = "@ARES_WEBSITE@";
+const string WebsiteURI = "https://@ARES_WEBSITE@/";
 const u32    SerializerSignature = 0x31545342;  //"BST1" (little-endian)

 }
@@ -3,6 +3,10 @@
 #include <libco/libco.h>
 #include <sljit.h>

+#include <vector>
+#include <ranges>
+#include <algorithm>
+
 #include <nall/platform.hpp>
 #include <nall/adaptive-array.hpp>
 #include <nall/any.hpp>
@@ -22,14 +26,13 @@
 #include <nall/random.hpp>
 #include <nall/serializer.hpp>
 #include <nall/set.hpp>
-#include <nall/shared-pointer.hpp>
+#include <nall/span-helpers.hpp>
 #include <nall/string.hpp>
 #include <nall/terminal.hpp>
 #include <nall/thread.hpp>
 #include <nall/traits.hpp>
-#include <nall/unique-pointer.hpp>
+#include <memory>
 #include <nall/variant.hpp>
-#include <nall/vector.hpp>
 #include <nall/vfs.hpp>
 #include <nall/cd.hpp>
 #include <nall/dsp/iir/one-pole.hpp>
@@ -51,8 +54,8 @@ namespace ares {
  extern const u32 SerializerSignature;

  namespace VFS {
-    using Pak = shared_pointer<vfs::directory>;
-    using File = shared_pointer<vfs::file>;
+    using Pak = std::shared_ptr<vfs::directory>;
+    using File = std::shared_ptr<vfs::file>;
  }

  namespace Video {
@@ -66,11 +69,23 @@ namespace ares {
    }
  }

-  extern bool _runAhead;
+  extern atomic<bool> _runAhead;
  inline auto runAhead() -> bool { return _runAhead; }
  inline auto setRunAhead(bool runAhead) -> void { _runAhead = runAhead; }
 }

+/// ares elects to use the reserved C++ `register` identifier liberally in a few different areas so that it can more
+/// freely describe hardware registers within emulated system components. This macro exists to prevent compilers
+/// exploding at the sight of the reserved identifier.
+///
+/// Perhaps unsurprisingly, this macro will conflict with certain system headers. MSVC headers will emit an error
+/// forbidding macroizing `register` if the identifier is defined, while the `clangarm64` system headers in MSYS2
+/// appear to try to make use of the obsolete keyword meaning of the identifier.
+///
+/// Defining this macro after all platform headers are included avoids these conflicts... for now. Removing this
+/// macro along with all uses of this identifier may inevitably become necessary in the future.
+#define register $register
+
 #include <ares/types.hpp>
 #include <ares/random.hpp>
 #include <ares/debug/debug.hpp>
@@ -4,40 +4,40 @@ Debug _debug;

 auto Debug::reset() -> void {
  _totalNotices = 0;
-  _unhandledNotices.reset();
-  _unimplementedNotices.reset();
-  _unusualNotices.reset();
-  _unverifiedNotices.reset();
+  _unhandledNotices.clear();
+  _unimplementedNotices.clear();
+  _unusualNotices.clear();
+  _unverifiedNotices.clear();
 }

 auto Debug::_unhandled(const string& text) -> void {
-  if(_unhandledNotices.find(text)) return;
+  if(std::ranges::find(_unhandledNotices, text) != _unhandledNotices.end()) return;
  if(_totalNotices++ > 256) return;
-  _unhandledNotices.append(text);
+  _unhandledNotices.push_back(text);

  print(terminal::color::yellow("[unhandled] "), text, "\n");
 }

 auto Debug::_unimplemented(const string& text) -> void {
-  if(_unimplementedNotices.find(text)) return;
+  if(std::ranges::find(_unimplementedNotices, text) != _unimplementedNotices.end()) return;
  if(_totalNotices++ > 256) return;
-  _unimplementedNotices.append(text);
+  _unimplementedNotices.push_back(text);

  print(terminal::color::magenta("[unimplemented] "), text, "\n");
 }

 auto Debug::_unusual(const string& text) -> void {
-  if(_unusualNotices.find(text)) return;
+  if(std::ranges::find(_unusualNotices, text) != _unusualNotices.end()) return;
  if(_totalNotices++ > 256) return;
-  _unusualNotices.append(text);
+  _unusualNotices.push_back(text);

  print(terminal::color::cyan("[unusual] "), text, "\n");
 }

 auto Debug::_unverified(const string& text) -> void {
-  if(_unverifiedNotices.find(text)) return;
+  if(std::ranges::find(_unverifiedNotices, text) != _unverifiedNotices.end()) return;
  if(_totalNotices++ > 256) return;
-  _unverifiedNotices.append(text);
+  _unverifiedNotices.push_back(text);

  print(terminal::color::gray("[unverified] "), text, "\n");
 }
@@ -26,10 +26,10 @@ private:
  auto _unverified(const string&) -> void;

  u64 _totalNotices = 0;
-  vector<string> _unhandledNotices;
-  vector<string> _unimplementedNotices;
-  vector<string> _unusualNotices;
-  vector<string> _unverifiedNotices;
+  std::vector<string> _unhandledNotices;
+  std::vector<string> _unimplementedNotices;
+  std::vector<string> _unusualNotices;
+  std::vector<string> _unverifiedNotices;
 };

 extern Debug _debug;
@@ -1,6 +1,7 @@
 #pragma once

 #include <ares/memory/memory.hpp>
+#include <span>

 namespace ares::Memory {

@@ -32,7 +33,7 @@ struct Readable {

  auto load(VFS::File fp) -> void {
    if(!self.size) allocate(fp->size());
-    fp->read({self.data, min(fp->size(), self.size * sizeof(T))});
+    fp->read({(u8*)self.data, min(fp->size(), self.size * sizeof(T))});
    for(u32 address = self.size; address <= self.mask; address++) {
      self.data[address] = self.data[mirror(address, self.size)];
    }
@@ -59,7 +60,7 @@ struct Readable {
  auto end() const -> const T* { return &self.data[self.size]; }

  auto serialize(serializer& s) -> void {
-    s(array_span<T>{self.data, self.size});
+    s(std::span<T>{self.data, self.size});
  }

 //private:
@@ -1,6 +1,7 @@
 #pragma once

 #include <ares/memory/memory.hpp>
+#include <span>

 namespace ares::Memory {

@@ -32,14 +33,14 @@ struct Writable {

  auto load(VFS::File fp) -> void {
    if(!self.size) allocate(fp->size());
-    fp->read({self.data, min(fp->size(), self.size * sizeof(T))});
+    fp->read({(u8*)self.data, min(fp->size(), self.size * sizeof(T))});
    for(u32 address = self.size; address <= self.mask; address++) {
      self.data[address] = self.data[mirror(address, self.size)];
    }
  }

  auto save(VFS::File fp) -> void {
-    fp->write({self.data, min(fp->size(), self.size * sizeof(T))});
+    fp->write({(const u8*)self.data, min(fp->size(), self.size * sizeof(T))});
  }

  explicit operator bool() const { return (bool)self.data; }
@@ -61,7 +62,7 @@ struct Writable {
  auto end() const -> const T* { return &self.data[self.size]; }

  auto serialize(serializer& s) -> void {
-    s(array_span<T>{self.data, self.size});
+    s(std::span<T>{self.data, self.size});
  }

 private:
@@ -1,5 +1,5 @@
 auto Stream::setChannels(u32 channels) -> void {
-  _channels.reset();
+  _channels.clear();
  _channels.resize(channels);
 }

@@ -12,7 +12,7 @@ auto Stream::setResamplerFrequency(f64 resamplerFrequency) -> void {
  _resamplerFrequency = resamplerFrequency;

  for(auto& channel : _channels) {
-    channel.nyquist.reset();
+    channel.nyquist.clear();
    channel.resampler.reset(_frequency, _resamplerFrequency);
  }

@@ -25,7 +25,7 @@ auto Stream::setResamplerFrequency(f64 resamplerFrequency) -> void {
        DSP::IIR::Biquad filter;
        f64 q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
        filter.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, _frequency, q);
-        channel.nyquist.append(filter);
+        channel.nyquist.push_back(filter);
      }
    }
  }
@@ -37,7 +37,7 @@ auto Stream::setMuted(bool muted) -> void {

 auto Stream::resetFilters() -> void {
  for(auto& channel : _channels) {
-    channel.filters.reset();
+    channel.filters.clear();
  }
 }

@@ -47,13 +47,13 @@ auto Stream::addLowPassFilter(f64 cutoffFrequency, u32 order, u32 passes) -> voi
      if(order == 1) {
        Filter filter{Filter::Mode::OnePole, Filter::Type::LowPass, Filter::Order::First};
        filter.onePole.reset(DSP::IIR::OnePole::Type::LowPass, cutoffFrequency, _frequency);
-        channel.filters.append(filter);
+        channel.filters.push_back(filter);
      }
      if(order == 2) {
        Filter filter{Filter::Mode::Biquad, Filter::Type::LowPass, Filter::Order::Second};
        f64 q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
        filter.biquad.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, _frequency, q);
-        channel.filters.append(filter);
+        channel.filters.push_back(filter);
      }
    }
  }
@@ -65,13 +65,13 @@ auto Stream::addHighPassFilter(f64 cutoffFrequency, u32 order, u32 passes) -> vo
      if(order == 1) {
        Filter filter{Filter::Mode::OnePole, Filter::Type::HighPass, Filter::Order::First};
        filter.onePole.reset(DSP::IIR::OnePole::Type::HighPass, cutoffFrequency, _frequency);
-        channel.filters.append(filter);
+        channel.filters.push_back(filter);
      }
      if(order == 2) {
        Filter filter{Filter::Mode::Biquad, Filter::Type::HighPass, Filter::Order::Second};
        f64 q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
        filter.biquad.reset(DSP::IIR::Biquad::Type::HighPass, cutoffFrequency, _frequency, q);
-        channel.filters.append(filter);
+        channel.filters.push_back(filter);
      }
    }
  }
@@ -83,7 +83,7 @@ auto Stream::addLowShelfFilter(f64 cutoffFrequency, u32 order, f64 gain, f64 slo
      Filter filter{Filter::Mode::Biquad, Filter::Type::LowShelf, Filter::Order::Second};
      f64 q = DSP::IIR::Biquad::shelf(gain, slope);
      filter.biquad.reset(DSP::IIR::Biquad::Type::LowShelf, cutoffFrequency, _frequency, q);
-      channel.filters.append(filter);
+      channel.filters.push_back(filter);
    }
  }
 }
@@ -94,13 +94,13 @@ auto Stream::addHighShelfFilter(f64 cutoffFrequency, u32 order, f64 gain, f64 sl
      Filter filter{Filter::Mode::Biquad, Filter::Type::HighShelf, Filter::Order::Second};
      f64 q = DSP::IIR::Biquad::shelf(gain, slope);
      filter.biquad.reset(DSP::IIR::Biquad::Type::HighShelf, cutoffFrequency, _frequency, q);
-      channel.filters.append(filter);
+      channel.filters.push_back(filter);
    }
  }
 }

 auto Stream::pending() const -> bool {
-  return _channels && _channels[0].resampler.pending();
+  return !_channels.empty() && _channels[0].resampler.pending();
 }

 auto Stream::read(f64 samples[]) -> u32 {
@@ -127,5 +127,5 @@ auto Stream::write(const f64 samples[]) -> void {

  //if there are samples pending, then alert the frontend to possibly process them.
  //this will generally happen when every audio stream has pending samples to be mixed.
-  if(pending()) platform->audio(shared());
+  if(pending()) platform->audio(std::static_pointer_cast<Core::Audio::Stream>(shared_from_this()));
 }
@@ -38,11 +38,11 @@ protected:
    DSP::IIR::Biquad biquad;
  };
  struct Channel {
-    vector<Filter> filters;
-    vector<DSP::IIR::Biquad> nyquist;
+    std::vector<Filter> filters;
+    std::vector<DSP::IIR::Biquad> nyquist;
    DSP::Resampler::Cubic resampler;
  };
-  vector<Channel> _channels;
+  std::vector<Channel> _channels;
  f64 _frequency = 48000.0;
  f64 _resamplerFrequency = 48000.0;
  bool _muted = false;
@@ -4,26 +4,28 @@
 struct Class {
  struct Instance {
    const string identifier;
-    const function<Node::Object ()> create;
+    const std::function<Node::Object ()> create;
  };

-  static auto classes() -> vector<Instance>& {
-    static vector<Instance> classes;
+  static auto classes() -> std::vector<Instance>& {
+    static std::vector<Instance> classes;
    return classes;
  }

  template<typename T> static auto register() -> void {
-    if(!classes().find([&](auto instance) { return instance.identifier == T::identifier(); })) {
-      classes().append({T::identifier(), &T::create});
+    auto& cls = classes();
+    auto it = std::ranges::find_if(cls, [&](const Instance& instance) { return instance.identifier == T::identifier(); });
+    if(it == cls.end()) {
+      cls.push_back({T::identifier(), &T::create});
    } else {
      throw;
    }
  }

  static auto create(string identifier) -> Node::Object {
-    if(auto index = classes().find([&](auto instance) { return instance.identifier == identifier; })) {
-      return classes()[*index].create();
-    }
+    auto& cls = classes();
+    auto it = std::ranges::find_if(cls, [&](const Instance& instance) { return instance.identifier == identifier; });
+    if(it != cls.end()) return it->create();
    if(identifier == "Object") throw;  //should never occur: detects unregistered classes
    return create("Object");
  }
@@ -5,7 +5,7 @@ struct RealTimeClock : Component {
  auto update() -> void { if(_update) return _update(); }
  auto timestamp() const -> u64 { return _timestamp; }

-  auto setUpdate(function<void ()> update) -> void { _update = update; }
+  auto setUpdate(std::function<void ()> update) -> void { _update = update; }
  auto setTimestamp(u64 timestamp) -> void { _timestamp = timestamp; }

  auto synchronize(u64 timestamp = 0) -> void {
@@ -25,6 +25,6 @@ struct RealTimeClock : Component {
  }

 protected:
-  function<void ()> _update;
+  std::function<void ()> _update;
  u64 _timestamp;
 };
@@ -6,10 +6,10 @@ struct Graphics : Debugger {

  auto width() const -> u32 { return _width; }
  auto height() const -> u32 { return _height; }
-  auto capture() const -> vector<u32> { if(_capture) return _capture(); return {}; }
+  auto capture() const -> std::vector<u32> { if(_capture) return _capture(); return {}; }

  auto setSize(u32 width, u32 height) -> void { _width = width, _height = height; }
-  auto setCapture(function<vector<u32> ()> capture) -> void { _capture = capture; }
+  auto setCapture(std::function<std::vector<u32> ()> capture) -> void { _capture = capture; }

  auto serialize(string& output, string depth) -> void override {
    Debugger::serialize(output, depth);
@@ -22,5 +22,5 @@ struct Graphics : Debugger {
 protected:
  u32 _width = 0;
  u32 _height = 0;
-  function<vector<u32> ()> _capture;
+  std::function<std::vector<u32> ()> _capture;
 };
@@ -9,8 +9,8 @@ struct Memory : Debugger {
  auto write(u32 address, u8 data) const -> void { if(_write) return _write(address, data); }

  auto setSize(u32 size) -> void { _size = size; }
-  auto setRead(function<u8 (u32)> read) -> void { _read = read; }
-  auto setWrite(function<void (u32, u8)> write) -> void { _write = write; }
+  auto setRead(std::function<u8 (u32)> read) -> void { _read = read; }
+  auto setWrite(std::function<void (u32, u8)> write) -> void { _write = write; }

  auto serialize(string& output, string depth) -> void override {
    Debugger::serialize(output, depth);
@@ -22,6 +22,6 @@ struct Memory : Debugger {

 protected:
  u32 _size = 0;
-  function<u8 (u32)> _read;
-  function<void (u32, u8)> _write;
+  std::function<u8 (u32)> _read;
+  std::function<void (u32, u8)> _write;
 };
@@ -6,7 +6,7 @@ struct Properties : Debugger {

  auto query() const -> string { if(_query) return _query(); return {}; }

-  auto setQuery(function<string ()> query) -> void { _query = query; }
+  auto setQuery(std::function<string ()> query) -> void { _query = query; }

  auto serialize(string& output, string depth) -> void override {
    Debugger::serialize(output, depth);
@@ -17,5 +17,5 @@ struct Properties : Debugger {
  }

 protected:
-  function<string ()> _query;
+  std::function<string ()> _query;
 };
@@ -23,11 +23,20 @@ struct Instruction : Tracer {

  auto setDepth(u32 depth) -> void {
    _depth = depth;
-    _history.reset();
+    _history.clear();
    _history.resize(depth);
    for(auto& history : _history) history = ~0ull;
  }

+  auto setEnabled(bool enabled) -> void {
+    Tracer::setTerminal(enabled);
+    if(!enabled) {
+      _omitted = 0;
+      setMask(_mask);
+      setDepth(_depth);
+    }
+  }
+
  auto address(u64 address) -> bool {
    address &= ~0ull >> (64 - _addressBits);  //mask upper bits of address
    _address = address;
@@ -49,7 +58,7 @@ struct Instruction : Tracer {
      for(auto index : range(_depth - 1)) {
        _history[index] = _history[index + 1];
      }
-      _history.last() = _address;
+      _history.back() = _address;
    }

    return true;
@@ -71,7 +80,8 @@ struct Instruction : Tracer {
    if(!enabled()) return;

    if(_omitted) {
-      PlatformLog(shared(), {"[Omitted: ", _omitted, "]"});
+      auto message = string{ "[Omitted: ", _omitted, "]" };
+      PlatformLog(std::dynamic_pointer_cast<Tracer>(shared_from_this()), message);
      _omitted = 0;
    }

@@ -82,7 +92,7 @@ struct Instruction : Tracer {
      context, "  ",
      extra
    };
-    PlatformLog(shared(), {output.strip()});
+    PlatformLog(std::dynamic_pointer_cast<Tracer>(shared_from_this()), {output.strip()});
  }

  auto serialize(string& output, string depth) -> void override {
@@ -135,6 +145,6 @@ protected:
 //unserialized:
  n64 _address = 0;
  n64 _omitted = 0;
-  vector<u64> _history;
+  std::vector<u64> _history;
  hashset<VisitMask> _masks;
 };
@@ -6,7 +6,7 @@ struct Notification : Tracer {

  auto notify(const string& message = {}) -> void {
    if(!enabled()) return;
-    PlatformLog(shared(), message);
+    PlatformLog(std::dynamic_pointer_cast<Tracer>(shared_from_this()), message);
  }

 protected:
@@ -12,7 +12,7 @@ struct Tracer : Debugger {
  auto file() const -> bool { return _file; }
  auto autoLineBreak() const -> bool { return _autoLineBreak; }

-  auto setToggle(function<void ()> toggle) -> void { _toggle = toggle; }
+  auto setToggle(std::function<void ()> toggle) -> void { _toggle = toggle; }
  auto setComponent(string component) -> void { _component = component; }
  auto setPrefix(bool prefix) -> void { _prefix = prefix; }
  auto setTerminal(bool terminal) -> void { _terminal = terminal; if(_toggle) _toggle(); }
@@ -36,7 +36,7 @@ struct Tracer : Debugger {
  }

 protected:
-  function<void ()> _toggle;
+  std::function<void ()> _toggle;
  string _component;
  bool _prefix = false;
  bool _terminal = false;
@@ -5,6 +5,57 @@ struct Axis : Input {
  auto value() const -> s64 { return _value; }
  auto setValue(s64 value) -> void { _value = value; }

+    auto setOperatingRange(s16 position, double saturationRadius, double offset) -> double {
+    return position * saturationRadius / 32767.0 + offset;
+  }
+  
+  auto processDeadzoneAndResponseCurve(double position, double innerDeadzone, double cardinalMax, double offset) -> double {
+    auto lengthAbsolute = abs(position - offset);
+    if(lengthAbsolute <= innerDeadzone) {
+      position = offset;
+    } else {
+      lengthAbsolute = (lengthAbsolute - innerDeadzone) * (cardinalMax) / (cardinalMax - innerDeadzone) / lengthAbsolute;
+      position = (position - offset) * lengthAbsolute + offset;
+    }
+    return position;
+  }
+
+  auto revisePosition(double position, double length, double saturationRadius, double offset) -> double {
+    if(length > saturationRadius) {
+      length = saturationRadius / length;
+      position = (position - offset) * length + offset;
+    }
+    return position;
+  }
+
+  auto applyGateBoundaries(double innerDeadzone, double cardinalMax, double diagonalMax, double positionX, double positionY, double offset, double& boundedPositionX, double& boundedPositionY) -> void {
+    if(positionX != offset && positionY != offset) {
+      auto slope = (positionY - offset) / (positionX - offset);
+      auto edgex = copysign(cardinalMax / (abs(slope) + (cardinalMax - diagonalMax) / diagonalMax), positionX);
+      auto edgey = copysign(min(abs(edgex * slope), cardinalMax / (1.0 / abs(slope) + (cardinalMax - diagonalMax) / diagonalMax)), positionY);
+      edgex = edgey / slope;
+
+      auto distanceToEdge = hypot(edgex, edgey);
+
+      auto length = hypot(positionX - offset, positionY - offset);
+      if(length > distanceToEdge) {
+        positionX = edgex + offset;
+        positionY = edgey + offset;
+      }
+    }
+    boundedPositionX = positionX;
+    boundedPositionY = positionY;
+  }
+
+  auto clampAxisToNearestBoundary(double position, double offset, double cardinalMax) -> double {
+    if(abs(position - offset) > cardinalMax) position = copysign(cardinalMax, position - offset) + offset;
+    return position;
+  }
+
+  auto counteractPrecisionError(double position) -> double {
+    return copysign(abs(position) + 1e-09, position);
+  }
+  
 protected:
  s64 _value = 0;
  s64 _minimum = -32768;
@@ -3,6 +3,7 @@ namespace ares::Core {
  struct System;
  struct Peripheral;
  struct Port;
+  struct Tape;
  namespace Component {
    struct Component;
    struct RealTimeClock;
@@ -45,47 +46,48 @@ namespace ares::Core {
 }

 namespace ares::Node {
-  using Object           = shared_pointer<Core::Object>;
-  using System           = shared_pointer<Core::System>;
-  using Peripheral       = shared_pointer<Core::Peripheral>;
-  using Port             = shared_pointer<Core::Port>;
+  using Object           = std::shared_ptr<Core::Object>;
+  using System           = std::shared_ptr<Core::System>;
+  using Peripheral       = std::shared_ptr<Core::Peripheral>;
+  using Port             = std::shared_ptr<Core::Port>;
+  using Tape             = std::shared_ptr<Core::Tape>;
  namespace Component {
-    using Component      = shared_pointer<Core::Component::Component>;
-    using RealTimeClock  = shared_pointer<Core::Component::RealTimeClock>;
+    using Component      = std::shared_ptr<Core::Component::Component>;
+    using RealTimeClock  = std::shared_ptr<Core::Component::RealTimeClock>;
  }
  namespace Video {
-    using Video          = shared_pointer<Core::Video::Video>;
-    using Sprite         = shared_pointer<Core::Video::Sprite>;
-    using Screen         = shared_pointer<Core::Video::Screen>;
+    using Video          = std::shared_ptr<Core::Video::Video>;
+    using Sprite         = std::shared_ptr<Core::Video::Sprite>;
+    using Screen         = std::shared_ptr<Core::Video::Screen>;
  }
  namespace Audio {
-    using Audio          = shared_pointer<Core::Audio::Audio>;
-    using Stream         = shared_pointer<Core::Audio::Stream>;
+    using Audio          = std::shared_ptr<Core::Audio::Audio>;
+    using Stream         = std::shared_ptr<Core::Audio::Stream>;
  }
  namespace Input {
-    using Input          = shared_pointer<Core::Input::Input>;
-    using Button         = shared_pointer<Core::Input::Button>;
-    using Axis           = shared_pointer<Core::Input::Axis>;
-    using Trigger        = shared_pointer<Core::Input::Trigger>;
-    using Rumble         = shared_pointer<Core::Input::Rumble>;
+    using Input          = std::shared_ptr<Core::Input::Input>;
+    using Button         = std::shared_ptr<Core::Input::Button>;
+    using Axis           = std::shared_ptr<Core::Input::Axis>;
+    using Trigger        = std::shared_ptr<Core::Input::Trigger>;
+    using Rumble         = std::shared_ptr<Core::Input::Rumble>;
  }
  namespace Setting {
-    using Setting        = shared_pointer<Core::Setting::Setting>;
-    using Boolean        = shared_pointer<Core::Setting::Boolean>;
-    using Natural        = shared_pointer<Core::Setting::Natural>;
-    using Integer        = shared_pointer<Core::Setting::Integer>;
-    using Real           = shared_pointer<Core::Setting::Real>;
-    using String         = shared_pointer<Core::Setting::String>;
+    using Setting        = std::shared_ptr<Core::Setting::Setting>;
+    using Boolean        = std::shared_ptr<Core::Setting::Boolean>;
+    using Natural        = std::shared_ptr<Core::Setting::Natural>;
+    using Integer        = std::shared_ptr<Core::Setting::Integer>;
+    using Real           = std::shared_ptr<Core::Setting::Real>;
+    using String         = std::shared_ptr<Core::Setting::String>;
  }
  namespace Debugger {
-    using Debugger       = shared_pointer<Core::Debugger::Debugger>;
-    using Memory         = shared_pointer<Core::Debugger::Memory>;
-    using Graphics       = shared_pointer<Core::Debugger::Graphics>;
-    using Properties     = shared_pointer<Core::Debugger::Properties>;
+    using Debugger       = std::shared_ptr<Core::Debugger::Debugger>;
+    using Memory         = std::shared_ptr<Core::Debugger::Memory>;
+    using Graphics       = std::shared_ptr<Core::Debugger::Graphics>;
+    using Properties     = std::shared_ptr<Core::Debugger::Properties>;
    namespace Tracer {
-      using Tracer       = shared_pointer<Core::Debugger::Tracer::Tracer>;
-      using Notification = shared_pointer<Core::Debugger::Tracer::Notification>;
-      using Instruction  = shared_pointer<Core::Debugger::Tracer::Instruction>;
+      using Tracer       = std::shared_ptr<Core::Debugger::Tracer::Tracer>;
+      using Notification = std::shared_ptr<Core::Debugger::Tracer::Notification>;
+      using Instruction  = std::shared_ptr<Core::Debugger::Tracer::Instruction>;
    }
  }
 }
@@ -102,6 +104,7 @@ namespace ares::Core {
  #include <ares/node/system.hpp>
  #include <ares/node/peripheral.hpp>
  #include <ares/node/port.hpp>
+  #include <ares/node/tape.hpp>
  namespace Component {
    #include <ares/node/component/component.hpp>
    #include <ares/node/component/real-time-clock.hpp>
@@ -164,9 +167,10 @@ namespace ares::Node {
  }

  static inline auto parent(Object child) -> Object {
-    if(!child || !child->parent()) return {};
-    if(auto parent = child->parent().acquire()) return parent;
-    return {};
+    if(!child) return {};
+    auto wp = child->parent();
+    if(wp.expired()) return {};
+    return wp.lock();
  }

  template<typename T>
@@ -177,8 +181,8 @@ namespace ares::Node {
  }

  template<typename T>
-  static inline auto enumerate(Object from) -> vector<T> {
-    vector<T> objects;
+  static inline auto enumerate(Object from) -> std::vector<T> {
+    std::vector<T> objects;
    if(from) from->enumerate<T>(objects);
    return objects;
  }
@@ -3,13 +3,13 @@

 #define DeclareClass(Type, Name) \
  static auto identifier() -> string { return Name; } \
-  static auto create() -> Node::Object { return new Type; } \
+  static auto create() -> Node::Object { return std::make_shared<Type>(); } \
  auto identity() const -> string override { return Name; } \
  private: static inline Class::Register<Type> register; public: \

-struct Object : shared_pointer_this<Object> {
+struct Object : std::enable_shared_from_this<Object> {
  static auto identifier() -> string { return "Object"; }
-  static auto create() -> Node::Object { return new Object; }
+  static auto create() -> Node::Object { return std::make_shared<Object>(); }
  virtual auto identity() const -> string { return "Object"; }
  private: static inline Class::Register<Object> register; public:
 //DeclareClass(Object, "object")
@@ -18,44 +18,47 @@ struct Object : shared_pointer_this<Object> {
  virtual ~Object() = default;

  auto name() const -> string { return _name; }
-  auto parent() const -> shared_pointer_weak<Object> { return _parent; }
+  auto parent() const -> std::weak_ptr<Object> { return _parent; }

  auto setName(string_view name) -> void { _name = name; }

  auto prepend(Node::Object node) -> Node::Object {
    if(auto found = find(node)) return found;
-    _nodes.prepend(node);
-    node->_parent = shared();
+    _nodes.insert(_nodes.begin(), node);
+    node->_parent = shared_from_this();
    PlatformAttach(node);
    return node;
  }

  template<typename T, typename... P>
-  auto prepend(P&&... p) -> Node::Object {
-    using Type = typename T::type;
-    return prepend(shared_pointer<Type>::create(std::forward<P>(p)...));
+  auto prepend(P&&... p) -> std::shared_ptr<typename T::element_type> {
+    using Type = typename T::element_type;
+    auto node = std::make_shared<Type>(std::forward<P>(p)...);
+    prepend(node);
+    return node;
  }

  auto append(Node::Object node) -> Node::Object {
    if(auto found = find(node)) return found;
-    _nodes.append(node);
-    node->_parent = shared();
+    _nodes.push_back(node);
+    node->_parent = shared_from_this();
    PlatformAttach(node);
    return node;
  }

  template<typename T, typename... P>
-  auto append(P&&... p) -> Node::Object {
-    using Type = typename T::type;
-    return append(shared_pointer<Type>::create(std::forward<P>(p)...));
+  auto append(P&&... p) -> std::shared_ptr<typename T::element_type> {
+    using Type = typename T::element_type;
+    auto node = std::make_shared<Type>(std::forward<P>(p)...);
+    append(node);
+    return node;
  }

  auto remove(Node::Object node) -> void {
-    if(auto index = _nodes.find(node)) {
+    if(std::erase(_nodes, node)) {
      PlatformDetach(node);
      node->reset();
      node->_parent.reset();
-      _nodes.remove(*index);
    }
  }

@@ -65,13 +68,12 @@ struct Object : shared_pointer_this<Object> {
      node->reset();
      node->_parent.reset();
    }
-    _nodes.reset();
+    _nodes.clear();
  }

  template<typename T>
-  auto cast() -> shared_pointer<typename T::type> {
-    if(dynamic_cast<typename T::type*>(this)) return shared();
-    return {};
+  auto cast() -> std::shared_ptr<typename T::element_type> {
+    return std::dynamic_pointer_cast<typename T::element_type>(shared_from_this());
  }

  template<typename T>
@@ -80,17 +82,20 @@ struct Object : shared_pointer_this<Object> {
  }

  template<typename T>
-  auto find() -> vector<shared_pointer<typename T::type>> {
-    vector<shared_pointer<typename T::type>> result;
-    if(dynamic_cast<typename T::type*>(this)) {
-      if(auto instance = shared()) result.append(instance);
+  auto find() -> std::vector<std::shared_ptr<typename T::element_type>> {
+    std::vector<std::shared_ptr<typename T::element_type>> result;
+    if(dynamic_cast<typename T::element_type*>(this)) {
+      if(auto instance = cast<T>()) result.push_back(instance);
+    }
+    for(auto& node : _nodes) {
+      auto sub = node->find<T>();
+      std::ranges::copy(sub, std::back_inserter(result));
    }
-    for(auto& node : _nodes) result.append(node->find<T>());
    return result;
  }

  template<typename T>
-  auto find(u32 index) -> shared_pointer<typename T::type> {
+  auto find(u32 index) -> std::shared_ptr<typename T::element_type> {
    auto result = find<T>();
    if(index < result.size()) return result[index];
    return {};
@@ -106,31 +111,33 @@ struct Object : shared_pointer_this<Object> {

  template<typename T = Node::Object>
  auto find(string name) -> T {
-    using Type = typename T::type;
-    auto path = name.split("/");
-    name = path.takeFirst();
+    using Type = typename T::element_type;
+    auto path = nall::split(name, "/");
+    if(path.empty()) return {};
+    name = path.front();
+    path.erase(path.begin());
    for(auto& node : _nodes) {
      if(node->_name != name) continue;
-      if(path) return node->find<T>(path.merge("/"));
-      if(node->identity() == Type::identifier()) return node;
+      if(!path.empty()) return node->find<T>(nall::merge(path, "/"));
+      if(node->identity() == Type::identifier()) return node->template cast<T>();
    }
    return {};
  }

  template<typename T = Node::Object>
  auto scan(string name) -> T {
-    using Type = typename T::type;
+    using Type = typename T::element_type;
    for(auto& node : _nodes) {
-      if(node->identity() == Type::identifier() && node->_name == name) return node;
+      if(node->identity() == Type::identifier() && node->_name == name) return node->template cast<T>();
      if(auto result = node->scan<T>(name)) return result;
    }
    return {};
  }

  template<typename T>
-  auto enumerate(vector<T>& objects) -> void {
-    using Type = typename T::type;
-    if(auto instance = cast<T>()) objects.append(instance);
+  auto enumerate(std::vector<T>& objects) -> void {
+    using Type = typename T::element_type;
+    if(auto instance = cast<T>()) objects.push_back(instance);
    for(auto& node : _nodes) node->enumerate<T>(objects);
  }

@@ -230,6 +237,6 @@ protected:
  string _name;
  VFS::Pak _pak;
  set<Attribute> _attributes;
-  shared_pointer_weak<Object> _parent;
-  vector<Node::Object> _nodes;
+  std::weak_ptr<Object> _parent;
+  std::vector<Node::Object> _nodes;
 };
@@ -5,15 +5,15 @@ struct Port : Object {
  auto type() const -> string { return _type; }
  auto family() const -> string { return _family; }
  auto hotSwappable() const -> bool { return _hotSwappable; }
-  auto supported() const -> vector<string> { return _supported; }
+  auto supported() const -> std::vector<string> { return _supported; }

-  auto setAllocate(function<Node::Peripheral (string)> allocate) -> void { _allocate = allocate; }
-  auto setConnect(function<void ()> connect) -> void { _connect = connect; }
-  auto setDisconnect(function<void ()> disconnect) -> void { _disconnect = disconnect; }
+  auto setAllocate(std::function<Node::Peripheral (string)> allocate) -> void { _allocate = allocate; }
+  auto setConnect(std::function<void ()> connect) -> void { _connect = connect; }
+  auto setDisconnect(std::function<void ()> disconnect) -> void { _disconnect = disconnect; }
  auto setType(string type) -> void { _type = type; }
  auto setFamily(string family) -> void { _family = family; }
  auto setHotSwappable(bool hotSwappable) -> void { _hotSwappable = hotSwappable; }
-  auto setSupported(vector<string> supported) -> void { _supported = supported; }
+  auto setSupported(std::vector<string> supported) -> void { _supported = supported; }

  auto connected() -> Node::Peripheral {
    return find<Node::Peripheral>(0);
@@ -64,11 +64,11 @@ struct Port : Object {
  }

 protected:
-  function<Node::Peripheral (string)> _allocate;
-  function<void ()> _connect;
-  function<void ()> _disconnect;
+  std::function<Node::Peripheral (string)> _allocate;
+  std::function<void ()> _connect;
+  std::function<void ()> _disconnect;
  string _type;
  string _family;
  bool _hotSwappable = false;
-  vector<string> _supported;
+  std::vector<string> _supported;
 };
@@ -1,7 +1,7 @@
 struct Boolean : Setting {
  DeclareClass(Boolean, "setting.boolean")

-  Boolean(string name = {}, bool value = {}, function<void (bool)> modify = {}) : Setting(name) {
+  Boolean(string name = {}, bool value = {}, std::function<void (bool)> modify = {}) : Setting(name) {
    _currentValue = value;
    _latchedValue = value;
    _modify = modify;
@@ -11,7 +11,7 @@ struct Boolean : Setting {
  auto value() const -> bool { return _currentValue; }
  auto latch() const -> bool { return _latchedValue; }

-  auto setModify(function<void (bool)> modify) { _modify = modify; }
+  auto setModify(std::function<void (bool)> modify) { _modify = modify; }

  auto setValue(bool value) -> void {
    _currentValue = value;
@@ -26,11 +26,11 @@ struct Boolean : Setting {

  auto readValue() const -> string override { return value(); }
  auto readLatch() const -> string override { return latch(); }
-  auto readAllowedValues() const -> vector<string> override { return {"false", "true"}; }
+  auto readAllowedValues() const -> std::vector<string> override { return {"false", "true"}; }
  auto writeValue(string value) -> void override { setValue(value.boolean()); }

 protected:
-  function<void (bool)> _modify;
+  std::function<void (bool)> _modify;
  bool _currentValue = {};
  bool _latchedValue = {};
 };
@@ -1,7 +1,7 @@
 struct Integer : Setting {
  DeclareClass(Integer, "setting.integer")

-  Integer(string name = {}, s64 value = {}, function<void (s64)> modify = {}) : Setting(name) {
+  Integer(string name = {}, s64 value = {}, std::function<void (s64)> modify = {}) : Setting(name) {
    _currentValue = value;
    _latchedValue = value;
    _modify = modify;
@@ -11,10 +11,10 @@ struct Integer : Setting {
  auto value() const -> s64 { return _currentValue; }
  auto latch() const -> s64 { return _latchedValue; }

-  auto setModify(function<void (s64)> modify) { _modify = modify; }
+  auto setModify(std::function<void (s64)> modify) { _modify = modify; }

  auto setValue(s64 value) -> void {
-    if(_allowedValues && !_allowedValues.find(value)) return;
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, value)) return;
    _currentValue = value;
    if(_dynamic) setLatch();
  }
@@ -25,23 +25,23 @@ struct Integer : Setting {
    modify(_latchedValue);
  }

-  auto setAllowedValues(vector<s64> allowedValues) -> void {
+  auto setAllowedValues(std::vector<s64> allowedValues) -> void {
    _allowedValues = allowedValues;
-    if(_allowedValues && !_allowedValues.find(_currentValue)) setValue(_allowedValues.first());
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, _currentValue)) setValue(_allowedValues.front());
  }

  auto readValue() const -> string override { return value(); }
  auto readLatch() const -> string override { return latch(); }
-  auto readAllowedValues() const -> vector<string> override {
-    vector<string> values;
-    for(auto value : _allowedValues) values.append(value);
+  auto readAllowedValues() const -> std::vector<string> override {
+    std::vector<string> values;
+    for(auto value : _allowedValues) values.push_back(value);
    return values;
  }
  auto writeValue(string value) -> void override { setValue(value.integer()); }

 protected:
-  function<void (s64)> _modify;
+  std::function<void (s64)> _modify;
  s64 _currentValue = {};
  s64 _latchedValue = {};
-  vector<s64> _allowedValues;
+  std::vector<s64> _allowedValues;
 };
@@ -1,7 +1,7 @@
 struct Natural : Setting {
  DeclareClass(Natural, "setting.natural")

-  Natural(string name = {}, u64 value = {}, function<void (u64)> modify = {}) : Setting(name) {
+  Natural(string name = {}, u64 value = {}, std::function<void (u64)> modify = {}) : Setting(name) {
    _currentValue = value;
    _latchedValue = value;
    _modify = modify;
@@ -11,10 +11,10 @@ struct Natural : Setting {
  auto value() const -> u64 { return _currentValue; }
  auto latch() const -> u64 { return _latchedValue; }

-  auto setModify(function<void (u64)> modify) { _modify = modify; }
+  auto setModify(std::function<void (u64)> modify) { _modify = modify; }

  auto setValue(u64 value) -> void {
-    if(_allowedValues && !_allowedValues.find(value)) return;
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, value)) return;
    _currentValue = value;
    if(_dynamic) setLatch();
  }
@@ -25,23 +25,23 @@ struct Natural : Setting {
    modify(_latchedValue);
  }

-  auto setAllowedValues(vector<u64> allowedValues) -> void {
+  auto setAllowedValues(std::vector<u64> allowedValues) -> void {
    _allowedValues = allowedValues;
-    if(_allowedValues && !_allowedValues.find(_currentValue)) setValue(_allowedValues.first());
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, _currentValue)) setValue(_allowedValues.front());
  }

  auto readValue() const -> string override { return value(); }
  auto readLatch() const -> string override { return latch(); }
-  auto readAllowedValues() const -> vector<string> override {
-    vector<string> values;
-    for(auto value : _allowedValues) values.append(value);
+  auto readAllowedValues() const -> std::vector<string> override {
+    std::vector<string> values;
+    for(auto value : _allowedValues) values.push_back(value);
    return values;
  }
  auto writeValue(string value) -> void override { setValue(value.natural()); }

 protected:
-  function<void (u64)> _modify;
+  std::function<void (u64)> _modify;
  u64 _currentValue = {};
  u64 _latchedValue = {};
-  vector<u64> _allowedValues;
+  std::vector<u64> _allowedValues;
 };
@@ -1,7 +1,7 @@
 struct Real : Setting {
  DeclareClass(Real, "setting.real")

-  Real(string name = {}, f64 value = {}, function<void (f64)> modify = {}) : Setting(name) {
+  Real(string name = {}, f64 value = {}, std::function<void (f64)> modify = {}) : Setting(name) {
    _currentValue = value;
    _latchedValue = value;
    _modify = modify;
@@ -11,10 +11,10 @@ struct Real : Setting {
  auto value() const -> f64 { return _currentValue; }
  auto latch() const -> f64 { return _latchedValue; }

-  auto setModify(function<void (f64)> modify) { _modify = modify; }
+  auto setModify(std::function<void (f64)> modify) { _modify = modify; }

  auto setValue(f64 value) -> void {
-    if(_allowedValues && !_allowedValues.find(value)) return;
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, value)) return;
    _currentValue = value;
    if(_dynamic) setLatch();
  }
@@ -25,23 +25,23 @@ struct Real : Setting {
    modify(_latchedValue);
  }

-  auto setAllowedValues(vector<f64> allowedValues) -> void {
+  auto setAllowedValues(std::vector<f64> allowedValues) -> void {
    _allowedValues = allowedValues;
-    if(_allowedValues && !_allowedValues.find(_currentValue)) setValue(_allowedValues.first());
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, _currentValue)) setValue(_allowedValues.front());
  }

  auto readValue() const -> string override { return value(); }
  auto readLatch() const -> string override { return latch(); }
-  auto readAllowedValues() const -> vector<string> override {
-    vector<string> values;
-    for(auto value : _allowedValues) values.append(value);
+  auto readAllowedValues() const -> std::vector<string> override {
+    std::vector<string> values;
+    for(auto value : _allowedValues) values.push_back(value);
    return values;
  }
  auto writeValue(string value) -> void override { setValue(value.real()); }

 protected:
-  function<void (f64)> _modify;
+  std::function<void (f64)> _modify;
  f64 _currentValue = {};
  f64 _latchedValue = {};
-  vector<f64> _allowedValues;
+  std::vector<f64> _allowedValues;
 };
@@ -12,12 +12,12 @@ struct Setting : Object {

  virtual auto readValue() const -> string { return {}; }
  virtual auto readLatch() const -> string { return {}; }
-  virtual auto readAllowedValues() const -> vector<string> { return {}; }
+  virtual auto readAllowedValues() const -> std::vector<string> { return {}; }
  virtual auto writeValue(string value) -> void {}

  auto load(Node::Object source) -> bool override {
    if(!Object::load(source)) return false;
-    if(auto setting = source->cast<shared_pointer<Setting>>()) writeValue(setting->readValue());
+    if(auto setting = source->cast<Node::Setting::Setting>()) writeValue(setting->readValue());
    return true;
  }

@@ -1,7 +1,7 @@
 struct String : Setting {
  DeclareClass(String, "setting.string")

-  String(string name = {}, string value = {}, function<void (string)> modify = {}) : Setting(name) {
+  String(string name = {}, string value = {}, std::function<void (string)> modify = {}) : Setting(name) {
    _currentValue = value;
    _latchedValue = value;
    _modify = modify;
@@ -11,10 +11,10 @@ struct String : Setting {
  auto value() const -> string { return _currentValue; }
  auto latch() const -> string { return _latchedValue; }

-  auto setModify(function<void (string)> modify) { _modify = modify; }
+  auto setModify(std::function<void (string)> modify) { _modify = modify; }

  auto setValue(string value) -> void {
-    if(_allowedValues && !_allowedValues.find(value)) return;
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, value)) return;
    _currentValue = value;
    if(_dynamic) setLatch();
  }
@@ -25,19 +25,19 @@ struct String : Setting {
    modify(_latchedValue);
  }

-  auto setAllowedValues(vector<string> allowedValues) -> void {
+  auto setAllowedValues(std::vector<string> allowedValues) -> void {
    _allowedValues = allowedValues;
-    if(_allowedValues && !_allowedValues.find(_currentValue)) setValue(_allowedValues.first());
+    if(!_allowedValues.empty() && !std::ranges::count(_allowedValues, _currentValue)) setValue(_allowedValues.front());
  }

  auto readValue() const -> string override { return value(); }
  auto readLatch() const -> string override { return latch(); }
-  auto readAllowedValues() const -> vector<string> override { return _allowedValues; }
+  auto readAllowedValues() const -> std::vector<string> override { return _allowedValues; }
  auto writeValue(string value) -> void override { setValue(value); }

 protected:
-  function<void (string)> _modify;
+  std::function<void (string)> _modify;
  string _currentValue = {};
  string _latchedValue = {};
-  vector<string> _allowedValues;
+  std::vector<string> _allowedValues;
 };
@@ -10,20 +10,20 @@ struct System : Object {
  auto serialize(bool synchronize = true) -> serializer { if(_serialize) return _serialize(synchronize); return {}; }
  auto unserialize(serializer& s) -> bool { if(_unserialize) return _unserialize(s); return false; }

-  auto setGame(function<string ()> game) -> void { _game = game; }
-  auto setRun(function<void ()> run) -> void { _run = run; }
-  auto setPower(function<void (bool)> power) -> void { _power = power; }
-  auto setSave(function<void ()> save) -> void { _save = save; }
-  auto setUnload(function<void ()> unload) -> void { _unload = unload; }
-  auto setSerialize(function<serializer (bool)> serialize) -> void { _serialize = serialize; }
-  auto setUnserialize(function<bool (serializer&)> unserialize) -> void { _unserialize = unserialize; }
+  auto setGame(std::function<string ()> game) -> void { _game = game; }
+  auto setRun(std::function<void ()> run) -> void { _run = run; }
+  auto setPower(std::function<void (bool)> power) -> void { _power = power; }
+  auto setSave(std::function<void ()> save) -> void { _save = save; }
+  auto setUnload(std::function<void ()> unload) -> void { _unload = unload; }
+  auto setSerialize(std::function<serializer (bool)> serialize) -> void { _serialize = serialize; }
+  auto setUnserialize(std::function<bool (serializer&)> unserialize) -> void { _unserialize = unserialize; }

 protected:
-  function<string ()> _game;
-  function<void ()> _run;
-  function<void (bool)> _power;
-  function<void ()> _save;
-  function<void ()> _unload;
-  function<serializer (bool)> _serialize;
-  function<bool (serializer&)> _unserialize;
+  std::function<string ()> _game;
+  std::function<void ()> _run;
+  std::function<void (bool)> _power;
+  std::function<void ()> _save;
+  std::function<void ()> _unload;
+  std::function<serializer (bool)> _serialize;
+  std::function<bool (serializer&)> _unserialize;
 };
@@ -0,0 +1,79 @@
+struct Tape : Peripheral {
+  DeclareClass(Tape, "tape") using Peripheral::Peripheral;
+
+  ~Tape() {
+    unload();
+  }
+
+  auto play() -> void { _playing = true; }
+  auto record() -> void { _recording = true; }
+  auto stop() -> void {
+    _playing = false;
+    _recording = false;
+  }
+
+  auto playing() const -> bool { return _playing; }
+  auto recording() const -> bool { return _recording; }
+
+  auto loaded() const -> bool { return _loaded; }
+  auto load() -> bool {
+    if (!_loaded && _load && _load()) {
+      _loaded = true;
+      return true;
+    }
+
+    return _loaded;
+  }
+  auto unload() -> void {
+    if (_loaded) {
+      stop();
+      if (_unload) _unload();
+      _loaded = false;
+    }
+  }
+
+  auto setLoad(std::function<bool()> load) -> void { _load = load; }
+  auto setUnload(std::function<void()> unload) -> void { _unload = unload; }
+
+  auto setSupportPlay(bool support) -> void { _supportPlay = support; }
+  auto setSupportRecord(bool support) -> void { _supportRecord = support; }
+
+  auto supportPlay() const -> bool { return _supportPlay; }
+  auto supportRecord() const -> bool { return _supportRecord; }
+
+  auto length() const -> u64 { return _length; }
+  auto setLength(u64 length) -> void { _length = length; }
+
+  auto position() const -> u64 { return _position; }
+  auto setPosition(u64 position) -> void { _position = position; }
+
+  auto frequency() const -> u64 { return _frequency; }
+  auto setFrequency(u64 frequency) -> void { _frequency = frequency; }
+
+  auto serialize(string &output, string depth) -> void override {
+    Peripheral::serialize(output, depth);
+    output.append(depth, "  supportPlay: ", _supportPlay, "\n");
+    output.append(depth, "  supportRecord: ", _supportRecord, "\n");
+    output.append(depth, "  playing: ", _playing, "\n");
+    output.append(depth, "  recording: ", _recording, "\n");
+  }
+  auto unserialize(Markup::Node node) -> void override {
+    Peripheral::unserialize(node);
+    _supportPlay = node["supportPlay"].boolean();
+    _supportRecord = node["supportRecord"].boolean();
+    _playing = node["playing"].boolean();
+    _recording = node["recording"].boolean();
+  }
+
+private:
+  bool _supportPlay = false;
+  bool _supportRecord = false;
+  bool _playing = false;
+  bool _recording = false;
+  bool _loaded = false;
+  u64 _length = 0;
+  u64 _position = 0;
+  u64 _frequency = 1;
+  std::function<bool()> _load;
+  std::function<void()> _unload;
+};
@@ -1,15 +1,18 @@
+#include <memory>
 Screen::Screen(string name, u32 width, u32 height) : Video(name) {
  _canvasWidth  = width;
  _canvasHeight = height;

  if(width && height) {
-    _inputA = new u32[width * height]();
-    _inputB = new u32[width * height]();
-    _output = new u32[width * height]();
-    _rotate = new u32[width * height]();
+    _inputA = std::make_unique<u32[]>(width * height);
+    _inputB = std::make_unique<u32[]>(width * height);
+    _output = std::make_unique<u32[]>(width * height);
+    _rotate = std::make_unique<u32[]>(width * height);
+    _lineOverrideActive.resize(width * height, false);
+    _lineOverride.resize(width * height, nullptr);

    if constexpr(ares::Video::Threaded) {
-      _thread = nall::thread::create({&Screen::main, this});
+      _thread = nall::thread::create(std::bind_front(&Screen::main, this));
    }
  }
 }
@@ -24,6 +27,7 @@ Screen::~Screen() {
 }

 auto Screen::main(uintptr_t) -> void {
+  thread::setName("dev.ares.screen");
  while(!_kill) {
    unique_lock<mutex> lock(_frameMutex);

@@ -40,34 +44,37 @@ auto Screen::main(uintptr_t) -> void {
 auto Screen::quit() -> void {
  _kill = true;
  _thread.join();
-  _sprites.reset();
+  _sprites.clear();
 }

 auto Screen::power() -> void {
  lock_guard<recursive_mutex> lock(_mutex);
-  memory::fill<u32>(_inputA.data(), _canvasWidth * _canvasHeight, _fillColor);
-  memory::fill<u32>(_inputB.data(), _canvasWidth * _canvasHeight, _fillColor);
-  memory::fill<u32>(_output.data(), _canvasWidth * _canvasHeight, _fillColor);
-  memory::fill<u32>(_rotate.data(), _canvasWidth * _canvasHeight, _fillColor);
+  memory::fill<u32>(_inputA.get(), _canvasWidth * _canvasHeight, _fillColor);
+  memory::fill<u32>(_inputB.get(), _canvasWidth * _canvasHeight, _fillColor);
+  memory::fill<u32>(_output.get(), _canvasWidth * _canvasHeight, _fillColor);
+  memory::fill<u32>(_rotate.get(), _canvasWidth * _canvasHeight, _fillColor);
+  memory::fill<n1>(_lineOverrideActive.data(), _canvasWidth * _canvasHeight, false);
+  memory::fill<const u32*>(_lineOverride.data(), _canvasWidth * _canvasHeight, nullptr);
 }

-auto Screen::pixels(bool frame) -> array_span<u32> {
-  if(frame == 0) return {_inputA.data(), _canvasWidth * _canvasHeight};
-  if(frame == 1) return {_inputB.data(), _canvasWidth * _canvasHeight};
+auto Screen::pixels(bool frame) -> std::span<u32> {
+  if(frame == 0) return {_inputA.get(), _canvasWidth * _canvasHeight};
+  if(frame == 1) return {_inputB.get(), _canvasWidth * _canvasHeight};
  return {};
 }

 auto Screen::resetPalette() -> void {
  lock_guard<recursive_mutex> lock(_mutex);
  _palette.reset();
+  refreshPalette();
 }

 auto Screen::resetSprites() -> void {
  lock_guard<recursive_mutex> lock(_mutex);
-  _sprites.reset();
+  _sprites.clear();
 }

-auto Screen::setRefresh(function<void ()> refresh) -> void {
+auto Screen::setRefresh(std::function<void ()> refresh) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
  _refresh = refresh;
 }
@@ -116,18 +123,21 @@ auto Screen::setSaturation(f64 saturation) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
  _saturation = saturation;
  _palette.reset();
+  refreshPalette();
 }

 auto Screen::setGamma(f64 gamma) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
  _gamma = gamma;
  _palette.reset();
+  refreshPalette();
 }

 auto Screen::setLuminance(f64 luminance) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
  _luminance = luminance;
  _palette.reset();
+  refreshPalette();
 }

 auto Screen::setFillColor(u32 fillColor) -> void {
@@ -171,21 +181,22 @@ auto Screen::setInterlace(bool interlaceField) -> void {

 auto Screen::attach(Node::Video::Sprite sprite) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
-  if(_sprites.find(sprite)) return;
-  _sprites.append(sprite);
+  if(std::ranges::find(_sprites, sprite) != _sprites.end()) return;
+  _sprites.push_back(sprite);
 }

 auto Screen::detach(Node::Video::Sprite sprite) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
-  if(!_sprites.find(sprite)) return;
-  _sprites.removeByValue(sprite);
+  if(std::ranges::find(_sprites, sprite) == _sprites.end()) return;
+  std::erase(_sprites, sprite);
 }

-auto Screen::colors(u32 colors, function<n64 (n32)> color) -> void {
+auto Screen::colors(u32 colors, std::function<n64 (n32)> color) -> void {
  lock_guard<recursive_mutex> lock(_mutex);
  _colors = colors;
  _color = color;
  _palette.reset();
+  refreshPalette();
 }

 auto Screen::frame() -> void {
@@ -218,14 +229,20 @@ auto Screen::refresh() -> void {
  auto pitch  = _canvasWidth;
  auto width  = _canvasWidth;
  auto height = _canvasHeight;
-  auto input  = _inputB.data();
-  auto output = _output.data();
+  auto input  = _inputB.get();
+  auto output = _output.get();

  for(u32 y : range(height)) {
    auto source = input  + y * pitch;
    auto target = output + y * width;

-    if(_interlace) {
+    if (_lineOverrideActive[y]) {
+      auto source = _lineOverride[y];
+      for(u32 x : range(width)) {
+        auto color = *source++;
+        *target++ = color;
+      }
+    } else if(_interlace) {
      if((_interlaceField & 1) == (y & 1)) {
        for(u32 x : range(width)) {
          auto color = _palette[*source++];
@@ -294,11 +311,11 @@ auto Screen::refresh() -> void {
    for(u32 y : range(height)) {
      auto source = output + y * width;
      for(u32 x : range(width)) {
-        auto target = _rotate.data() + (width - 1 - x) * height + y;
+        auto target = _rotate.get() + (width - 1 - x) * height + y;
        *target = *source++;
      }
    }
-    output = _rotate.data();
+    output = _rotate.get();
    swap(width, height);
    swap(viewWidth, viewHeight);
  }
@@ -308,11 +325,11 @@ auto Screen::refresh() -> void {
    for(u32 y : range(height)) {
      auto source = output + y * width;
      for(u32 x : range(width)) {
-        auto target = _rotate.data() + (height - 1 - y) * width + (width - 1 - x);
+        auto target = _rotate.get() + (height - 1 - y) * width + (width - 1 - x);
        *target = *source++;
      }
    }
-    output = _rotate.data();
+    output = _rotate.get();
  }

  if(_rotation == 270) {
@@ -320,17 +337,31 @@ auto Screen::refresh() -> void {
    for(u32 y : range(height)) {
      auto source = output + y * width;
      for(u32 x : range(width)) {
-        auto target = _rotate.data() + x * height + (height - 1 - y);
+        auto target = _rotate.get() + x * height + (height - 1 - y);
        *target = *source++;
      }
    }
-    output = _rotate.data();
+    output = _rotate.get();
    swap(width, height);
    swap(viewWidth, viewHeight);
  }

-  platform->video(shared(), output + viewX + viewY * width, width * sizeof(u32), viewWidth, viewHeight);
-  memory::fill<u32>(_inputB.data(), width * height, _fillColor);
+  platform->video(std::static_pointer_cast<Core::Video::Screen>(shared_from_this()), output + viewX + viewY * width, width * sizeof(u32), viewWidth, viewHeight);
+  memory::fill<u32>(_inputB.get(), width * height, _fillColor);
+}
+
+auto Screen::lookupPalette(u32 index) -> u32 {
+  return _palette[index];
+}
+
+auto Screen::overrideLineDraw(u32 y, const u32* source) -> void {
+  _lineOverride[y] = source;
+  _lineOverrideActive[y] = true;
+}
+
+auto Screen::clearOverrideLineDraw(u32 y) -> void {
+  _lineOverrideActive[y] = false;
+  _lineOverride[y] = nullptr;
 }

 auto Screen::refreshPalette() -> void {
@@ -338,7 +369,7 @@ auto Screen::refreshPalette() -> void {
  if(_palette) return;

  //generate the color lookup palettes to convert native colors to ARGB8888
-  _palette = new u32[_colors];
+  _palette = std::make_unique<u32[]>(_colors);
  for(u32 index : range(_colors)) {
    n64 color = _color(index);
    n16 b = color.bit( 0,15);
@@ -348,10 +379,9 @@ auto Screen::refreshPalette() -> void {

    if(_saturation != 1.0) {
      n16 grayscale = uclamp<16>((r + g + b) / 3);
-      f64 inverse = max(0.0, 1.0 - _saturation);
-      r = uclamp<16>(r * _saturation + grayscale * inverse);
-      g = uclamp<16>(g * _saturation + grayscale * inverse);
-      b = uclamp<16>(b * _saturation + grayscale * inverse);
+      r = uclamp<16>(grayscale + (r - grayscale) * _saturation);
+      g = uclamp<16>(grayscale + (g - grayscale) * _saturation);
+      b = uclamp<16>(grayscale + (b - grayscale) * _saturation);
    }

    if(_gamma != 1.0) {
@@ -18,7 +18,7 @@ struct Screen : Video {
  auto aspectY() const -> f64 { return _aspectY; }
  auto overscan() const -> bool { return _overscan; }
  auto colors() const -> u32 { return _colors; }
-  auto pixels(bool frame = 0) -> array_span<u32>;
+  auto pixels(bool frame = 0) -> std::span<u32>;

  auto saturation() const -> double { return _saturation; }
  auto gamma() const -> double { return _gamma; }
@@ -32,7 +32,7 @@ struct Screen : Video {
  auto resetPalette() -> void;
  auto resetSprites() -> void;

-  auto setRefresh(function<void ()> refresh) -> void;
+  auto setRefresh(std::function<void ()> refresh) -> void;
  auto setViewport(u32 x, u32 y, u32 width, u32 height) -> void;
  auto refreshRateHint(double refreshRate) -> void;
  auto refreshRateHint(double pixelFrequency, int dotsPerLine, int linesPerFrame) -> void;
@@ -58,9 +58,12 @@ struct Screen : Video {
  auto attach(Node::Video::Sprite) -> void;
  auto detach(Node::Video::Sprite) -> void;

-  auto colors(u32 colors, function<n64 (n32)> color) -> void;
+  auto colors(u32 colors, std::function<n64 (n32)> color) -> void;
  auto frame() -> void;
  auto refresh() -> void;
+  auto lookupPalette(u32 index) -> u32;
+  auto overrideLineDraw(u32 y, const u32* source) -> void;
+  auto clearOverrideLineDraw(u32 y) -> void;

  auto serialize(string& output, string depth) -> void override;
  auto unserialize(Markup::Node node) -> void override;
@@ -88,13 +91,15 @@ protected:
  bool _overscan = true;
  u32  _rotation = 0;  //counter-clockwise (90 = left, 270 = right)

-  function<n64 (n32)> _color;
-  unique_pointer<u32[]> _inputA;
-  unique_pointer<u32[]> _inputB;
-  unique_pointer<u32[]> _output;
-  unique_pointer<u32[]> _rotate;
-  unique_pointer<u32[]> _palette;
-  vector<Node::Video::Sprite> _sprites;
+  std::function<n64 (n32)> _color;
+  std::unique_ptr<u32[]> _inputA;
+  std::unique_ptr<u32[]> _inputB;
+  std::unique_ptr<u32[]> _output;
+  std::unique_ptr<u32[]> _rotate;
+  std::unique_ptr<u32[]> _palette;
+  std::vector<n1> _lineOverrideActive;
+  std::vector<const u32*> _lineOverride;
+  std::vector<Node::Video::Sprite> _sprites;

 //unserialized:
  nall::thread _thread;
@@ -103,7 +108,7 @@ protected:
  condition_variable _frameCondition;
  atomic<bool> _kill = false;
  atomic<bool> _frame = false;
-  function<void ()> _refresh;
+  std::function<void ()> _refresh;
  bool _progressive = false;
  bool _progressiveDouble = false;
  bool _interlace = false;
@@ -10,13 +10,13 @@ auto Sprite::setPosition(u32 x, u32 y) -> void {
 auto Sprite::setImage(nall::image image, bool invert) -> void {
  _width = image.width();
  _height = image.height();
-  _pixels = new u32[_width * _height];
+  _pixels = std::make_unique<u32[]>(_width * _height);
  image.transform(0, 32, 255u << 24, 255u << 16, 255u << 8, 255u << 0);
-  memory::copy(_pixels.data(), _width * _height * sizeof(u32), image.data(), image.size());
+  memory::copy(_pixels.get(), _width * _height * sizeof(u32), image.data(), image.size());
  if(!invert) return;

  for(u32 y : range(_height)) {
-    auto data = _pixels.data() + y * _width;
+    auto data = _pixels.get() + y * _width;
    for(u32 x : range(_width)) {
      auto pixel = data[x];
      pixel ^= 0xffffff;
@@ -7,7 +7,7 @@ struct Sprite : Video {
  auto y() const -> u32 { return _y; }
  auto width() const -> u32 { return _width; }
  auto height() const -> u32 { return _height; }
-  auto image() const -> array_view<u32> { return {_pixels.data(), _width * _height}; }
+  auto image() const -> std::span<const u32> { return {_pixels.get(), _width * _height}; }

  auto setVisible(bool visible) -> void;
  auto setPosition(u32 x, u32 y) -> void;
@@ -19,5 +19,5 @@ protected:
  u32  _y = 0;
  u32  _width = 0;
  u32  _height = 0;
-  unique_pointer<u32[]> _pixels;
+  std::unique_ptr<u32[]> _pixels;
 };
@@ -8,12 +8,15 @@ enum class Event : u32 {
  Frame,
  Power,
  Synchronize,
+  FastForwardOn,
+  FastForwardOff,
+  Shutdown
 };

 struct Platform {
  virtual auto attach(Node::Object) -> void {}
  virtual auto detach(Node::Object) -> void {}
-  virtual auto pak(Node::Object) -> shared_pointer<vfs::directory> { return {}; }
+  virtual auto pak(Node::Object) -> std::shared_ptr<vfs::directory> { return {}; }
  virtual auto event(Event) -> void {}
  virtual auto log(Node::Debugger::Tracer::Tracer, string_view message) -> void {}
  virtual auto status(string_view message) -> void {}
@@ -4,6 +4,9 @@ namespace ares {

 struct Random {
  enum class Entropy : u32 { None, Low, High };
+  struct Init { u64 seed, sequence; };
+
+  static constexpr Init Default { 0x853c49e6748fea9b, 0xda3e39cb94b95bdb };

  auto operator()() -> n64 {
    return random();
@@ -14,8 +17,8 @@ struct Random {
    seed();
  }

-  auto seed(maybe<n32> seed = nothing, maybe<n32> sequence = nothing) -> void {
-    if(!seed) seed = (n32)clock();
+  auto seed(maybe<n64> seed = nothing, maybe<n64> sequence = nothing) -> void {
+    if(!seed) seed = (n64)clock();
    if(!sequence) sequence = 0;

    _state = 0;
@@ -25,6 +28,10 @@ struct Random {
    step();
  }

+  auto seed(Init init) -> void {
+    seed((n64)init.seed, (n64)init.sequence);
+  }
+
  auto random() -> n64 {
    if(_entropy == Entropy::None) return 0;
    return (n64)step() << 32 | (n64)step() << 0;
@@ -43,15 +50,16 @@ struct Random {
    }
  }

-  auto array(array_span<n8> buffer) -> void {
+  auto array(std::span<u8> buffer) -> void {
    if(_entropy == Entropy::None) {
      memory::fill(buffer.data(), buffer.size());
      return;
    }

    if(_entropy == Entropy::High) {
-      for(n32 address : range(buffer.size())) {
-        buffer[address] = random();
+      while(buffer.size()) {
+        u64 value = random();
+        nall::writel(buffer, value, min((u32)sizeof(value), (u32)buffer.size())); 
      }
      return;
    }
@@ -1,10 +0,0 @@
-build := stable
-nall.path := ../../../nall
-include $(nall.path)/GNUmakefile
-
-all:
-	sourcery resource.bml resource.cpp resource.hpp
-
-clean:
-	$(call delete,resource.cpp)
-	$(call delete,resource.hpp)
@@ -1,34 +0,0 @@
-namespace Resource {
-namespace Ares {
-extern const unsigned char Icon1x[6562];
-extern const unsigned char Icon2x[9662];
-extern const unsigned char Logo1x[11533];
-extern const unsigned char Logo2x[18991];
-}
-namespace Sprite {
-namespace SuperFamicom {
-extern const unsigned char CrosshairBlue[332];
-extern const unsigned char CrosshairGreen[329];
-extern const unsigned char CrosshairRed[342];
-}
-namespace WonderSwan {
-extern const unsigned char Auxiliary0[117];
-extern const unsigned char Auxiliary1[134];
-extern const unsigned char Auxiliary2[136];
-extern const unsigned char Headphones[167];
-extern const unsigned char Initialized[136];
-extern const unsigned char LowBattery[144];
-extern const unsigned char Orientation0[148];
-extern const unsigned char Orientation1[150];
-extern const unsigned char PoweredOn[155];
-extern const unsigned char Sleeping[154];
-extern const unsigned char VolumeA0[129];
-extern const unsigned char VolumeA1[142];
-extern const unsigned char VolumeA2[146];
-extern const unsigned char VolumeB0[125];
-extern const unsigned char VolumeB1[137];
-extern const unsigned char VolumeB2[148];
-extern const unsigned char VolumeB3[153];
-}
-}
-}
@@ -1,5 +1,5 @@
 inline auto Scheduler::reset() -> void {
-  _threads.reset();
+  _threads.clear();
 }

 inline auto Scheduler::threads() const -> u32 {
@@ -41,15 +41,15 @@ inline auto Scheduler::maximum() const -> u64 {
 }

 inline auto Scheduler::append(Thread& thread) -> bool {
-  if(_threads.find(&thread)) return false;
+  if(std::ranges::find(_threads, &thread) != _threads.end()) return false;
  thread._uniqueID = uniqueID();
  thread._clock = maximum() + thread._uniqueID;
-  _threads.append(&thread);
+  _threads.push_back(&thread);
  return true;
 }

 inline auto Scheduler::remove(Thread& thread) -> void {
-  _threads.removeByValue(&thread);
+  std::erase(_threads, &thread);
 }

 //power cycle and soft reset events: assigns the primary thread and resets all thread clocks.
@@ -38,7 +38,7 @@ private:
  cothread_t _primary = nullptr;  //primary thread (used to synchronize components)
  Mode _mode = Mode::Run;
  Event _event = Event::Step;
-  vector<Thread*> _threads;
+  std::vector<Thread*> _threads;
  bool _synchronize = false;

  friend struct Thread;
@@ -1,5 +1,5 @@
-inline auto Thread::EntryPoints() -> vector<EntryPoint>& {
-  static vector<EntryPoint> entryPoints;
+inline auto Thread::EntryPoints() -> std::vector<EntryPoint>& {
+  static std::vector<EntryPoint> entryPoints;
  return entryPoints;
 }

@@ -7,7 +7,7 @@ inline auto Thread::Enter() -> void {
  for(u32 index : range(EntryPoints().size())) {
    if(co_active() == EntryPoints()[index].handle) {
      auto entryPoint = EntryPoints()[index].entryPoint;
-      EntryPoints().remove(index);
+      EntryPoints().erase(EntryPoints().begin() + index);
      while(true) {
        scheduler.synchronize();
        entryPoint();
@@ -45,22 +45,22 @@ inline auto Thread::setClock(u64 clock) -> void {
  _clock = clock;
 }

-inline auto Thread::create(double frequency, function<void ()> entryPoint) -> void {
+inline auto Thread::create(double frequency, std::function<void ()> entryPoint) -> void {
  if(!_handle) {
    _handle = co_create(Thread::Size, &Thread::Enter);
  } else {
    co_derive(_handle, Thread::Size, &Thread::Enter);
  }
-  EntryPoints().append({_handle, entryPoint});
+  EntryPoints().push_back({_handle, entryPoint});
  setFrequency(frequency);
  setClock(0);
  scheduler.append(*this);
 }

 //returns a thread to its entry point (eg for a reset), without resetting the clock value
-inline auto Thread::restart(function<void()> entryPoint) -> void {
+inline auto Thread::restart(std::function<void()> entryPoint) -> void {
  co_derive(_handle, Thread::Size, &Thread::Enter);
-  EntryPoints().append({_handle, entryPoint});
+  EntryPoints().push_back({_handle, entryPoint});
 }

 inline auto Thread::destroy() -> void {
@@ -6,10 +6,10 @@ struct Thread {

  struct EntryPoint {
    cothread_t handle = nullptr;
-    function<void ()> entryPoint;
+    std::function<void ()> entryPoint;
  };

-  static auto EntryPoints() -> vector<EntryPoint>&;
+  static auto EntryPoints() -> std::vector<EntryPoint>&;
  static auto Enter() -> void;

  Thread() = default;
@@ -29,8 +29,8 @@ struct Thread {
  auto setScalar(u64 scalar) -> void;
  auto setClock(u64 clock) -> void;

-  auto create(double frequency, function<void ()> entryPoint) -> void;
-  auto restart(function<void ()> entryPoint) -> void;
+  auto create(double frequency, std::function<void ()> entryPoint) -> void;
+  auto restart(std::function<void ()> entryPoint) -> void;
  auto destroy() -> void;

  auto step(u32 clocks) -> void;
@@ -1,5 +1,9 @@
 list(REMOVE_DUPLICATES ares.components)

+set(ARES_COMPONENTS_LIST "${ares.components}" CACHE STRING "Enabled shared hardware components" FORCE)
+
+mark_as_advanced(ARES_COMPONENTS_LIST)
+
 ares_add_sources(INCLUDED CMakeLists.txt)

 macro(component_sources)
@@ -134,6 +138,7 @@ component_sources(
  INCLUDED
    processor/arm7tdmi/algorithms.cpp
    processor/arm7tdmi/arm7tdmi.hpp
+    processor/arm7tdmi/coprocessor.cpp
    processor/arm7tdmi/disassembler.cpp
    processor/arm7tdmi/instruction.cpp
    processor/arm7tdmi/instructions-arm.cpp
@@ -432,6 +437,16 @@ component_sources(
    processor/z80/z80.hpp
 )

+component_sources(
+  COMPONENT
+    s3511a
+  PRIMARY
+    rtc/s3511a/s3511a.cpp
+  INCLUDED
+    rtc/s3511a/s3511a.hpp
+    rtc/s3511a/serialization.cpp
+)
+
 component_sources(
  COMPONENT
    sst39sf0x0
@@ -1,76 +0,0 @@
-ares.components := $(call unique,$(ares.components))
-
-ares.objects += $(if $(findstring ay38910,$(ares.components)),ares-audio-ay38910)
-ares.objects += $(if $(findstring msm5205,$(ares.components)),ares-audio-msm5205)
-ares.objects += $(if $(findstring sn76489,$(ares.components)),ares-audio-sn76489)
-ares.objects += $(if $(findstring t6w28,$(ares.components)),ares-audio-t6w28)
-ares.objects += $(if $(findstring ym2149,$(ares.components)),ares-audio-ym2149)
-ares.objects += $(if $(findstring ym2413,$(ares.components)),ares-audio-ym2413)
-ares.objects += $(if $(findstring ym2610,$(ares.components)),ares-audio-ym2610)
-ares.objects += $(if $(findstring ym2612,$(ares.components)),ares-audio-ym2612)
-
-ares.objects += $(if $(findstring m24c,$(ares.components)),ares-eeprom-m24c)
-ares.objects += $(if $(findstring m93lcx6,$(ares.components)),ares-eeprom-m93lcx6)
-
-ares.objects += $(if $(findstring i8255,$(ares.components)),ares-io-i8255)
-
-ares.objects += $(if $(findstring arm7tdmi,$(ares.components)),ares-processor-arm7tdmi)
-ares.objects += $(if $(findstring gsu,$(ares.components)),ares-processor-gsu)
-ares.objects += $(if $(findstring hg51b,$(ares.components)),ares-processor-hg51b)
-ares.objects += $(if $(findstring huc6280,$(ares.components)),ares-processor-huc6280)
-ares.objects += $(if $(findstring i8080,$(ares.components)),ares-processor-i8080)
-ares.objects += $(if $(findstring m68hc05,$(ares.components)),ares-processor-m68hc05)
-ares.objects += $(if $(findstring m68000,$(ares.components)),ares-processor-m68000)
-ares.objects += $(if $(findstring mos6502,$(ares.components)),ares-processor-mos6502)
-ares.objects += $(if $(findstring sh2,$(ares.components)),ares-processor-sh2)
-ares.objects += $(if $(findstring sm5k,$(ares.components)),ares-processor-sm5k)
-ares.objects += $(if $(findstring sm83,$(ares.components)),ares-processor-sm83)
-ares.objects += $(if $(findstring spc700,$(ares.components)),ares-processor-spc700)
-ares.objects += $(if $(findstring ssp1601,$(ares.components)),ares-processor-ssp1601)
-ares.objects += $(if $(findstring tlcs900h,$(ares.components)),ares-processor-tlcs900h)
-ares.objects += $(if $(findstring upd96050,$(ares.components)),ares-processor-upd96050)
-ares.objects += $(if $(findstring v30mz,$(ares.components)),ares-processor-v30mz)
-ares.objects += $(if $(findstring wdc65816,$(ares.components)),ares-processor-wdc65816)
-ares.objects += $(if $(findstring z80,$(ares.components)),ares-processor-z80)
-
-ares.objects += $(if $(findstring sst39sf0x0,$(ares.components)),ares-flash-sst39sf0x0)
-
-ares.objects += $(if $(findstring tms9918,$(ares.components)),ares-video-tms9918)
-ares.objects += $(if $(findstring v9938,$(ares.components)),ares-video-v9938)
-
-$(object.path)/ares-audio-ay38910.o:      $(ares.path)/component/audio/ay38910/ay38910.cpp
-$(object.path)/ares-audio-msm5205.o:      $(ares.path)/component/audio/msm5205/msm5205.cpp
-$(object.path)/ares-audio-sn76489.o:      $(ares.path)/component/audio/sn76489/sn76489.cpp
-$(object.path)/ares-audio-t6w28.o:        $(ares.path)/component/audio/t6w28/t6w28.cpp
-$(object.path)/ares-audio-ym2149.o:       $(ares.path)/component/audio/ym2149/ym2149.cpp
-$(object.path)/ares-audio-ym2413.o:       $(ares.path)/component/audio/ym2413/ym2413.cpp
-$(object.path)/ares-audio-ym2612.o:       $(ares.path)/component/audio/ym2612/ym2612.cpp
-
-$(object.path)/ares-eeprom-m24c.o:        $(ares.path)/component/eeprom/m24c/m24c.cpp
-$(object.path)/ares-eeprom-m93lcx6.o:     $(ares.path)/component/eeprom/m93lcx6/m93lcx6.cpp
-
-$(object.path)/ares-io-i8255.o:    		  $(ares.path)/component/io/i8255/i8255.cpp
-
-$(object.path)/ares-processor-arm7tdmi.o: $(ares.path)/component/processor/arm7tdmi/arm7tdmi.cpp
-$(object.path)/ares-processor-gsu.o:      $(ares.path)/component/processor/gsu/gsu.cpp
-$(object.path)/ares-processor-hg51b.o:    $(ares.path)/component/processor/hg51b/hg51b.cpp
-$(object.path)/ares-processor-huc6280.o:  $(ares.path)/component/processor/huc6280/huc6280.cpp
-$(object.path)/ares-processor-i8080.o:    $(ares.path)/component/processor/i8080/i8080.cpp
-$(object.path)/ares-processor-m68hc05.o:  $(ares.path)/component/processor/m68hc05/m68hc05.cpp
-$(object.path)/ares-processor-m68000.o:   $(ares.path)/component/processor/m68000/m68000.cpp
-$(object.path)/ares-processor-mos6502.o:  $(ares.path)/component/processor/mos6502/mos6502.cpp
-$(object.path)/ares-processor-sh2.o:      $(ares.path)/component/processor/sh2/sh2.cpp
-$(object.path)/ares-processor-sm5k.o:     $(ares.path)/component/processor/sm5k/sm5k.cpp
-$(object.path)/ares-processor-sm83.o:     $(ares.path)/component/processor/sm83/sm83.cpp
-$(object.path)/ares-processor-spc700.o:   $(ares.path)/component/processor/spc700/spc700.cpp
-$(object.path)/ares-processor-ssp1601.o:  $(ares.path)/component/processor/ssp1601/ssp1601.cpp
-$(object.path)/ares-processor-tlcs900h.o: $(ares.path)/component/processor/tlcs900h/tlcs900h.cpp
-$(object.path)/ares-processor-upd96050.o: $(ares.path)/component/processor/upd96050/upd96050.cpp
-$(object.path)/ares-processor-v30mz.o:    $(ares.path)/component/processor/v30mz/v30mz.cpp
-$(object.path)/ares-processor-wdc65816.o: $(ares.path)/component/processor/wdc65816/wdc65816.cpp
-$(object.path)/ares-processor-z80.o:      $(ares.path)/component/processor/z80/z80.cpp
-
-$(object.path)/ares-flash-sst39sf0x0.o:   $(ares.path)/component/flash/sst39sf0x0/sst39sf0x0.cpp
-
-$(object.path)/ares-video-tms9918.o:      $(ares.path)/component/video/tms9918/tms9918.cpp
-$(object.path)/ares-video-v9938.o:        $(ares.path)/component/video/v9938/v9938.cpp
@@ -135,10 +135,10 @@ auto YM2149::read() -> n8 {
    data.bit(4,7) = envelope.unused;
    break;
  case 14:
-    data.bit(0,7) = portA.data;
+    data.bit(0,7) = readIO(0);
    break;
  case 15:
-    data.bit(0,7) = portB.data;
+    data.bit(0,7) = readIO(1);
    break;
  }

@@ -215,9 +215,11 @@ auto YM2149::write(n8 data) -> void {
    break;
  case 14:
    portA.data = data;
+    writeIO(0, data);
    break;
  case 15:
    portB.data = data;
+    writeIO(1, data);
    break;
  }
 }
@@ -5,6 +5,9 @@ namespace ares {
 //Yamaha YM2149 (General Instrument AY-3-8910 derivative)

 struct YM2149 {
+  virtual auto readIO(n1 port) -> n8 { return 0xff; }
+  virtual auto writeIO(n1 port, n8 data) -> void {}
+
  //ym2149.cpp
  auto clock() -> array<n5[3]>;
  auto read() -> n8;
@@ -125,7 +125,7 @@ auto YM2612::Channel::Operator::updatePhase() -> void {

 auto YM2612::Channel::Operator::updateLevel() -> void {
  u32 lfo = ym2612.lfo.clock & 0x40 ? ym2612.lfo.clock & 0x3f : ~ym2612.lfo.clock & 0x3f;
-  u32 depth = tremolos[channel.tremolo];
+  u32 depth = tremolos[tremoloEnable * channel.tremolo];

  bool invert = ssg.attack != ssg.invert && envelope.state != Release;
  n10 value = ssg.enable && invert ? 0x200 - envelope.value : 0 + envelope.value;
@@ -147,7 +147,7 @@ auto YM2612::Channel::power() -> void {
  for(auto& op : operators) {
    op.keyOn = 0;
    op.keyLine = 0;
-    op.lfoEnable = 0;
+    op.tremoloEnable = 0;
    op.keyScale = 0;
    op.detune = 0;
    op.multiple = 0;
@@ -36,18 +36,14 @@ auto YM2612::writeData(n8 data) -> void {
  //timer B period
  case 0x026: {
    timerB.period.bit(0,7) = data.bit(0,7);
+    // Not sure if this is the right place for it, but...
+    // handle a specific use case to reset the subticks on timer B
+    if(!timerB.enable) timerB.divider = 0;
    break;
  }

  //timer control
  case 0x027: {
-    //reload period on 0->1 transition
-    if(!timerA.enable && data.bit(0)) timerA.counter = timerA.period;
-    if(!timerB.enable && data.bit(1)) {
-      timerB.counter = timerB.period;
-      timerB.divider = 0;
-    }
-
    timerA.enable = data.bit(0);
    timerB.enable = data.bit(1);
    timerA.irq = data.bit(2);
@@ -125,10 +121,10 @@ auto YM2612::writeData(n8 data) -> void {
    break;
  }

-  //LFO enable, decay rate
+  //LFO AM enable, decay rate
  case 0x060: {
    op.envelope.decayRate = data.bit(0,4);
-    op.lfoEnable = data.bit(7);
+    op.tremoloEnable = data.bit(7);
    channel[index].updateEnvelope();
    channel[index].updateLevel();
    break;
@@ -13,12 +13,14 @@ auto YM2612::serialize(serializer& s) -> void {
  s(envelope.divider);

  s(timerA.enable);
+  s(timerA.enableLatch);
  s(timerA.irq);
  s(timerA.line);
  s(timerA.period);
  s(timerA.counter);

  s(timerB.enable);
+  s(timerB.enableLatch);
  s(timerB.irq);
  s(timerB.line);
  s(timerB.period);
@@ -43,7 +45,7 @@ auto YM2612::Channel::serialize(serializer& s) -> void {
 auto YM2612::Channel::Operator::serialize(serializer& s) -> void {
  s(keyOn);
  s(keyLine);
-  s(lfoEnable);
+  s(tremoloEnable);
  s(keyScale);
  s(detune);
  s(multiple);
@@ -1,16 +1,15 @@
 auto YM2612::TimerA::run() -> void {
-  if(!enable) return;
-  if(++counter) return;
-
-  counter = period;
-  line |= irq;
+  if(!++counter)
+    line |= irq & enableLatch;
+  if(enableLatch < enable || !counter)
+    counter = period;
+  enableLatch = enable;
 }

 auto YM2612::TimerB::run() -> void {
-  if(!enable) return;
-  if(++divider) return;
-  if(++counter) return;
-
-  counter = period;
-  line |= irq;
+  if(!++divider && !++counter)
+    line |= irq & enableLatch;
+  if(enableLatch < enable || !counter && !divider)
+    counter = period; // do not reset divider on reenable
+  enableLatch = enable;
 }
@@ -45,6 +45,7 @@ protected:
    auto run() -> void;

    n1  enable = 0;
+    n1  enableLatch = 0;
    n1  irq = 0;
    n1  line = 0;
    n10 period = 0;
@@ -56,6 +57,7 @@ protected:
    auto run() -> void;

    n1 enable = 0;
+    n1 enableLatch = 0;
    n1 irq = 0;
    n1 line = 0;
    n8 period = 0;
@@ -106,7 +108,7 @@ protected:

      n1 keyOn = 0;
      n1 keyLine = 0;
-      n1 lfoEnable = 0;
+      n1 tremoloEnable = 0;
      n5 keyScale = 0;
      n3 detune = 0;
      n4 multiple = 0;
@@ -15,7 +15,7 @@ auto M24C::serialize(serializer& s) -> void {
  s(output);
  s(response);
  s(writable);
-  s(array_span<u8>{memory, size()});
+  s(std::span<n8>{memory, size()});
  if(type >= Type::M24C32) s(idpage);
  s(locked);
 }
@@ -9,7 +9,6 @@ namespace ares {
    io.portCHigherInput = 1;
    io.portAInput = 1;
    io.groupAMode = 0;
-    io.ioMode = 0;
    state.portA = 0xff;
    state.portB = 0xff;
    state.portC = 0xff;
@@ -43,15 +42,20 @@ namespace ares {
  }

  auto I8255::writeControl(n8 data) -> void {
+    if(data.bit(7) == 0) {
+      n3 bitSelect = data.bit(1, 3);
+      state.portC.bit(bitSelect) = data.bit(0);
+      writePortC(state.portC);
+      return;
+    }
+
    io.portCLowerInput  = data.bit(0);
    io.portBInput       = data.bit(1);
    io.groupBMode       = data.bit(2);
    io.portCHigherInput = data.bit(3);
    io.portAInput       = data.bit(4);
    io.groupAMode       = data.bit(5,6);
-    io.ioMode           = data.bit(7);

-    if(!io.ioMode) debug(unimplemented, "[I8255] BSR Mode");
    if(io.groupAMode != 0) debug(unimplemented, "[I8255] Group A Mode != 0");
    if(io.groupBMode != 0) debug(unimplemented, "[I8255] Group B Mode != 0");
  }
@@ -63,7 +67,6 @@ namespace ares {
    s(io.portCHigherInput);
    s(io.portAInput);
    s(io.groupAMode);
-    s(io.ioMode);

    s(state.portA);
    s(state.portB);
@@ -23,7 +23,6 @@ namespace ares {
      n1 portCHigherInput;
      n1 portAInput;
      n2 groupAMode;
-      n1 ioMode;
    } io;

    struct State {
@@ -9,6 +9,7 @@ namespace ares {
 #include "instruction.cpp"
 #include "instructions-arm.cpp"
 #include "instructions-thumb.cpp"
+#include "coprocessor.cpp"
 #include "serialization.cpp"
 #include "disassembler.cpp"

@@ -19,7 +20,9 @@ ARM7TDMI::ARM7TDMI() {

 auto ARM7TDMI::power() -> void {
  processor = {};
-  processor.r15.modify = [&] { pipeline.reload = true; };
+  processor.r15.modify = [&] { processor.r15.data &= ~1; pipeline.reload = true; };
+  processor.rNULL.modify = [&] { processor.rNULL.data = 0; };
+  processor.spsrNULL.readonly = true;
  pipeline = {};
  carry = 0;
  irq = 0;
@@ -6,15 +6,13 @@ namespace ares {

 struct ARM7TDMI {
  enum : u32 {
-    Nonsequential = 1 << 0,  //N cycle
-    Sequential    = 1 << 1,  //S cycle
+    Load          = 1 << 0,  //load operation
+    Store         = 1 << 1,  //store operation
    Prefetch      = 1 << 2,  //instruction fetch
    Byte          = 1 << 3,  // 8-bit access
    Half          = 1 << 4,  //16-bit access
    Word          = 1 << 5,  //32-bit access
-    Load          = 1 << 6,  //load operation
-    Store         = 1 << 7,  //store operation
-    Signed        = 1 << 8,  //sign-extend
+    Signed        = 1 << 6,  //sign-extend
  };

  virtual auto step(u32 clocks) -> void = 0;
@@ -44,6 +42,7 @@ struct ARM7TDMI {
  auto load(u32 mode, n32 address) -> n32;
  auto write(u32 mode, n32 address, n32 word) -> void;
  auto store(u32 mode, n32 address, n32 word) -> void;
+  auto endBurst() -> void { nonsequential = true; return; }

  //algorithms.cpp
  auto ADD(n32, n32, bool) -> n32;
@@ -70,21 +69,25 @@ struct ARM7TDMI {
  auto armMoveToStatus(n4 field, n1 source, n32 data) -> void;

  auto armInstructionBranch(i24, n1) -> void;
-  auto armInstructionBranchExchangeRegister(n4) -> void;
+  auto armInstructionBranchExchangeRegister(n4, n4, n4, n1) -> void;
+  auto armInstructionCoprocessorDataProcessing(n4, n3, n4, n4, n4, n4) -> void;
  auto armInstructionDataImmediate(n8, n4, n4, n4, n1, n4) -> void;
  auto armInstructionDataImmediateShift(n4, n2, n5, n4, n4, n1, n4) -> void;
  auto armInstructionDataRegisterShift(n4, n2, n4, n4, n4, n1, n4) -> void;
-  auto armInstructionLoadImmediate(n8, n1, n4, n4, n1, n1, n1) -> void;
-  auto armInstructionLoadRegister(n4, n1, n4, n4, n1, n1, n1) -> void;
  auto armInstructionMemorySwap(n4, n4, n4, n1) -> void;
  auto armInstructionMoveHalfImmediate(n8, n4, n4, n1, n1, n1, n1) -> void;
  auto armInstructionMoveHalfRegister(n4, n4, n4, n1, n1, n1, n1) -> void;
  auto armInstructionMoveImmediateOffset(n12, n4, n4, n1, n1, n1, n1, n1) -> void;
  auto armInstructionMoveMultiple(n16, n4, n1, n1, n1, n1, n1) -> void;
  auto armInstructionMoveRegisterOffset(n4, n2, n5, n4, n4, n1, n1, n1, n1, n1) -> void;
+  auto armInstructionMoveSignedImmediate(n8, n1, n4, n4, n1, n1, n1, n1) -> void;
+  auto armInstructionMoveSignedRegister(n4, n1, n4, n4, n1, n1, n1, n1) -> void;
+  auto armInstructionMoveToCoprocessorFromRegister(n4, n3, n4, n4, n4, n3) -> void;
+  auto armInstructionMoveToRegisterFromCoprocessor(n4, n3, n4, n4, n4, n3) -> void;
+  auto armInstructionMoveToRegisterFromRegister(n4, n4) -> void;
  auto armInstructionMoveToRegisterFromStatus(n4, n1) -> void;
  auto armInstructionMoveToStatusFromImmediate(n8, n4, n4, n1) -> void;
-  auto armInstructionMoveToStatusFromRegister(n4, n4, n1) -> void;
+  auto armInstructionMoveToStatusFromRegister(n4, n2, n5, n4, n1) -> void;
  auto armInstructionMultiply(n4, n4, n4, n4, n1, n1) -> void;
  auto armInstructionMultiplyLong(n4, n4, n4, n4, n1, n1, n1) -> void;
  auto armInstructionSoftwareInterrupt(n24 immediate) -> void;
@@ -133,7 +136,7 @@ struct ARM7TDMI {
    }

    n32 data;
-    function<auto () -> void> modify;
+    std::function<auto () -> void> modify;
  };

  struct PSR {
@@ -148,21 +151,31 @@ struct ARM7TDMI {
    };

    operator u32() const {
-      return m << 0 | t << 5 | f << 6 | i << 7 | v << 28 | c << 29 | z << 30 | n << 31;
+      return m << 0 | 1 << 4 | t << 5 | f << 6 | i << 7 | v << 28 | c << 29 | z << 30 | n << 31;
    }

    auto operator=(n32 data) -> PSR& {
-      m = data.bit(0,4);
-      t = data.bit(5);
-      f = data.bit(6);
-      i = data.bit(7);
-      v = data.bit(28);
-      c = data.bit(29);
-      z = data.bit(30);
-      n = data.bit(31);
+      set(0b1111, data);
      return *this;
    }

+    auto set(n4 field, n32 data) -> void {
+      if(readonly) return;
+      if(field.bit(0)) {
+        m = data.bit(0,4) | 0x10;
+        t = data.bit(5);
+        f = data.bit(6);
+        i = data.bit(7);
+      }
+
+      if(field.bit(3)) {
+        v = data.bit(28);
+        c = data.bit(29);
+        z = data.bit(30);
+        n = data.bit(31);
+      }
+    }
+
    //serialization.cpp
    auto serialize(serializer&) -> void;

@@ -174,6 +187,8 @@ struct ARM7TDMI {
    b1 c;  //carry
    b1 z;  //zero
    b1 n;  //negative
+
+    b1 readonly;
  };

  struct Processor {
@@ -182,6 +197,8 @@ struct ARM7TDMI {

    GPR r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15;
    PSR cpsr;
+    GPR rNULL;  //read-only, used when no register is mapped to r(13) or r(14)
+    PSR spsrNULL;  //read-only, used when no SPSR is mapped

    struct FIQ {
      GPR r8, r9, r10, r11, r12, r13, r14;
@@ -221,7 +238,6 @@ struct ARM7TDMI {
    };

    n1 reload = 1;
-    n1 nonsequential = 1;
    Instruction fetch;
    Instruction decode;
    Instruction execute;
@@ -230,27 +246,41 @@ struct ARM7TDMI {
  n32 opcode;
  b1  carry;
  b1  irq;
+  b1  nonsequential;

-  function<void (n32 opcode)> armInstruction[4096];
-  function<void ()> thumbInstruction[65536];
+  std::function<void (n32 opcode)> armInstruction[4096];
+  std::function<void ()> thumbInstruction[65536];
+
+  //coprocessor.cpp
+  auto bindCDP(n4 id, std::function<void (n4 cm, n3 op2, n4 cd, n4 cn, n4 op1)> handler) -> void;
+  auto bindMCR(n4 id, std::function<void (n32 data, n4 cm, n3 op2, n4 cn, n3 op1)> handler) -> void;
+  auto bindMRC(n4 id, std::function<n32 (n4 cm, n3 op2, n4 cn, n3 op1)> handler) -> void;
+
+  std::function<void (n4 cm, n3 op2, n4 cd, n4 cn, n4 op1)> CDP[16];
+  std::function<void (n32 data, n4 cm, n3 op2, n4 cn, n3 op1)> MCR[16];
+  std::function<n32 (n4 cm, n3 op2, n4 cn, n3 op1)> MRC[16];

  //disassembler.cpp
  auto armDisassembleBranch(i24, n1) -> string;
-  auto armDisassembleBranchExchangeRegister(n4) -> string;
+  auto armDisassembleBranchExchangeRegister(n4, n4, n4, n1) -> string;
+  auto armDisassembleCoprocessorDataProcessing(n4, n3, n4, n4, n4, n4) -> string;
  auto armDisassembleDataImmediate(n8, n4, n4, n4, n1, n4) -> string;
  auto armDisassembleDataImmediateShift(n4, n2, n5, n4, n4, n1, n4) -> string;
  auto armDisassembleDataRegisterShift(n4, n2, n4, n4, n4, n1, n4) -> string;
-  auto armDisassembleLoadImmediate(n8, n1, n4, n4, n1, n1, n1) -> string;
-  auto armDisassembleLoadRegister(n4, n1, n4, n4, n1, n1, n1) -> string;
  auto armDisassembleMemorySwap(n4, n4, n4, n1) -> string;
  auto armDisassembleMoveHalfImmediate(n8, n4, n4, n1, n1, n1, n1) -> string;
  auto armDisassembleMoveHalfRegister(n4, n4, n4, n1, n1, n1, n1) -> string;
  auto armDisassembleMoveImmediateOffset(n12, n4, n4, n1, n1, n1, n1, n1) -> string;
  auto armDisassembleMoveMultiple(n16, n4, n1, n1, n1, n1, n1) -> string;
  auto armDisassembleMoveRegisterOffset(n4, n2, n5, n4, n4, n1, n1, n1, n1, n1) -> string;
+  auto armDisassembleMoveSignedImmediate(n8, n1, n4, n4, n1, n1, n1, n1) -> string;
+  auto armDisassembleMoveSignedRegister(n4, n1, n4, n4, n1, n1, n1, n1) -> string;
+  auto armDisassembleMoveToCoprocessorFromRegister(n4, n3, n4, n4, n4, n3) -> string;
+  auto armDisassembleMoveToRegisterFromCoprocessor(n4, n3, n4, n4, n4, n3) -> string;
+  auto armDisassembleMoveToRegisterFromRegister(n4, n4) -> string;
  auto armDisassembleMoveToRegisterFromStatus(n4, n1) -> string;
  auto armDisassembleMoveToStatusFromImmediate(n8, n4, n4, n1) -> string;
-  auto armDisassembleMoveToStatusFromRegister(n4, n4, n1) -> string;
+  auto armDisassembleMoveToStatusFromRegister(n4, n2, n5, n4, n1) -> string;
  auto armDisassembleMultiply(n4, n4, n4, n4, n1, n1) -> string;
  auto armDisassembleMultiplyLong(n4, n4, n4, n4, n1, n1, n1) -> string;
  auto armDisassembleSoftwareInterrupt(n24) -> string;
@@ -280,8 +310,8 @@ struct ARM7TDMI {
  auto thumbDisassembleStackMultiple(n8, n1, n1) -> string;
  auto thumbDisassembleUndefined() -> string;

-  function<string (n32 opcode)> armDisassemble[4096];
-  function<string ()> thumbDisassemble[65536];
+  std::function<string (n32 opcode)> armDisassemble[4096];
+  std::function<string ()> thumbDisassemble[65536];

  n32 _pc;
  string _c;
@@ -0,0 +1,11 @@
+auto ARM7TDMI::bindCDP(n4 id, std::function<void (n4 cm, n3 op2, n4 cd, n4 cn, n4 op1)> handler) -> void {
+  CDP[id] = handler;
+}
+
+auto ARM7TDMI::bindMCR(n4 id, std::function<void (n32 data, n4 cm, n3 op2, n4 cn, n3 op1)> handler) -> void {
+  MCR[id] = handler;
+}
+
+auto ARM7TDMI::bindMRC(n4 id, std::function<n32 (n4 cm, n3 op2, n4 cn, n3 op1)> handler) -> void {
+  MRC[id] = handler;
+}
@@ -17,12 +17,12 @@ auto ARM7TDMI::disassembleInstruction(maybe<n32> pc, maybe<boolean> thumb) -> st

  _pc = pc();
  if(!thumb()) {
-    n32 opcode = getDebugger(Word | Nonsequential, _pc & ~3);
+    n32 opcode = getDebugger(Word, _pc & ~3);
    n12 index = (opcode & 0x0ff00000) >> 16 | (opcode & 0x000000f0) >> 4;
    _c = _conditions[opcode >> 28];
    return pad(armDisassemble[index](opcode), -40);
  } else {
-    n16 opcode = getDebugger(Half | Nonsequential, _pc & ~1);
+    n16 opcode = getDebugger(Half, _pc & ~1);
    return pad(thumbDisassemble[opcode](), -40);
  }
 }
@@ -64,10 +64,16 @@ auto ARM7TDMI::armDisassembleBranch
 }

 auto ARM7TDMI::armDisassembleBranchExchangeRegister
-(n4 m) -> string {
+(n4 m, n4 d, n4 field, n1 mode) -> string {
  return {"bx", _c, " ", _r[m]};
 }

+auto ARM7TDMI::armDisassembleCoprocessorDataProcessing
+(n4 cm, n3 op2, n4 cpid, n4 cd, n4 cn, n4 op1) -> string {
+  return {"cdp", _c, " p", cpid, ", ", op1, ", cr", cd,
+    ", cr", cn, ", cr", cm, ", ", op2};
+}
+
 auto ARM7TDMI::armDisassembleDataImmediate
 (n8 immediate, n4 shift, n4 d, n4 n, n1 save, n4 mode) -> string {
  static const string opcode[] = {
@@ -118,30 +124,6 @@ auto ARM7TDMI::armDisassembleDataRegisterShift
    " ", _r[s]};
 }

-auto ARM7TDMI::armDisassembleLoadImmediate
-(n8 immediate, n1 half, n4 d, n4 n, n1 writeback, n1 up, n1 pre) -> string {
-  string data;
-  if(n == 15) data = {" =0x", hex(getDebugger((half ? Half : Byte) | Nonsequential,
-    _pc + 8 + (up ? +immediate : -immediate)), half ? 4L : 2L)};
-
-  return {"ldr", _c, half ? "sh" : "sb", " ",
-    _r[d], ",[", _r[n],
-    pre == 0 ? "]" : "",
-    immediate ? string{",", up ? "+" : "-", "0x", hex(immediate, 2L)} : string{},
-    pre == 1 ? "]" : "",
-    pre == 0 || writeback ? "!" : "", data};
-}
-
-auto ARM7TDMI::armDisassembleLoadRegister
-(n4 m, n1 half, n4 d, n4 n, n1 writeback, n1 up, n1 pre) -> string {
-  return {"ldr", _c, half ? "sh" : "sb", " ",
-    _r[d], ",[", _r[n],
-    pre == 0 ? "]" : "",
-    ",", up ? "+" : "-", _r[m],
-    pre == 1 ? "]" : "",
-    pre == 0 || writeback ? "!" : ""};
-}
-
 auto ARM7TDMI::armDisassembleMemorySwap
 (n4 m, n4 d, n4 n, n1 byte) -> string {
  return {"swp", _c, byte ? "b" : "", " ", _r[d], ",", _r[m], ",[", _r[n], "]"};
@@ -150,7 +132,7 @@ auto ARM7TDMI::armDisassembleMemorySwap
 auto ARM7TDMI::armDisassembleMoveHalfImmediate
 (n8 immediate, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> string {
  string data;
-  if(n == 15) data = {" =0x", hex(getDebugger(Half | Nonsequential, _pc + (up ? +immediate : -immediate)), 4L)};
+  if(n == 15) data = {" =0x", hex(getDebugger(Half, _pc + (up ? +immediate : -immediate)), 4L)};

  return {mode ? "ldr" : "str", _c, "h ",
    _r[d], ",[", _r[n],
@@ -173,7 +155,7 @@ auto ARM7TDMI::armDisassembleMoveHalfRegister
 auto ARM7TDMI::armDisassembleMoveImmediateOffset
 (n12 immediate, n4 d, n4 n, n1 mode, n1 writeback, n1 byte, n1 up, n1 pre) -> string {
  string data;
-  if(n == 15) data = {" =0x", hex(getDebugger((byte ? Byte : Word) | Nonsequential,
+  if(n == 15) data = {" =0x", hex(getDebugger((byte ? Byte : Word),
    _pc + 8 + (up ? +immediate : -immediate)), byte ? 2L : 4L)};
  return {mode ? "ldr" : "str", _c, byte ? "b" : "", " ", _r[d], ",[", _r[n],
    pre == 0 ? "]" : "",
@@ -212,6 +194,47 @@ auto ARM7TDMI::armDisassembleMoveRegisterOffset
    pre == 0 || writeback ? "!" : ""};
 }

+auto ARM7TDMI::armDisassembleMoveSignedImmediate
+(n8 immediate, n1 half, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> string {
+  string data;
+  if(n == 15) data = {" =0x", hex(getDebugger((half ? Half : Byte),
+    _pc + 8 + (up ? +immediate : -immediate)), half ? 4L : 2L)};
+
+  return {mode ? "ldr" : "str", _c, half ? "sh" : "sb", " ",
+    _r[d], ",[", _r[n],
+    pre == 0 ? "]" : "",
+    immediate ? string{",", up ? "+" : "-", "0x", hex(immediate, 2L)} : string{},
+    pre == 1 ? "]" : "",
+    pre == 0 || writeback ? "!" : "", data};
+}
+
+auto ARM7TDMI::armDisassembleMoveSignedRegister
+(n4 m, n1 half, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> string {
+  return {mode ? "ldr" : "str", _c, half ? "sh" : "sb", " ",
+    _r[d], ",[", _r[n],
+    pre == 0 ? "]" : "",
+    ",", up ? "+" : "-", _r[m],
+    pre == 1 ? "]" : "",
+    pre == 0 || writeback ? "!" : ""};
+}
+
+auto ARM7TDMI::armDisassembleMoveToCoprocessorFromRegister
+(n4 cm, n3 op2, n4 cpid, n4 d, n4 cn, n3 op1) -> string {
+  return {"mcr", _c, " p", cpid, ", ", op1, ", ", _r[d],
+    ", cr", cn, ", cr", cm, ", ", op2};
+}
+
+auto ARM7TDMI::armDisassembleMoveToRegisterFromCoprocessor
+(n4 cm, n3 op2, n4 cpid, n4 d, n4 cn, n3 op1) -> string {
+  return {"mrc", _c, " p", cpid, ", ", op1, ", ", _r[d],
+    ", cr", cn, ", cr", cm, ", ", op2};
+}
+
+auto ARM7TDMI::armDisassembleMoveToRegisterFromRegister
+(n4 d, n4 n) -> string {
+  return {"mov", _c, " ", _r[d], ",", _r[n]};
+}
+
 auto ARM7TDMI::armDisassembleMoveToRegisterFromStatus
 (n4 d, n1 mode) -> string {
  return {"mrs", _c, " ", _r[d], ",", mode ? "spsr" : "cpsr"};
@@ -229,13 +252,18 @@ auto ARM7TDMI::armDisassembleMoveToStatusFromImmediate
 }

 auto ARM7TDMI::armDisassembleMoveToStatusFromRegister
-(n4 m, n4 field, n1 mode) -> string {
+(n4 m, n2 type, n5 shift, n4 field, n1 mode) -> string {
  return {"msr", _c, " ", mode ? "spsr:" : "cpsr:",
    field.bit(0) ? "c" : "",
    field.bit(1) ? "x" : "",
    field.bit(2) ? "s" : "",
    field.bit(3) ? "f" : "",
-    ",", _r[m]};
+    ",", _r[m],
+    type == 0 && shift ? string{" lsl #", shift} : string{},
+    type == 1 ? string{" lsr #", shift ? (u32)shift : 32} : string{},
+    type == 2 ? string{" asr #", shift ? (u32)shift : 32} : string{},
+    type == 3 && shift ? string{" ror #", shift} : string{},
+    type == 3 && !shift ? " rrx" : ""};
 }

 auto ARM7TDMI::armDisassembleMultiply
@@ -276,7 +304,7 @@ auto ARM7TDMI::thumbDisassembleALU

 auto ARM7TDMI::thumbDisassembleALUExtended
 (n4 d, n4 m, n2 mode) -> string {
-  static const string opcode[] = {"add", "sub", "mov"};
+  static const string opcode[] = {"add", "cmp", "mov"};
  if(d == 8 && m == 8 && mode == 2) return {"nop"};
  return {opcode[mode], " ", _r[d], ",", _r[m]};
 }
@@ -308,7 +336,7 @@ auto ARM7TDMI::thumbDisassembleBranchExchange

 auto ARM7TDMI::thumbDisassembleBranchFarPrefix
 (i11 displacementHi) -> string {
-  n11 displacementLo = getDebugger(Half | Nonsequential, (_pc & ~1) + 2);
+  n11 displacementLo = getDebugger(Half, (_pc & ~1) + 2);
  i22 displacement = displacementHi << 11 | displacementLo << 0;
  n32 address = _pc + 4 + displacement * 2;
  return {"bl 0x", hex(address, 8L)};
@@ -340,7 +368,7 @@ auto ARM7TDMI::thumbDisassembleImmediate
 auto ARM7TDMI::thumbDisassembleLoadLiteral
 (n8 displacement, n3 d) -> string {
  n32 address = ((_pc + 4) & ~3) + (displacement << 2);
-  n32 data = getDebugger(Word | Nonsequential, address);
+  n32 data = getDebugger(Word, address);
  return {"ldr ", _r[d], ",[pc,#0x", hex(address, 8L), "] =0x", hex(data, 8L)};
 }

@@ -1,11 +1,9 @@
 auto ARM7TDMI::reload() -> void {
-  u32 mask = !cpsr().t ? 3 : 1;
  u32 size = !cpsr().t ? Word : Half;
-
  pipeline.reload = false;
-  r(15).data &= ~mask;
-  pipeline.fetch.address = r(15) & ~mask;
-  pipeline.fetch.instruction = read(Prefetch | size | Nonsequential, pipeline.fetch.address);
+  endBurst();
+  pipeline.fetch.address = r(15);
+  pipeline.fetch.instruction = read(Prefetch | size, pipeline.fetch.address);
  fetch();
 }

@@ -16,18 +14,10 @@ auto ARM7TDMI::fetch() -> void {
  pipeline.decode.thumb = cpsr().t;
  pipeline.decode.irq = !cpsr().i;

-  u32 sequential = Sequential;
-  if(pipeline.nonsequential) {
-    pipeline.nonsequential = false;
-    sequential = Nonsequential;
-  }
-
-  u32 mask = !cpsr().t ? 3 : 1;
  u32 size = !cpsr().t ? Word : Half;
-
  r(15).data += size >> 3;
-  pipeline.fetch.address = r(15) & ~mask;
-  pipeline.fetch.instruction = read(Prefetch | size | sequential, pipeline.fetch.address);
+  pipeline.fetch.address = r(15);
+  pipeline.fetch.instruction = read(Prefetch | size, pipeline.fetch.address);
 }

 auto ARM7TDMI::instruction() -> void {
@@ -85,13 +75,31 @@ auto ARM7TDMI::armInitialize() -> void {
  #undef arguments

  #define arguments \
-    opcode.bit( 0, 3)   /* m */
-  {
-    auto opcode = pattern(".... 0001 0010 ---- ---- ---- 0001 ????");
+    opcode.bit( 0, 3),  /* m */ \
+    opcode.bit(12,15),  /* d */ \
+    opcode.bit(16,19),  /* field */ \
+    opcode.bit(22)      /* mode */
+  for(n3 _ : range(8))
+  for(n1 mode : range(2)) {
+    auto opcode = pattern(".... 0001 0??0 ???? ???? ---- 0??1 ????") | _.bit(0,1) << 5 | _.bit(2) << 21 | mode << 22;
    bind(opcode, BranchExchangeRegister);
  }
  #undef arguments

+  #define arguments \
+    opcode.bit( 0, 3),  /* cm */ \
+    opcode.bit( 5, 7),  /* op2 */ \
+    opcode.bit( 8,11),  /* cpid */ \
+    opcode.bit(12,15),  /* cd */ \
+    opcode.bit(16,19),  /* cn */ \
+    opcode.bit(20,23)   /* op1 */
+  for(n3 op2 : range(8))
+  for(n4 op1 : range(16)) {
+    auto opcode = pattern(".... 1110 ???? ???? ???? ???? ???0 ????") | op2 << 5 | op1 << 20;
+    bind(opcode, CoprocessorDataProcessing);
+  }
+  #undef arguments
+
  #define arguments \
    opcode.bit( 0, 7),  /* immediate */ \
    opcode.bit( 8,11),  /* shift */ \
@@ -143,47 +151,14 @@ auto ARM7TDMI::armInitialize() -> void {
  }
  #undef arguments

-  #define arguments \
-    opcode.bit( 0, 3) << 0 | opcode.bit( 8,11) << 4,  /* immediate */ \
-    opcode.bit( 5),     /* half */ \
-    opcode.bit(12,15),  /* d */ \
-    opcode.bit(16,19),  /* n */ \
-    opcode.bit(21),     /* writeback */ \
-    opcode.bit(23),     /* up */ \
-    opcode.bit(24)      /* pre */
-  for(n1 half : range(2))
-  for(n1 writeback : range(2))
-  for(n1 up : range(2))
-  for(n1 pre : range(2)) {
-    auto opcode = pattern(".... 000? ?1?1 ???? ???? ???? 11?1 ????") | half << 5 | writeback << 21 | up << 23 | pre << 24;
-    bind(opcode, LoadImmediate);
-  }
-  #undef arguments
-
-  #define arguments \
-    opcode.bit( 0, 3),  /* m */ \
-    opcode.bit( 5),     /* half */ \
-    opcode.bit(12,15),  /* d */ \
-    opcode.bit(16,19),  /* n */ \
-    opcode.bit(21),     /* writeback */ \
-    opcode.bit(23),     /* up */ \
-    opcode.bit(24)      /* pre */
-  for(n1 half : range(2))
-  for(n1 writeback : range(2))
-  for(n1 up : range(2))
-  for(n1 pre : range(2)) {
-    auto opcode = pattern(".... 000? ?0?1 ???? ???? ---- 11?1 ????") | half << 5 | writeback << 21 | up << 23 | pre << 24;
-    bind(opcode, LoadRegister);
-  }
-  #undef arguments
-
  #define arguments \
    opcode.bit( 0, 3),  /* m */ \
    opcode.bit(12,15),  /* d */ \
    opcode.bit(16,19),  /* n */ \
    opcode.bit(22)      /* byte */
+  for(n3 _ : range(8))
  for(n1 byte : range(2)) {
-    auto opcode = pattern(".... 0001 0?00 ???? ???? ---- 1001 ????") | byte << 22;
+    auto opcode = pattern(".... 0001 ???? ???? ???? ---- 1001 ????") | _.bit(0,1) << 20 | byte << 22 | _.bit(2) << 23;
    bind(opcode, MemorySwap);
  }
  #undef arguments
@@ -287,11 +262,88 @@ auto ARM7TDMI::armInitialize() -> void {
  }
  #undef arguments

+  #define arguments \
+    opcode.bit( 0, 3) << 0 | opcode.bit( 8,11) << 4,  /* immediate */ \
+    opcode.bit( 5),     /* half */ \
+    opcode.bit(12,15),  /* d */ \
+    opcode.bit(16,19),  /* n */ \
+    opcode.bit(20),     /* mode */ \
+    opcode.bit(21),     /* writeback */ \
+    opcode.bit(23),     /* up */ \
+    opcode.bit(24)      /* pre */
+  for(n1 half : range(2))
+  for(n1 mode : range(2))
+  for(n1 writeback : range(2))
+  for(n1 up : range(2))
+  for(n1 pre : range(2)) {
+    auto opcode = pattern(".... 000? ?1?? ???? ???? ???? 11?1 ????") | half << 5 | mode << 20 | writeback << 21 | up << 23 | pre << 24;
+    bind(opcode, MoveSignedImmediate);
+  }
+  #undef arguments
+
+  #define arguments \
+    opcode.bit( 0, 3),  /* m */ \
+    opcode.bit( 5),     /* half */ \
+    opcode.bit(12,15),  /* d */ \
+    opcode.bit(16,19),  /* n */ \
+    opcode.bit(20),     /* mode */ \
+    opcode.bit(21),     /* writeback */ \
+    opcode.bit(23),     /* up */ \
+    opcode.bit(24)      /* pre */
+  for(n1 half : range(2))
+  for(n1 mode : range(2))
+  for(n1 writeback : range(2))
+  for(n1 up : range(2))
+  for(n1 pre : range(2)) {
+    auto opcode = pattern(".... 000? ?0?? ???? ???? ---- 11?1 ????") | half << 5 | mode << 20 | writeback << 21 | up << 23 | pre << 24;
+    bind(opcode, MoveSignedRegister);
+  }
+  #undef arguments
+
+  #define arguments \
+    opcode.bit( 0, 3),  /* cm */ \
+    opcode.bit( 5, 7),  /* op2 */ \
+    opcode.bit( 8,11),  /* cpid */ \
+    opcode.bit(12,15),  /* d */ \
+    opcode.bit(16,19),  /* cn */ \
+    opcode.bit(21,23)   /* op1 */
+  for(n3 op2 : range(8))
+  for(n3 op1 : range(8)) {
+    auto opcode = pattern(".... 1110 ???0 ???? ???? ???? ???1 ????") | op2 << 5 | op1 << 21;
+    bind(opcode, MoveToCoprocessorFromRegister);
+  }
+  #undef arguments
+
+  #define arguments \
+    opcode.bit( 0, 3),  /* cm */ \
+    opcode.bit( 5, 7),  /* op2 */ \
+    opcode.bit( 8,11),  /* cpid */ \
+    opcode.bit(12,15),  /* d */ \
+    opcode.bit(16,19),  /* cn */ \
+    opcode.bit(21,23)   /* op1 */
+  for(n3 op2 : range(8))
+  for(n3 op1 : range(8)) {
+    auto opcode = pattern(".... 1110 ???1 ???? ???? ???? ???1 ????") | op2 << 5 | op1 << 21;
+    bind(opcode, MoveToRegisterFromCoprocessor);
+  }
+  #undef arguments
+
+  #define arguments \
+    opcode.bit(12,15),  /* d */ \
+    opcode.bit(16,19)   /* n */
+  for(n5 _ : range(32)) {
+    //undocumented instruction, equivalent to "mov rd, rn"
+    auto opcode = pattern(".... 0011 0?00 ???? ???? ---- ???? ----") | _.bit(0,3) << 4 | _.bit(4) << 22;
+    bind(opcode, MoveToRegisterFromRegister);
+  }
+  #undef arguments
+
  #define arguments \
    opcode.bit(12,15),  /* d */ \
    opcode.bit(22)      /* mode */
+  for(n3 _ : range(8))
  for(n1 mode : range(2)) {
-    auto opcode = pattern(".... 0001 0?00 ---- ???? ---- 0000 ----") | mode << 22;
+    auto opcode = pattern(".... 0001 0?00 ---- ???? ---- ???0 ----") | _ << 5 | mode << 22;
    bind(opcode, MoveToRegisterFromStatus);
  }
  #undef arguments
@@ -310,10 +362,14 @@ auto ARM7TDMI::armInitialize() -> void {

  #define arguments \
    opcode.bit( 0, 3),  /* m */ \
+    opcode.bit( 5, 6),  /* type */ \
+    opcode.bit( 7,11),  /* shift */ \
    opcode.bit(16,19),  /* field */ \
    opcode.bit(22)      /* mode */
+  for(n2 type : range(4))
+  for(n1 shiftLo : range(2))
  for(n1 mode : range(2)) {
-    auto opcode = pattern(".... 0001 0?10 ???? ---- ---- 0000 ????") | mode << 22;
+    auto opcode = pattern(".... 0001 0?10 ???? ---- ???? ???0 ????") | type << 5 | shiftLo << 7 | mode << 22;
    bind(opcode, MoveToStatusFromRegister);
  }
  #undef arguments
@@ -326,8 +382,9 @@ auto ARM7TDMI::armInitialize() -> void {
    opcode.bit(20),     /* save */ \
    opcode.bit(21)      /* accumulate */
  for(n1 save : range(2))
-  for(n1 accumulate : range(2)) {
-    auto opcode = pattern(".... 0000 00?? ???? ???? ???? 1001 ????") | save << 20 | accumulate << 21;
+  for(n1 accumulate : range(2))
+  for(n1 _ : range(2)) {
+    auto opcode = pattern(".... 0000 0??? ???? ???? ???? 1001 ????") | save << 20 | accumulate << 21 | _ << 22;
    bind(opcode, Multiply);
  }
  #undef arguments
@@ -358,22 +415,35 @@ auto ARM7TDMI::armInitialize() -> void {
  #undef arguments

  #define arguments
-  for(n12 id : range(4096)) {
-    if(armInstruction[id]) continue;
-    auto opcode = pattern(".... ???? ???? ---- ---- ---- ???? ----") | id.bit(0,3) << 4 | id.bit(4,11) << 20;
+  for(n8 _ : range(256)) {
+    //architecturally undefined
+    auto opcode = pattern(".... 011? ???? ---- ---- ---- ???1 ----") | _.bit(0,2) << 5 | _.bit(3,7) << 20;
+    bind(opcode, Undefined);
+  }
+  for(n8 _ : range(256)) {
+    //load to coprocessor
+    auto opcode = pattern(".... 110? ???1 ---- ---- ---- ???? ----") | _.bit(0,3) << 4 | _.bit(4,7) << 21;
+    bind(opcode, Undefined);
+  }
+  for(n8 _ : range(256)) {
+    //store from coprocessor
+    auto opcode = pattern(".... 110? ???0 ---- ---- ---- ???? ----") | _.bit(0,3) << 4 | _.bit(4,7) << 21;
    bind(opcode, Undefined);
  }
  #undef arguments

  #undef bind
  #undef pattern
+
+  //check that all encodings are bound
+  for(n12 index : range(4096)) assert(armInstruction[index]);
 }

 auto ARM7TDMI::thumbInitialize() -> void {
  #define bind(id, name, ...) { \
    assert(!thumbInstruction[id]); \
-    thumbInstruction[id] = [=] { return thumbInstruction##name(__VA_ARGS__); }; \
-    thumbDisassemble[id] = [=] { return thumbDisassemble##name(__VA_ARGS__); }; \
+    thumbInstruction[id] = [=, this] { return thumbInstruction##name(__VA_ARGS__); }; \
+    thumbDisassemble[id] = [=, this] { return thumbDisassemble##name(__VA_ARGS__); }; \
  }

  #define pattern(s) \
@@ -423,9 +493,9 @@ auto ARM7TDMI::thumbInitialize() -> void {
    bind(opcode, AdjustStack, immediate, mode);
  }

-  for(n4 d : range(16))
+  for(n4 _ : range(16))
  for(n4 m : range(16)) {
-    auto opcode = pattern("0100 0111 ???? ?---") | d.bit(0,2) << 0 | m << 3 | d.bit(3) << 7;
+    auto opcode = pattern("0100 0111 ???? ?---") | _.bit(0,2) << 0 | m << 3 | _.bit(3) << 7;
    bind(opcode, BranchExchange, m);
  }

@@ -446,6 +516,7 @@ auto ARM7TDMI::thumbInitialize() -> void {

  for(n8 displacement : range(256))
  for(n4 condition : range(16)) {
+    if(condition == 14) continue;  //BAL
    if(condition == 15) continue;  //BNV
    auto opcode = pattern("1101 ???? ???? ????") | displacement << 0 | condition << 8;
    bind(opcode, BranchTest, displacement, condition);
@@ -24,24 +24,12 @@ auto ARM7TDMI::armALU(n4 mode, n4 d, n32 rn, n32 rm) -> void {
 }

 auto ARM7TDMI::armMoveToStatus(n4 field, n1 mode, n32 data) -> void {
-  if(mode && (cpsr().m == PSR::USR || cpsr().m == PSR::SYS)) return;
-  PSR& psr = mode ? spsr() : cpsr();
-
-  if(field.bit(0)) {
-    if(mode || privileged()) {
-      psr.m = data.bit(0,4);
-      psr.t = data.bit(5);
-      psr.f = data.bit(6);
-      psr.i = data.bit(7);
-      if(!mode && psr.t) r(15).data += 2;
-    }
-  }
-
-  if(field.bit(3)) {
-    psr.v = data.bit(28);
-    psr.c = data.bit(29);
-    psr.z = data.bit(30);
-    psr.n = data.bit(31);
+  if(mode) {
+    spsr().set(field, data);
+  } else {
+    if(!privileged()) field.bit(0) = 0;
+    cpsr().set(field, data);
+    if(cpsr().t) r(15).data += 2;
  }
 }

@@ -54,10 +42,21 @@ auto ARM7TDMI::armInstructionBranch
 }

 auto ARM7TDMI::armInstructionBranchExchangeRegister
-(n4 m) -> void {
+(n4 m, n4 d, n4 field, n1 mode) -> void {
  n32 address = r(m);
-  cpsr().t = address.bit(0);
-  r(15) = address;
+  if((field & 0b1001) == 0b1001) {
+    PSR& psr = mode ? spsr() : cpsr();
+    psr.t = address.bit(0);
+  } else {
+    armMoveToStatus(field, mode, address);
+  }
+  r(d) = address;
+}
+
+auto ARM7TDMI::armInstructionCoprocessorDataProcessing
+(n4 cm, n3 op2, n4 cpid, n4 cd, n4 cn, n4 op1) -> void {
+  if(!CDP[cpid]) return armInstructionUndefined();
+  CDP[cpid](cm, op2, cd, cn, op1);
 }

 auto ARM7TDMI::armInstructionDataImmediate
@@ -87,84 +86,65 @@ auto ARM7TDMI::armInstructionDataImmediateShift

 auto ARM7TDMI::armInstructionDataRegisterShift
 (n4 m, n2 type, n4 s, n4 d, n4 n, n1 save, n4 mode) -> void {
-  n8  rs = r(s) + (s == 15 ? 4 : 0);
+  n8  rs = r(s);
  n32 rn = r(n) + (n == 15 ? 4 : 0);
  n32 rm = r(m) + (m == 15 ? 4 : 0);
  carry = cpsr().c;

+  idle();
  switch(type) {
-  case 0: rm = LSL(rm, rs < 33 ? rs : (n8)33); break;
-  case 1: rm = LSR(rm, rs < 33 ? rs : (n8)33); break;
-  case 2: rm = ASR(rm, rs < 32 ? rs : (n8)32); break;
-  case 3: if(rs) rm = ROR(rm, rs & 31 ? u32(rs & 31) : 32); break;
+  case 0: rm = LSL(rm, rs); break;
+  case 1: rm = LSR(rm, rs); break;
+  case 2: rm = ASR(rm, rs); break;
+  case 3: rm = ROR(rm, rs); break;
  }

  armALU(mode, d, rn, rm);
 }

-auto ARM7TDMI::armInstructionLoadImmediate
-(n8 immediate, n1 half, n4 d, n4 n, n1 writeback, n1 up, n1 pre) -> void {
-  n32 rn = r(n);
-  n32 rd = r(d);
-
-  if(pre == 1) rn = up ? rn + immediate : rn - immediate;
-  rd = load((half ? Half : Byte) | Nonsequential | Signed, rn);
-  if(pre == 0) rn = up ? rn + immediate : rn - immediate;
-
-  if(pre == 0 || writeback) r(n) = rn;
-  r(d) = rd;
-}
-
-auto ARM7TDMI::armInstructionLoadRegister
-(n4 m, n1 half, n4 d, n4 n, n1 writeback, n1 up, n1 pre) -> void {
-  n32 rn = r(n);
-  n32 rm = r(m);
-  n32 rd = r(d);
-
-  if(pre == 1) rn = up ? rn + rm : rn - rm;
-  rd = load((half ? Half : Byte) | Nonsequential | Signed, rn);
-  if(pre == 0) rn = up ? rn + rm : rn - rm;
-
-  if(pre == 0 || writeback) r(n) = rn;
-  r(d) = rd;
-}
-
 auto ARM7TDMI::armInstructionMemorySwap
 (n4 m, n4 d, n4 n, n1 byte) -> void {
  lock();
-  n32 word = load((byte ? Byte : Word) | Nonsequential, r(n));
-  store((byte ? Byte : Word) | Nonsequential, r(n), r(m));
-  r(d) = word;
+  n32 word = load((byte ? Byte : Word), r(n));
+  store((byte ? Byte : Word), r(n), r(m) + (m == 15 ? 4 : 0));
  unlock();
+  idle();
+  r(d) = word;
 }

 auto ARM7TDMI::armInstructionMoveHalfImmediate
 (n8 immediate, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> void {
  n32 rn = r(n);
-  n32 rd = r(d);
+  n32 rd = r(d) + (d == 15 ? 4 : 0);

  if(pre == 1) rn = up ? rn + immediate : rn - immediate;
-  if(mode == 1) rd = load(Half | Nonsequential, rn);
-  if(mode == 0) store(Half | Nonsequential, rn, rd);
+  if(mode == 1) rd = load(Half, rn);
+  if(mode == 0) store(Half, rn, rd);
  if(pre == 0) rn = up ? rn + immediate : rn - immediate;

-  if(pre == 0 || writeback) r(n) = rn;
-  if(mode == 1) r(d) = rd;
+  if(pre == 0 || writeback) r(n) = rn + (n == 15 ? 4 : 0);
+  if(mode == 1) {
+    idle();
+    r(d) = rd;
+  }
 }

 auto ARM7TDMI::armInstructionMoveHalfRegister
 (n4 m, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> void {
  n32 rn = r(n);
  n32 rm = r(m);
-  n32 rd = r(d);
+  n32 rd = r(d) + (d == 15 ? 4 : 0);

  if(pre == 1) rn = up ? rn + rm : rn - rm;
-  if(mode == 1) rd = load(Half | Nonsequential, rn);
-  if(mode == 0) store(Half | Nonsequential, rn, rd);
+  if(mode == 1) rd = load(Half, rn);
+  if(mode == 0) store(Half, rn, rd);
  if(pre == 0) rn = up ? rn + rm : rn - rm;

-  if(pre == 0 || writeback) r(n) = rn;
-  if(mode == 1) r(d) = rd;
+  if(pre == 0 || writeback) r(n) = rn + (n == 15 ? 4 : 0);
+  if(mode == 1) {
+    idle();
+    r(d) = rd;
+  }
 }

 auto ARM7TDMI::armInstructionMoveImmediateOffset
@@ -173,46 +153,47 @@ auto ARM7TDMI::armInstructionMoveImmediateOffset
  n32 rd = r(d) + (d == 15 ? 4 : 0);

  if(pre == 1) rn = up ? rn + immediate : rn - immediate;
-  if(mode == 1) rd = load((byte ? Byte : Word) | Nonsequential, rn);
-  if(mode == 0) store((byte ? Byte : Word) | Nonsequential, rn, rd);
+  if(mode == 1) rd = load((byte ? Byte : Word), rn);
+  if(mode == 0) store((byte ? Byte : Word), rn, rd);
  if(pre == 0) rn = up ? rn + immediate : rn - immediate;

  if(pre == 0 || writeback) r(n) = rn;
-  if(mode == 1) r(d) = rd;
+  if(mode == 1) {
+    idle();
+    r(d) = rd;
+  }
 }

 auto ARM7TDMI::armInstructionMoveMultiple
 (n16 list, n4 n, n1 mode, n1 writeback, n1 type, n1 up, n1 pre) -> void {
  n32 rn = r(n);
  n32 bitCount = list ? bit::count(list) : 16;
+  n32 rnEnd;
+  if(up == 1) rnEnd = r(n) + bitCount * 4;  //IA,IB
+  if(up == 0) rnEnd = r(n) - bitCount * 4;  //DA,DB
  if(pre == 0 && up == 1) rn = rn + 0;  //IA
  if(pre == 1 && up == 1) rn = rn + 4;  //IB
  if(pre == 1 && up == 0) rn = rn - bitCount * 4 + 0;  //DB
  if(pre == 0 && up == 0) rn = rn - bitCount * 4 + 4;  //DA

-  if(writeback && mode == 1 && !list.bit(n)) {
-    if(up == 1) r(n) = r(n) + bitCount * 4;  //IA,IB
-    if(up == 0) r(n) = r(n) - bitCount * 4;  //DA,DB
-  }
-
  auto cpsrMode = cpsr().m;
  bool usr = false;
  if(type && mode == 1 && !list.bit(15)) usr = true;
  if(type && mode == 0) usr = true;
  if(usr) cpsr().m = PSR::USR;

-  u32 sequential = Nonsequential;
-  if(!list) {
-    if(mode == 1) r(15) = read(Word | sequential, rn);
-    if(mode == 0) write(Word | sequential, rn, r(15) + 4);
-  } else {
-    for(u32 m : range(16)) {
-      if(!list.bit(m)) continue;
-      if(mode == 1) r(m) = read(Word | sequential, rn);
-      if(mode == 0) write(Word | sequential, rn, r(m) + (m == 15 ? 4 : 0));
-      rn += 4;
-      sequential = Sequential;
+  if(writeback && mode == 1 && !list.bit(n)) r(n) = rnEnd;
+
+  endBurst();
+  if(!list) list.bit(15) = 1;
+  for(u32 m : range(16)) {
+    if(!list.bit(m)) continue;
+    if(mode == 1) r(m) = read(Word, rn);
+    if(mode == 0) {
+      write(Word, rn, r(m) + (!(n == 15 && writeback) && m == 15 ? 4 : 0));
+      if(writeback) r(n) = rnEnd;  //writeback occurs after first access
    }
+    rn += 4;
  }

  if(usr) cpsr().m = cpsrMode;
@@ -223,19 +204,14 @@ auto ARM7TDMI::armInstructionMoveMultiple
      cpsr() = spsr();
    }
  } else {
-    pipeline.nonsequential = true;
-  }
-
-  if(writeback && mode == 0) {
-    if(up == 1) r(n) = r(n) + bitCount * 4;  //IA,IB
-    if(up == 0) r(n) = r(n) - bitCount * 4;  //DA,DB
+    endBurst();
  }
 }

 auto ARM7TDMI::armInstructionMoveRegisterOffset
 (n4 m, n2 type, n5 shift, n4 d, n4 n, n1 mode, n1 writeback, n1 byte, n1 up, n1 pre) -> void {
  n32 rm = r(m);
-  n32 rd = r(d);
+  n32 rd = r(d) + (d == 15 ? 4 : 0);
  n32 rn = r(n);
  carry = cpsr().c;

@@ -247,12 +223,67 @@ auto ARM7TDMI::armInstructionMoveRegisterOffset
  }

  if(pre == 1) rn = up ? rn + rm : rn - rm;
-  if(mode == 1) rd = load((byte ? Byte : Word) | Nonsequential, rn);
-  if(mode == 0) store((byte ? Byte : Word) | Nonsequential, rn, rd);
+  if(mode == 1) rd = load((byte ? Byte : Word), rn);
+  if(mode == 0) store((byte ? Byte : Word), rn, rd);
  if(pre == 0) rn = up ? rn + rm : rn - rm;

  if(pre == 0 || writeback) r(n) = rn;
-  if(mode == 1) r(d) = rd;
+  if(mode == 1) {
+    idle();
+    r(d) = rd;
+  }
+}
+
+auto ARM7TDMI::armInstructionMoveSignedImmediate
+(n8 immediate, n1 half, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> void {
+  n32 rn = r(n);
+  n32 rd = r(d) + (d == 15 ? 4 : 0);
+
+  if(pre == 1) rn = up ? rn + immediate : rn - immediate;
+  if(mode == 1) rd = load((half ? Half : Byte) | Signed, rn);
+  if(mode == 0) store((half ? Half : Byte) | Signed, rn, rd);
+  if(pre == 0) rn = up ? rn + immediate : rn - immediate;
+
+  if(pre == 0 || writeback) r(n) = rn + (n == 15 ? 4 : 0);
+  if(mode == 1) {
+    idle();
+    r(d) = rd;
+  }
+}
+
+auto ARM7TDMI::armInstructionMoveSignedRegister
+(n4 m, n1 half, n4 d, n4 n, n1 mode, n1 writeback, n1 up, n1 pre) -> void {
+  n32 rn = r(n);
+  n32 rm = r(m);
+  n32 rd = r(d) + (d == 15 ? 4 : 0);
+
+  if(pre == 1) rn = up ? rn + rm : rn - rm;
+  if(mode == 1) rd = load((half ? Half : Byte) | Signed, rn);
+  if(mode == 0) store((half ? Half : Byte) | Signed, rn, rd);
+  if(pre == 0) rn = up ? rn + rm : rn - rm;
+
+  if(pre == 0 || writeback) r(n) = rn + (n == 15 ? 4 : 0);
+  if(mode == 1) {
+    idle();
+    r(d) = rd;
+  }
+}
+
+auto ARM7TDMI::armInstructionMoveToCoprocessorFromRegister
+(n4 cm, n3 op2, n4 cpid, n4 d, n4 cn, n3 op1) -> void {
+  if(!MCR[cpid]) return armInstructionUndefined();
+  MCR[cpid](r(d), cm, op2, cn, op1);
+}
+
+auto ARM7TDMI::armInstructionMoveToRegisterFromCoprocessor
+(n4 cm, n3 op2, n4 cpid, n4 d, n4 cn, n3 op1) -> void {
+  if(!MRC[cpid]) return armInstructionUndefined();
+  r(d) = MRC[cpid](cm, op2, cn, op1);
+}
+
+auto ARM7TDMI::armInstructionMoveToRegisterFromRegister
+(n4 d, n4 n) -> void {
+  r(d) = r(n);
 }

 auto ARM7TDMI::armInstructionMoveToRegisterFromStatus
@@ -268,14 +299,25 @@ auto ARM7TDMI::armInstructionMoveToStatusFromImmediate
 }

 auto ARM7TDMI::armInstructionMoveToStatusFromRegister
-(n4 m, n4 field, n1 mode) -> void {
-  armMoveToStatus(field, mode, r(m));
+(n4 m, n2 type, n5 shift, n4 field, n1 mode) -> void {
+  n32 rm = r(m);
+  carry = cpsr().c;
+
+  switch(type) {
+  case 0: rm = LSL(rm, shift); break;
+  case 1: rm = LSR(rm, shift ? (u32)shift : 32); break;
+  case 2: rm = ASR(rm, shift ? (u32)shift : 32); break;
+  case 3: rm = shift ? ROR(rm, shift) : RRX(rm); break;
+  }
+
+  armMoveToStatus(field, mode, rm);
 }

 auto ARM7TDMI::armInstructionMultiply
 (n4 m, n4 s, n4 n, n4 d, n1 save, n1 accumulate) -> void {
  if(accumulate) idle();
-  r(d) = MUL(accumulate ? r(n) : 0, r(m), r(s));
+  n32 product = MUL(accumulate ? r(n) : 0, r(m), r(s));
+  if(d != 15) r(d) = product;
 }

 auto ARM7TDMI::armInstructionMultiplyLong
@@ -302,8 +344,8 @@ auto ARM7TDMI::armInstructionMultiplyLong
  n64 rd = rm * rs;
  if(accumulate) rd += (n64)r(h) << 32 | (n64)r(l) << 0;

-  r(l) = rd >>  0;
-  r(h) = rd >> 32;
+  if(l != 15) r(l) = rd >>  0;
+  if(h != 15) r(h) = rd >> 32;

  if(save) {
    cpsr().z = rd == 0;
@@ -1,14 +1,15 @@
 auto ARM7TDMI::thumbInstructionALU
 (n3 d, n3 m, n4 mode) -> void {
+  carry = cpsr().c;
  switch(mode) {
  case  0: r(d) = BIT(r(d) & r(m)); break;  //AND
  case  1: r(d) = BIT(r(d) ^ r(m)); break;  //EOR
-  case  2: r(d) = BIT(LSL(r(d), r(m))); break;  //LSL
-  case  3: r(d) = BIT(LSR(r(d), r(m))); break;  //LSR
-  case  4: r(d) = BIT(ASR(r(d), r(m))); break;  //ASR
+  case  2: r(d) = BIT(LSL(r(d), r(m))); idle(); break;  //LSL
+  case  3: r(d) = BIT(LSR(r(d), r(m))); idle(); break;  //LSR
+  case  4: r(d) = BIT(ASR(r(d), r(m))); idle(); break;  //ASR
  case  5: r(d) = ADD(r(d), r(m), cpsr().c); break;  //ADC
  case  6: r(d) = SUB(r(d), r(m), cpsr().c); break;  //SBC
-  case  7: r(d) = BIT(ROR(r(d), r(m))); break;  //ROR
+  case  7: r(d) = BIT(ROR(r(d), r(m))); idle(); break;  //ROR
  case  8:        BIT(r(d) & r(m)); break;  //TST
  case  9: r(d) = SUB(0, r(m), 1); break;  //NEG
  case 10:        SUB(r(d), r(m), 1); break;  //CMP
@@ -24,7 +25,7 @@ auto ARM7TDMI::thumbInstructionALUExtended
 (n4 d, n4 m, n2 mode) -> void {
  switch(mode) {
  case 0: r(d) = r(d) + r(m); break;  //ADD
-  case 1: SUB(r(d), r(m), 1); break;  //SUBS
+  case 1: SUB(r(d), r(m), 1); break;  //CMP
  case 2: r(d) = r(m); break;  //MOV
  }
 }
@@ -92,6 +93,7 @@ auto ARM7TDMI::thumbInstructionBranchTest

 auto ARM7TDMI::thumbInstructionImmediate
 (n8 immediate, n3 d, n2 mode) -> void {
+  carry = cpsr().c;
  switch(mode) {
  case 0: r(d) = BIT(immediate); break;  //MOV
  case 1:        SUB(r(d), immediate, 1); break;  //CMP
@@ -103,81 +105,81 @@ auto ARM7TDMI::thumbInstructionImmediate
 auto ARM7TDMI::thumbInstructionLoadLiteral
 (n8 displacement, n3 d) -> void {
  n32 address = (r(15) & ~3) + (displacement << 2);
-  r(d) = load(Word | Nonsequential, address);
+  r(d) = load(Word, address);
+  idle();
 }

 auto ARM7TDMI::thumbInstructionMoveByteImmediate
 (n3 d, n3 n, n5 offset, n1 mode) -> void {
  switch(mode) {
-  case 0: store(Byte | Nonsequential, r(n) + offset, r(d)); break;  //STRB
-  case 1: r(d) = load(Byte | Nonsequential, r(n) + offset); break;  //LDRB
+  case 0: store(Byte, r(n) + offset, r(d)); break;  //STRB
+  case 1: r(d) = load(Byte, r(n) + offset); idle(); break;  //LDRB
  }
 }

 auto ARM7TDMI::thumbInstructionMoveHalfImmediate
 (n3 d, n3 n, n5 offset, n1 mode) -> void {
  switch(mode) {
-  case 0: store(Half | Nonsequential, r(n) + offset * 2, r(d)); break;  //STRH
-  case 1: r(d) = load(Half | Nonsequential, r(n) + offset * 2); break;  //LDRH
+  case 0: store(Half, r(n) + offset * 2, r(d)); break;  //STRH
+  case 1: r(d) = load(Half, r(n) + offset * 2); idle(); break;  //LDRH
  }
 }

 auto ARM7TDMI::thumbInstructionMoveMultiple
 (n8 list, n3 n, n1 mode) -> void {
  n32 rn = r(n);
-  n32 bitCount = list ? bit::count(list) : 16;
+  n16 rlist = list;
+  n32 bitCount = rlist ? bit::count(rlist) : 16;
+  n32 rnEnd = r(n) + bitCount * 4;

-  if(mode == 1 && !list.bit(n)) r(n) = r(n) + bitCount * 4;
+  if(mode == 1 && !rlist.bit(n)) r(n) = rnEnd;

-  u32 sequential = Nonsequential;
-  if(!list) {
-    if(mode == 1) r(15) = read(Word | sequential, rn);
-    if(mode == 0) write(Word | sequential, rn, r(15) + 2);
-  } else {
-    for(u32 m : range(8)) {
-      if(!list.bit(m)) continue;
-      if(mode == 1) r(m) = read(Word | sequential, rn);  //LDMIA
-      if(mode == 0) write(Word | sequential, rn, r(m));  //STMIA
-      rn += 4;
-      sequential = Sequential;
+  endBurst();
+  if(!rlist) rlist.bit(15) = 1;
+  for(u32 m : range(16)) {
+    if(!rlist.bit(m)) continue;
+    if(mode == 1) r(m) = read(Word, rn);  //LDMIA
+    if(mode == 0) {
+      write(Word, rn, r(m) + (m == 15 ? 2 : 0));  //STMIA
+      r(n) = rnEnd;  //writeback occurs after first access
    }
+    rn += 4;
  }

  if(mode) {
    idle();
  } else {
-    pipeline.nonsequential = true;
-    r(n) = r(n) + bitCount * 4;
+    endBurst();
  }
 }

 auto ARM7TDMI::thumbInstructionMoveRegisterOffset
 (n3 d, n3 n, n3 m, n3 mode) -> void {
  switch(mode) {
-  case 0: store(Word | Nonsequential, r(n) + r(m), r(d)); break;  //STR
-  case 1: store(Half | Nonsequential, r(n) + r(m), r(d)); break;  //STRH
-  case 2: store(Byte | Nonsequential, r(n) + r(m), r(d)); break;  //STRB
-  case 3: r(d) = load(Byte | Nonsequential | Signed, r(n) + r(m)); break;  //LDSB
-  case 4: r(d) = load(Word | Nonsequential, r(n) + r(m)); break;  //LDR
-  case 5: r(d) = load(Half | Nonsequential, r(n) + r(m)); break;  //LDRH
-  case 6: r(d) = load(Byte | Nonsequential, r(n) + r(m)); break;  //LDRB
-  case 7: r(d) = load(Half | Nonsequential | Signed, r(n) + r(m)); break;  //LDSH
+  case 0: store(Word, r(n) + r(m), r(d)); break;  //STR
+  case 1: store(Half, r(n) + r(m), r(d)); break;  //STRH
+  case 2: store(Byte, r(n) + r(m), r(d)); break;  //STRB
+  case 3: r(d) = load(Byte | Signed, r(n) + r(m)); idle(); break;  //LDSB
+  case 4: r(d) = load(Word, r(n) + r(m)); idle(); break;  //LDR
+  case 5: r(d) = load(Half, r(n) + r(m)); idle(); break;  //LDRH
+  case 6: r(d) = load(Byte, r(n) + r(m)); idle(); break;  //LDRB
+  case 7: r(d) = load(Half | Signed, r(n) + r(m)); idle(); break;  //LDSH
  }
 }

 auto ARM7TDMI::thumbInstructionMoveStack
 (n8 immediate, n3 d, n1 mode) -> void {
  switch(mode) {
-  case 0: store(Word | Nonsequential, r(13) + immediate * 4, r(d)); break;  //STR
-  case 1: r(d) = load(Word | Nonsequential, r(13) + immediate * 4); break;  //LDR
+  case 0: store(Word, r(13) + immediate * 4, r(d)); break;  //STR
+  case 1: r(d) = load(Word, r(13) + immediate * 4); idle(); break;  //LDR
  }
 }

 auto ARM7TDMI::thumbInstructionMoveWordImmediate
 (n3 d, n3 n, n5 offset, n1 mode) -> void {
  switch(mode) {
-  case 0: store(Word | Nonsequential, r(n) + offset * 4, r(d)); break;  //STR
-  case 1: r(d) = load(Word | Nonsequential, r(n) + offset * 4); break;  //LDR
+  case 0: store(Word, r(n) + offset * 4, r(d)); break;  //STR
+  case 1: r(d) = load(Word, r(n) + offset * 4); idle(); break;  //LDR
  }
 }

@@ -198,33 +200,28 @@ auto ARM7TDMI::thumbInstructionSoftwareInterrupt
 auto ARM7TDMI::thumbInstructionStackMultiple
 (n8 list, n1 lrpc, n1 mode) -> void {
  n32 sp = r(13);
-  n32 bitCount = (list | lrpc) ? (bit::count(list) + lrpc) : 16;
+  n16 rlist = list;
+  if(lrpc) {
+    if(mode == 1) rlist.bit(15) = 1;  //POP
+    if(mode == 0) rlist.bit(14) = 1;  //PUSH
+  }
+  n32 bitCount = rlist ? bit::count(rlist) : 16;
  if(mode == 1) r(13) = r(13) + bitCount * 4;  //POP
  if(mode == 0) sp = sp - bitCount * 4 + 0;    //PUSH

-  u32 sequential = Nonsequential;
-  if(bitCount == 16) {
-    if(mode == 1) r(15) = read(Word | sequential, sp);      //POP
-    if(mode == 0) write(Word | sequential, sp, r(15) + 2);  //PUSH
-  } else {
-    for(u32 m : range(8)) {
-      if(!list.bit(m)) continue;
-      if(mode == 1) r(m) = read(Word | sequential, sp);  //POP
-      if(mode == 0) write(Word | sequential, sp, r(m));  //PUSH
-      sp += 4;
-      sequential = Sequential;
-    }
-  }
-  if(lrpc) {
-    if(mode == 1) r(15) = read(Word | sequential, sp);  //POP
-    if(mode == 0) write(Word | sequential, sp, r(14));  //PUSH
+  endBurst();
+  if(!rlist) rlist.bit(15) = 1;
+  for(u32 m : range(16)) {
+    if(!rlist.bit(m)) continue;
+    if(mode == 1) r(m) = read(Word, sp);  //POP
+    if(mode == 0) write(Word, sp, r(m) + (m == 15 ? 2 : 0));  //PUSH
    sp += 4;
  }

  if(mode) {
    idle();
  } else {
-    pipeline.nonsequential = true;
+    endBurst();
    r(13) = r(13) - bitCount * 4;  //PUSH
  }
 }
@@ -1,14 +1,16 @@
 auto ARM7TDMI::idle() -> void {
-  pipeline.nonsequential = true;
+  endBurst();
  sleep();
 }

 auto ARM7TDMI::read(u32 mode, n32 address) -> n32 {
-  return get(mode, address);
+  n32 word = get(mode, address);
+  nonsequential = false;  //allows burst transfer to continue
+  return word;
 }

 auto ARM7TDMI::load(u32 mode, n32 address) -> n32 {
-  pipeline.nonsequential = true;
+  endBurst();
  auto word = get(Load | mode, address);
  if(mode & Half) {
    address &= 1;
@@ -23,17 +25,17 @@ auto ARM7TDMI::load(u32 mode, n32 address) -> n32 {
  } else {
    word = ROR(word, address.bit(0,1) << 3);
  }
-  idle();
  return word;
 }

 auto ARM7TDMI::write(u32 mode, n32 address, n32 word) -> void {
-  pipeline.nonsequential = true;
-  return set(mode, address, word);
+  set(mode, address, word);
+  nonsequential = false;  //allows burst transfer to continue
+  return;
 }

 auto ARM7TDMI::store(u32 mode, n32 address, n32 word) -> void {
-  pipeline.nonsequential = true;
+  endBurst();
  if(mode & Half) { word &= 0xffff; word |= word << 16; }
  if(mode & Byte) { word &= 0xff; word |= word << 8; word |= word << 16; }
  return set(Store | mode, address, word);
@@ -14,20 +14,24 @@ inline auto ARM7TDMI::r(n4 index) -> GPR& {
  case 11: return processor.cpsr.m == PSR::FIQ ? processor.fiq.r11 : processor.r11;
  case 12: return processor.cpsr.m == PSR::FIQ ? processor.fiq.r12 : processor.r12;
  case 13: switch(processor.cpsr.m) {
+    case PSR::USR: return processor.r13;
    case PSR::FIQ: return processor.fiq.r13;
    case PSR::IRQ: return processor.irq.r13;
    case PSR::SVC: return processor.svc.r13;
    case PSR::ABT: return processor.abt.r13;
    case PSR::UND: return processor.und.r13;
-    default: return processor.r13;
+    case PSR::SYS: return processor.r13;
+    default: return processor.rNULL;
  }
  case 14: switch(processor.cpsr.m) {
+    case PSR::USR: return processor.r14;
    case PSR::FIQ: return processor.fiq.r14;
    case PSR::IRQ: return processor.irq.r14;
    case PSR::SVC: return processor.svc.r14;
    case PSR::ABT: return processor.abt.r14;
    case PSR::UND: return processor.und.r14;
-    default: return processor.r14;
+    case PSR::SYS: return processor.r14;
+    default: return processor.rNULL;
  }
  case 15: return processor.r15;
  }
@@ -46,7 +50,7 @@ inline auto ARM7TDMI::spsr() -> PSR& {
  case PSR::ABT: return processor.abt.spsr;
  case PSR::UND: return processor.und.spsr;
  }
-  throw;
+  return processor.spsrNULL;
 }

 inline auto ARM7TDMI::privileged() const -> bool {
@@ -3,6 +3,7 @@ auto ARM7TDMI::serialize(serializer& s) -> void {
  s(pipeline);
  s(carry);
  s(irq);
+  s(nonsequential);
 }

 auto ARM7TDMI::Processor::serialize(serializer& s) -> void {
@@ -23,6 +24,8 @@ auto ARM7TDMI::Processor::serialize(serializer& s) -> void {
  s(r14.data);
  s(r15.data);
  s(cpsr);
+  s(rNULL.data);
+  s(spsrNULL);
  s(fiq.r8.data);
  s(fiq.r9.data);
  s(fiq.r10.data);
@@ -54,11 +57,11 @@ auto ARM7TDMI::PSR::serialize(serializer& s) -> void {
  s(c);
  s(z);
  s(n);
+  s(readonly);
 }

 auto ARM7TDMI::Pipeline::serialize(serializer& s) -> void {
  s(reload);
-  s(nonsequential);
  s(fetch.address);
  s(fetch.instruction);
  s(fetch.thumb);