Clean up the sequencer firmware somewhat, trying to look for this Amiga write

issue.
2025-10-24 11:11:02 -07:00 · 2021-07-09 21:25:58 +01:00
978 changed files with 42001 additions and 160018 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,44 +0,0 @@
---
-AccessModifierOffset: -4
-AlignAfterOpenBracket: DontAlign
-AlignArrayOfStructures: Left
-AlignEscapedNewlines: Left
-AllowAllArgumentsOnNextLine: 'true'
-AllowAllConstructorInitializersOnNextLine: 'false'
-AllowAllParametersOfDeclarationOnNextLine: 'true'
-AllowShortBlocksOnASingleLine: 'true'
-AllowShortCaseLabelsOnASingleLine: 'false'
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLambdasOnASingleLine: None
-AllowShortLoopsOnASingleLine: 'false'
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: 'true'
-AlwaysBreakTemplateDeclarations: 'Yes'
-BinPackArguments: 'false'
-BinPackParameters: 'false'
-BreakBeforeBraces: Allman
-BreakConstructorInitializers: 'AfterColon'
-BreakInheritanceList: AfterColon
-BreakStringLiterals: 'true'
-ColumnLimit: '80'
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-FixNamespaceComments: 'false'
-IncludeBlocks: Preserve
-IndentCaseLabels: 'true'
-IndentWidth: '4'
-IndentWrappedFunctionNames: 'false'
-KeepEmptyLinesAtTheStartOfBlocks: 'true'
-NamespaceIndentation: All
-PointerAlignment: Left
-ReflowComments: 'true'
-SortIncludes: 'false'
-SortUsingDeclarations: 'true'
-SpaceAfterTemplateKeyword: 'true'
-SpaceBeforeAssignmentOperators: 'true'
-SpaceBeforeCtorInitializerColon: 'false'
-SpaceBeforeInheritanceColon: 'true'
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: 'false'
-...
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -2,123 +2,53 @@ name: C/C++ CI

 on: [push]

-concurrency: 
-  group: environment-${{ github.head_ref }}
-  cancel-in-progress: true
-
 jobs:
  build-linux:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v1
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v4
-      with:
-        repository: 'davidgiven/fluxengine-testdata'
-        path: 'fluxengine-testdata'
+        fetch-depth: 1
    - name: apt
-      run: |
-        sudo apt install libudev-dev libsqlite3-dev protobuf-compiler libwxgtk3.0-gtk3-dev libfmt-dev libprotobuf-dev wx-common
+      run: sudo apt update && sudo apt install libusb-1.0-0-dev libsqlite3-dev ninja-build protobuf-compiler
    - name: make
-      run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j`nproc` -C fluxengine
+      run: make

-  build-linux-debian-11:
-    runs-on: ubuntu-22.04
-    container: debian:11
+  build-macos:
+    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v4
-      with:
-        repository: 'davidgiven/fluxengine-testdata'
-        path: 'fluxengine-testdata'
-    - name: apt update
-      run: apt update
-    - name: apt
-      run: >
-        apt install -y python3 make xz-utils python3 python3-hamcrest
-        protobuf-compiler libprotobuf-dev libsqlite3-dev
-        libfmt-dev libprotobuf-dev wx-common pkg-config
-        libudev-dev g++ libwxgtk3.0-gtk3-dev
-    - name: make
-      run: make -C fluxengine
-      
-  build-macos-current:
-    strategy:
-      matrix:
-        runs-on: [macos-13, macos-latest]
-    runs-on: ${{ matrix.runs-on }}
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v4
-      with:
-        repository: 'davidgiven/fluxengine-testdata'
-        path: 'fluxengine-testdata'
+        fetch-depth: 1
    - name: brew
-      run: |
-        brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
+      run: brew install sqlite pkg-config libusb ninja protobuf
    - name: make
-      run: gmake -C fluxengine -j2
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}.fluxengine.${{ runner.arch }}.pkg
-        path: fluxengine/FluxEngine.pkg
+      run: make

  build-windows:
    runs-on: windows-latest
-
+    defaults:
+      run:
+        shell: msys2 {0}
    steps:
-    - name: setup WSL
-      run: |
-        curl -L https://github.com/WhitewaterFoundry/Fedora-Remix-for-WSL/releases/download/40.1.0/Fedora-Remix-for-WSL-SL_40.1.0.0_x64_arm64.msixbundle -o fedora.msixbundle
-        unzip fedora.msixbundle Fedora-Remix-for-WSL-SL_40.1.0.0_x64.msix
-        unzip Fedora-Remix-for-WSL-SL_40.1.0.0_x64.msix install.tar.gz
-        wsl --update
-        wsl --set-default-version 2
-        wsl --import fedora fedora install.tar.gz
-        wsl --set-default fedora
-        wsl sh -c 'dnf -y install https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-40-1.noarch.rpm'
-        wsl sh -c 'dnf -y install --setop=install_weak_deps=False gcc gcc-c++ protobuf-c-compiler protobuf-devel fmt-devel systemd-devel sqlite-devel wxGTK-devel mingw32-gcc mingw32-gcc-c++ mingw32-zlib-static mingw32-protobuf-static mingw32-sqlite-static mingw32-wxWidgets3-static mingw32-libpng-static mingw32-libjpeg-static mingw32-libtiff-static mingw32-nsis png2ico'
-
-    - name: fix line endings
-      run: |
-        git config --global core.autocrlf false
-        git config --global core.eol lf
-        
-    - uses: actions/checkout@v4
+    - uses: msys2/setup-msys2@v2
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-
-    - uses: actions/checkout@v4
+        update: true
+        msystem: MINGW32
+        install: >-
+          make
+          ninja
+          mingw-w64-i686-libusb
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-zlib
+          mingw-w64-i686-gcc
+          zip
+          mingw-w64-i686-protobuf
+          vim
+    - uses: actions/checkout@v1
      with:
-        repository: 'davidgiven/fluxengine-testdata'
-        path: 'fluxengine-testdata'
-
-    - name: run
+        fetch-depth: 1
+    - name: build
      run: |
-        wsl sh -c 'make -C fluxengine BUILDTYPE=windows -j$(nproc)'
+        make

-    - name: nsis
-      run: |
-        wsl sh -c 'cd fluxengine && strip fluxengine.exe -o fluxengine-stripped.exe'
-        wsl sh -c 'cd fluxengine && strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe'
-        wsl sh -c 'cd fluxengine && makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi'
-
-    - name: zip
-      run: |
-        wsl sh -c 'cd fluxengine && zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe'
-
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}.windows.zip
-        path: fluxengine/fluxengine-windows.zip
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,9 +1,5 @@
 name: Autorelease

-concurrency: 
-  group: environment-release-${{ github.head_ref }}
-  cancel-in-progress: true
-
 on:
  push:
    branches:
@@ -12,57 +8,42 @@ on:
 jobs:
  dev-release:
    runs-on: windows-latest
-
+    defaults:
+      run:
+        shell: msys2 {0}
    steps:
-    - name: setup WSL
-      run: |
-        curl -L https://github.com/WhitewaterFoundry/Fedora-Remix-for-WSL/releases/download/40.1.0/Fedora-Remix-for-WSL-SL_40.1.0.0_x64_arm64.msixbundle -o fedora.msixbundle
-        unzip fedora.msixbundle Fedora-Remix-for-WSL-SL_40.1.0.0_x64.msix
-        unzip Fedora-Remix-for-WSL-SL_40.1.0.0_x64.msix install.tar.gz
-        wsl --update
-        wsl --set-default-version 2
-        wsl --import fedora fedora install.tar.gz
-        wsl --set-default fedora
-        wsl sh -c 'dnf -y install https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-40-1.noarch.rpm'
-        wsl sh -c 'dnf -y install --setop=install_weak_deps=False gcc gcc-c++ protobuf-c-compiler protobuf-devel fmt-devel systemd-devel sqlite-devel wxGTK-devel mingw32-gcc mingw32-gcc-c++ mingw32-zlib-static mingw32-protobuf-static mingw32-sqlite-static mingw32-wxWidgets3-static mingw32-libpng-static mingw32-libjpeg-static mingw32-libtiff-static mingw32-nsis png2ico'
-
-    - name: fix line endings
-      run: |
-        git config --global core.autocrlf false
-        git config --global core.eol lf
-        
-    - uses: actions/checkout@v4
+    - uses: msys2/setup-msys2@v2
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-
-    - name: run
+        update: true
+        msystem: MINGW32
+        install: >-
+          make
+          ninja
+          mingw-w64-i686-libusb
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-zlib
+          mingw-w64-i686-gcc
+          zip
+          mingw-w64-i686-protobuf
+          vim
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 1
+    - name: build
      run: |
-        wsl sh -c 'cd fluxengine && make BUILDTYPE=windows -j$(nproc)'
-
-    - name: nsis
-      run: |
-        wsl sh -c 'cd fluxengine && strip fluxengine.exe -o fluxengine-stripped.exe'
-        wsl sh -c 'cd fluxengine && strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe'
-        wsl sh -c 'cd fluxengine && makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi'
-
+        make
    - name: zip
      run: |
-        wsl sh -c 'cd fluxengine && zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe'
-
+        zip -9 fluxengine.zip fluxengine.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
    - name: date
      run: |
        echo "RELEASE_DATE=$(date --rfc-3339=date)" >> ${GITHUB_ENV}
-
    - name: tag
      uses: EndBug/latest-tag@latest
      with:
        tag-name: dev
-        force-branch: false
-        git-directory: 'fluxengine'
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
    - name: delete-old-assets
      uses: mknejp/delete-release-assets@v1
      with:
@@ -70,62 +51,13 @@ jobs:
        tag: dev
        assets: | 
          fluxengine.zip
-          fluxengine-installer.exe
        fail-if-no-assets: false
-
    - name: release
      uses: softprops/action-gh-release@v1
      with:
        name: Development build ${{ env.RELEASE_DATE }}
        files: |
-          fluxengine/fluxengine.zip
-          fluxengine/fluxengine-installer.exe
+          fluxengine.zip
        tag_name: dev
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  build-macos:
-    strategy:
-      matrix:
-        runs-on: [macos-13, macos-latest]
-    runs-on: ${{ matrix.runs-on }}
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: brew
-      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
-
-    - name: make
-      run: |
-        gmake -j2
-        mv FluxEngine.pkg FluxEngine-${{ runner.arch }}.pkg
-
-    - name: tag
-      uses: EndBug/latest-tag@latest
-      with:
-        tag-name: dev
-        force-branch: false
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-    - name: delete-old-assets
-      uses: mknejp/delete-release-assets@v1
-      with:
-        token: ${{ github.token }}
-        tag: dev
-        assets: | 
-          FluxEngine-${{ runner.arch }}.pkg
-        fail-if-no-assets: false
-
-    - name: release
-      uses: softprops/action-gh-release@v1
-      with:
-        name: Development build ${{ env.RELEASE_DATE }}
-        files: |
-          FluxEngine-${{ runner.arch }}.pkg
-        tag_name: dev
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-
-
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,2 @@
 .obj
 .project
-/.ninja*
-/brother120tool
-/brother120tool-*
-/brother240tool
-/brother240tool-*
-/fluxengine
-/fluxengine-*
-/upgrade-flux-file
--- a/.hgignore
+++ b/.hgignore
@@ -1,5 +1,4 @@
 .obj
-.git
 streams
 .*\.flux
 .*\.img
--- a/FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
+++ b/FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
@@ -1,250 +1,250 @@
-:400000000080002011000000A1100000A1100000064A08B5136843F020031360044B1A6803F53F5302331A6001F058F8E8460040FA46004010B5054C237833B9044B13B173
-:400040000448AFF300800123237010BD6081FF1F00000000F0380000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF0000000021
-:400080006481FF1FF0380000C880FF1F000000000A4A0B4B116801310B40002BBEBF03F1FF3363F03F030133136011685368994202BF024B01221A72704700BF8081FF1FA4
-:4000C0003F0000800A4A0B4B516801310B40002BBEBF03F1FF3363F03F030133536051681368994202BF024B01221A72704700BF8081FF1F3F000080114BDA68196919B905
-:4001000001221A75597514E09969521A19698A4294BF587D00201875187D094908B1002204E0086982428CBF002201224A75DA689A611B7D13B1002002F082B9704700BF34
-:400140008081FF1F10B5C4B2204601F089F90128FAD110BD08B572B60F4B0F49DA680132DA60DA690132C82A08BF0022DA611A6AD8690132A72A08BF00220A621B6A002BEB
-:400180000CBF02230023002814BF184643F0010002F0DAFB62B608BD8081FF1F38B50446C5B2284602F0C4F8062002F099FD44F00200C0B202F0BCF8062002F091FD284602
-:4001C00002F0B6F8BDE83840062002F073BD10B5642402F0A7F828B9FFF7E0FF013CF8D1204610BD012010BD70B5C4B2054620460E4601F035F9012805D0204601F04EFAE3
-:400200002846FFF79FFF204601F032F9314605460246204601F0EEF9204601F021F90028FAD1284670BD000038B5044D0024285D013402F005FD402CF9D138BDA481FF1F75
-:4002400008B502F0FDF9002002F006FA02F018FA02F022FA80B208BD10B50446012002F07FF8642002F026FDFFF7EAFF2080002002F076F8642002F01DFDFFF7E1FF608047
-:4002800010BD08B502F008FB002002F011FB02F023FB02F02DFB80B208BD10B50446FFF796FF322002F006FDFFF7EBFF20800120FFF774FF322002F0FDFCFFF7E2FF6080A1
-:4002C00010BD0FB400B593B014AB53F8042B402102A8019302F0F4FE02A802F0BEF802F0C8F813B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF723FF62787E
-:400300002146BDE81040042001F002B90C3A000007B50023ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB000010B5074C94F8643043B1002001F0ECFF79
-:40034000002002F083F8002384F8643010BD00BF8081FF1F38B5124D837895F8672004469A4204D0FFF7E4FF002385F86A302368C5F8653022790B4B1A71A378002B14BF38
-:400380000220012002F062F8E078B0FA80F0400902F0D4FA2079BDE8384002F0DBBA00BF8081FF1FE581FF1F38B50D4C94F8645065B904F16500FFF7CDFF012001F0ACFF17
-:4003C0004FF47A7002F076FC84F86A50E368E366012384F86430BDE8384002F0A9BC00BF8081FF1FF8B5214C0546FFF7DDFF94F86A3003B15DB91E48FFF763FFFFF7E7FE5C
-:400400000120002384F86A00236702F069FC2A46216F1848FFF755FF144E0027236F9D4216D001F07FFF00B13767236F9D4205DD0120FFF7B3FE336F013305E005DA002094
-:40044000FFF7ACFE336F013B336702F071FCE5E7322002F02FFC2A2DCCBF0020012002F07FFABDE8F8400448FFF72BBF8081FF1F193A0000203A00003D3A00002DE9F04F9B
-:4004800099B062B602F0BEFC9F49042002F0E2FC9E4801F053FF9E4801F084FF9D4801F0B1FF02F06DF902F03FF8002001F0CEFF01F0D2FF0221002000F088FF012001F05D
-:4004C00001F9954D0321084602F012FC2E462C4602F02EFC95F8643043B1EA6EEB689B1A41F28832934201D9FFF722FF00F0A6FF18B98A48FFF7E5FE04E000F0A5FF0028D3
-:40050000F7D134E000F09AFF10B902F011FCF9E78348FFF7D6FE032001F0C0F88148FFF7D0FE002386F86730FFF73EFFFFF74FFE86F87400FFF7FCFE012386F86730FFF701
-:4005400033FFFFF744FE86F87500FFF7F1FE96F874007549754B96F87520002A14BF0A461A46002808BF19467148FFF7AAFE032000F076FF0128ABD16E48FFF7EBFE6E49CB
-:400580000320FFF731FE94F876106C48FFF799FE94F87630023B142B00F2D783DFE813F01500D5031E00D5032400D5035000D5037600D503DA00D503C201D5030903D50356
-:4005C0002D03D5033403D5034E0303238DF820308DF8213011238DF822302BE394F87800FFF700FF564B22E340F2DC57FFF7DCFE00232375E068227D02F0FF012AB9EB680B
-:400600001B1ABB42F7DD0B4611E083B10022174696F87810F068277594F814E0BEF1000F02D1EB681B1AF7E701329142F3DA07228DF8202004228DF82120ADF82230F9E2BF
-:400640000220FFF77FFD4FF000080DF1200A02F06FFB4FF480790027C9EB0803DA1907F80A200137402FF9D10220FFF76BFD3A465146022000F04CFFB9F10109EBD108F10F
-:400680000108B8F1400FE2D12E4B38E04FF0010A4FF000080DF1200B02F04AFB4FF0000959460120FFF7A0FD08EB090300270493049B1BF807203B44DBB29A4209D08DE89D
-:4006C0000C0041463B464A461F48FFF7FAFD4FF0000A0137402FEBD109F10109B9F5807FDED108F10108B8F1400FD5D151461748FFF7E7FDBAF1000F00F01C81144B1B883D
-:4007000007A8ADF81C3096E255010000F900000091000000C50000008081FF1F523A0000653A00006F3A00004B3A00004F3A0000823A0000E581FF1FF681FF1F9A3A000052
-:40074000F4380000F6380000A93A0000C53A0000F8380000206FFFF745FE94F8780001F0FFFD94F8780001F0E3FD02F015FCB94BDFF8FC821A78002702F0FB021A701A785F
-:4007800042F001021A701A7802F0FE021A701A7802F0FE021A7002F003FC0220FFF7D2FC012141F6FF734FF48042084601F0DEFD84F8B60002F02AFA08F807000137402FA7
-:4007C000F8D1DFF8B0A200270AF195091FFA89F80137402F14BF3A4600221AF8010F2244062392F82420402102F044FA424646F24E419AF8000002F04FFA08F14008402FB5
-:400800001FFA88F8E4D196F8793053B196F87C30336100233375237D002BFCD000233375336100234FF0FF32236062602372236894F8B600234493F8241002F09FF994F82A
-:40084000B60002F05DF9012194F8B60002F030F92368002BFCD0002398467360D6F80CA0012702F065FAE368B4F87A20CAEB030393420DD367B1042195F8B60002F08AF9BC
-:4008800094F8B60002F096F90028F9D107463072237AFBB96A682B689A4202D1002FE0D118E00220FFF74EFC6968402209EB8111022000F02DFE6A68674B01321340002BCA
-:4008C000BEBF03F1FF3363F03F03013308F101086360C6E70220277AFFF734FC00221146022000F015FE0220FFF72CFCFFB2FFF79BFC002001F01CFD37B15848FFF7E1FC90
-:400900000220FFF705FD06E0554B08A81B88ADF82030FFF7EBFC227D4146237A5148FFF7D0FC15E25048FFF7CCFCD4F87A7017F03F0701D0032009E2286FFFF753FD95F83B
-:40094000780001F00DFD95F8780001F0F1FC012001F098FD02F020FB444BDFF814811A7842F004021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F0BF
-:400980000FFB01214FF4804341F6FF72084601F01DFD85F8B60002F039F908F807000137402FF8D1DFF8CC90002709F195031FFA83F804930137402F14BF3A46002219F8F2
-:4009C000010F2244052392F82420402102F052F9414646F2484299F8000002F05DF908F14008402F1FFA88F8E4D100274FF0FF33376098467360BB463B46D6F87A903772EA
-:400A00005FEA99190CBF4FF0010A4FF0000A2168114A01310A40002ABCBF02F1FF3262F03F026068B8BF013282426FD02BB1227A002A7AD12A7D002A77D12068049A059368
-:400A400002EB8010BAF1000F16D040223F2102F003FB1CE09E6400403F000080CF3A0000FA380000E93A0000FC3A000098640040A481FF1FA381FF1F014601370120FFF7BF
-:400A8000B3FBC7EB0903D3F1000A4AEB030A2168B34A01310A40002ABEBF02F1FF3262F03F02013222606268059B01322ED12A683F2A2BD14FF00008C5F8048001F0B4FCE9
-:400AC00085F808806B6895F8B6002B4493F8241002F054F895F8B60002F012F8012195F8B60001F0E5FF95F87E302B6185F81480237D002BFCD04FF00008012086F814800D
-:400B000001F09EFC404601F0BDFC00E023B1237A5BB92B7D4BB90123626842453FF477AF0BF1010BD5F8048071E701F083FC012001F0A8FC002001F083FC042194F8B6004D
-:400B400002F028F894F8B60002F034F880460028F8D196F8B60001F0C1FF337D327A0293012303920193CDF800A05B463A4649467C48FFF7A6FBC6F81080BAF1000F0BD0C6
-:400B8000FFF752FB002001F0D3FB237A63B17648FFF797FB0220D9E0B945F1D073490120FFF722FB0137F7E77148FFF78AFB714B3DE094F8780001F0D3FB206FFFF712FC19
-:400BC0006D48FFF77EFB94F87930236100232375237D002BFCD0012001F032FC00233375237D002BFCD0002001F02AFC002363483361FFF766FB624B19E0002084F86A0088
-:400C0000FFF7F0FB5F4B12E094F8743023B195F875200AB985F8782094F875201AB113B9012385F878305848FFF794FB574B1B88ADF8203008A8FFF759FB89E0FFF778FB0D
-:400C400001F01CFE002001F0BFFD2A2701F0EAFC002001F08DFC3A46002108A802F0FCF917238DF820308DF8217002F061F8002001F052FB002001F0E9FBC82002F01AF8F3
-:400C80000DF12200FFF7E8FA0DF13600FFF705FB02F04EF8012001F0D9FB322002F00AF80DF12600FFF7D8FA0DF13A00FFF7F5FA012001F031FB4FF4967001F0FBFF02F041
-:400CC00037F80DF12E00FFF7C7FA0DF14200FFF7E4FA002001F020FB4FF4967001F0EAFF02F026F8022001F0B1FB322001F0E2FF0DEB0700FFF7B0FA0DF13E00FFF7CDFAF4
-:400D0000012001F009FB4FF4967001F0D3FF02F00FF80DF13200FFF79FFA0DF14600FFF7BCFA002001F0F8FA4FF4967001F0C2FF01F0FEFF002001F089FB002384F86A302F
-:400D400001F01EFD01F0F0FB74E70120FFF7E0FA032000F0A3FC0E48FFF7B3FAFFF7B8BB3F000080063B0000363B00003892FF1F403B0000FC380000483B0000563B00000F
-:400D8000FE38000000390000F681FF1F02390000633B00000F4B1A78120616D55878C0B2012814D11B79DBB2042B02D0052B05D07047094A094B5A60282203E0084A074B07
-:400DC0005A60E0221A8000F043BE002070470120704700BF0060004004390000BC92FF1F2C3900002DE9F04172B6884B61221A70A3F5F06301221A801924854A9C7092E807
-:400E000003008033062283F8002283E80300522203F580731A707F4B7F4A1B787F4EDBB2137040F618027E4B00251A8041F2512223F8022C33784FF4F07003F0010343EAA4
-:400E4000450502F0A1F8013C05F003052ED0032DF0D1744B4FF480721A8007221A70724A002548211570917002221D705D7103F8032C0422DA716D4A6D4C13786D4E43F060
-:400E80000103137012F8013C062743F0030302F8013C2378012243F0800323705B4B1A70654A137843F02003137000E0FEE707FB056300219A881868013502F0CDF8072D6A
-:400EC000F5D15E485E4E002550F8041F05F1105303F14A0221F0FF074B33C9B20B4452005B0002329A4206D012F802EC12F801CC0EF807C0F5E7B0420D44E5D1514A002390
-:400F000013609360136193614F4B504F1A68504BDFF888811A604F4B1A684F4B1A604F4A137843F002031370137C43F0020313742378A2F5863243F040032370413A1378DD
-:400F400043F010031370464A464B07CA03C31A80454A2833106843F8250C127903F8212C424A07CA03C31A80414AE83B07CA03C31A80404A083307CA03C31A803E4A3F4B11
-:400F8000A2F5616203CBC2F8100EC2F8141E1378042043F008031370394B02F5AA521B783D78DBB298F80060EDB203F007010C321B091170F6B2537045F003033B7046F095
-:400FC000030388F800302F4B48221A702E4A402313702E49937013729372082382F81F3220220A7048710A72294A0A20137001F077FE284B88F8006044223D70264D1A709B
-:4010000094E80F0007C52B80BDE8F08100480040680A00480F010049A146004025420040224200400440004006400040A2430040A0430040683B0000E8460040FCFFFF47E7
-:401040009000004800760040700A0048F846004020760040740A00482876004003500140280A0048C0510040340A00483C0A0048480A0048540A004832510040600A004800
-:40108000CF0100491D51004001590040235B0040585B004076580040B0430040F946004008B501F0ADFF03680C2B00D1FEE7FEE7084908B50B68084A1844821A802A01DC75
-:4010C000086005E001F09CFF0C2303604FF0FF33184608BDCC80FF1F8893FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F8046BF7E7E8
-:40110000114653F8046C8C1AA64202D041F8045BF9E701381033E5E701F078FFFFF7AEF9FEE700BF01000000FC3C0000124A134B10B51A60124A134C1368134843F4007367
-:4011400013600023032B98BF54F823204FEA830188BF0E4A0133302B4250F3D10C4B1A780C4B1A700C4B084A1A60FFF73BFEBDE8104001F087BC00BF0004FA050CED00E0A4
-:4011800014ED00E0000000000080FF1FA1100000BC760040C080FF1F08ED00E0F8B501F0FBFE4B4A01271378022643F001031370137C484C43F001031374474B02F5E352FA
-:4011C0001F700B3203F8946C1378054603F07F031370002001F084FD2378404A03F0F90323701378384603F0DF03137023783B43237001F075FD282001F072FD384B304610
-:401200001A7802F07F021A701A7802F0BF021A7023783343237001F063FD2378314A43F0040323700023137053702F4AFF2199540133092BFBD1284601F0B2FE07211720E7
-:4012400001F096FD2949172001F084FD0721182001F08EFD2649182001F07CFD0721152001F086FD2349152001F074FD0721052001F07EFD2049052001F06CFD072106201F
-:4012800001F076FD1D49062001F064FD0721084601F06EFD1A49072001F05CFD0721082001F066FD1749082001F054FD0021162001F05EFD1449162001F04CFD07210C2014
-:4012C00001F056FDBDE8F84010490C2001F042BDA5430040944300409D60004012600040F851004084600040AD92FF1F6B1B0000A5190000691B00009D1A0000C91A0000BE
-:40130000F91A0000311B0000711B0000E51B0000214B224A10B5187000231370204A40201370204A0F2413701F4A13701F4A13701F4A13701F4A13701F4B4FF400021A60B1
-:401340004FF080721A604FF400121A6020221A601860802018604FF480701860174804704FF480001860164B1A70933B19B91A7802F0FE0202E01A7842F001021A70114B50
-:4013800003221A70802203F8202C012001F0FCFD0D4B04221A7010BDC892FF1FCE92FF1FCC92FF1FCD92FF1FC992FF1FB892FF1FCB92FF1F4093FF1F00E100E09E6000407A
-:4013C0009C600040286000401260004070B5074C054623780E461BB9FFF7E0FE0123237031462846BDE87040FFF792BF7892FF1F0A4A002313700A4A13700A4A13700A4A81
-:4014000013700A4A13700A4A13700A4A13700A4B03221A70802203F8202C7047CE92FF1FCC92FF1FCD92FF1FC992FF1FB892FF1FCB92FF1F4093FF1F28600040014B187898
-:40144000704700BFCD92FF1F044B1A7802F0FF001AB118780022C0B21A707047CC92FF1F024A0C2303FB002040787047D492FF1F431E072B0CD8074A064B00010344805C32
-:401480005B7800F00F0043EA0020023880B2704700207047FC5F00401A4A38B50C2303FB00231B79090C13F0800F00F1FF35044619BF8AB24FF480438BB24FF48042032DA1
-:4014C00018D8DFE805F002070C110021084601F0A1FA0DE00021084601F080FA08E00021084601F05FFA03E00021084601F03EFA054B1855EDB2072D03D801F087FB034B10
-:40150000185538BDD492FF1FA492FF1FAD92FF1F431E072B2DE9F0470446894615465CD82F4F0C2202FB0072D388DFF8B8A09BB2C3F500739D424FF00C0303FB007388BF8A
-:40154000D588DB7884BFC5F50075ADB2254A43EA15230601B354B244EBB28AF80130224B1A5C9846FF2A01D1FFF796FF0C2303FB047200215170B9F1000F28D03DB31B4FEB
-:40158000385D01F0ABFA11232946FE2218F8040001F070FB06F5C04278321FFA89F118F8040001F079FB124D18F80410385D01F0E5FA0121385D01F07BFA735D43F002030D
-:4015C0007355735D03F0FD037355BDE8F08703FB04746379DBB28AF80230BDE8F08700BFD492FF1FFC5F0040AD92FF1FA492FF1F706000402DE9F047044615468846002945
-:4016000040D0431E072B3FD8FFF732FFA84203D22046FFF72DFF05461D4E335DFF2B03D141462046FFF738FFDFF868A027011AF8040001F053FA1223FE222946305D01F087
-:4016400019FB07F5C0411FFA88F27831305D01F023FBDFF84490315D1AF8040001F08EFA01211AF8040001F023FA17F8093043F0020307F8093017F8093003F0FD0307F881
-:40168000093002E00D4600E000252846BDE8F087AD92FF1FA492FF1F70600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B200011A54704700BFD492FF1F5D
-:4016C000FE5F0040431E072B9FBF024B000108221A547047FE5F004030B51A4A1A491B4D0878138803449BB21380194A00231488D8B2A4B27CB1082B0CD050680078C0B2EC
-:40170000E85450680133013050601088013880B21080ECE718460B780E4C082B0E4A00D040B10E4D2B7883F080032B700F232370022301E0022323701370094B18700870CA
-:4017400030BD00BF4493FF1F4093FF1F00600040BC92FF1FB992FF1FCE92FF1FCA92FF1F4193FF1F074B02221A70074B80221A70064B0F221A70064A00231370054A012088
-:4017800013707047CE92FF1FCA92FF1FB992FF1F4093FF1F4193FF1F30B5164B16491B780A8803F00F03023BDBB21A4492B20A80124C134A0020118889B279B173B155682C
-:4017C000215C013BC9B229705168DBB20131516011880130013989B21180ECE7094A1370094A137883F080031370084B0B221A7030BD00BF296000404493FF1F006000400F
-:40180000BC92FF1F4193FF1FCA92FF1FB992FF1F064A06231370064A01201370054B80221A70054B00221A70704700BFCE92FF1FB992FF1FCA92FF1F4193FF1F054B9A68E4
-:401840003AB19A68044910709A680988518000229A607047BC92FF1F4493FF1F08B5124B1A78D2B21A701B78DBB21A0602D50F4A137008BD0220FFF7E1FF0D4B1B7803F0CE
-:401880006003202B05D0402B06D043B900F012FC04E001F089FB01E0FFF77CFA10B9034B03221A7008BD00BF28600040B992FF1F0060004008B5084A084B012019781388FA
-:4018C0000B449BB21380064B00221A70FFF7B6FF044B03221A7008BD4493FF1F4093FF1FCE92FF1FB992FF1F08B50C4B1B78DBB2042B07D0062B09D0022B0DD1BDE8084045
-:40190000FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A7008BD00BFCE92FF1FB992FF1F08B5054B002201201A70FFF785FF034B03221A7008BD00BFCE92FF1FCA
-:40194000B992FF1F08B50A4B1A7832B11A78094942F080020A7000221A70074B002201201A70FFF76BFF054B03221A7008BD00BFB892FF1F08600040CE92FF1FB992FF1FC0
-:40198000074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF7C5BFFFF7D3BF7047CE92FF1F38B51D4C2378DBB2DD0634D518060AD503F00F03012B2ED1FFF74EFF42
-:4019C000174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5FFF786FF23781B061BD4104B1A78104B1B7813430F4A13701278934211D10A4A0849154613782078EB
-:401A0000DBB2000605D41378DBB20B700B7803F00F0328788342F1D138BD38BD28600040B992FF1FCA92FF1F4193FF1F29600040054A00231380054A916819B191680B701D
-:401A400092685380704700BF4493FF1FBC92FF1F0E4808B503889BB213B9FFF783FE13E00B4B02221A700B4B00221A70FFF7E0FF094AD1799379028843EA012392B2934229
-:401A800038BF0380FFF728FE012008BDBC92FF1FCE92FF1FCA92FF1F00600040084B01221A700F3B9B7C074B1A7B02F00302012A1EBFDA7B82F08002DA7301225A73704722
-:401AC0000B600040D492FF1F094B02221A700F3B93F82230074B1A7E02F00302012A1EBFDA7E82F08002DA7601225A76704700BF0B600040D492FF1F0B4B04221A700F3B21
-:401B000093F83230094B93F8242002F00302012A1EBF93F8272082F0800283F82720012283F82520704700BF0B600040D492FF1F0B4B08221A700F3B93F84230094B93F856
-:401B4000302002F00302012A1EBF93F8332082F0800283F83320012283F83120704700BF0B600040D492FF1F7047FFF741BC0000F0B5184B184E19780C27C9B201234FF028
-:401B8000000C31B3CA0720D5144A4FEA031E7244947850782040C5070DD507FB03652C79240608D5147804F0FE0414706D790C4CEDB204F80E50840706D507FB036425795F
-:401BC0002D0658BF84F801C090700133DBB24908D7E7F0BD9F600040D492FF1F70600040FE5F004000F032BF70B50446184B88B003AA03F11006154618685968083303C530
-:401C0000B3422A46F7D11B782B70FCB12223237001AD03232846637001F024F9002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143C0132082AB1
-:401C4000C1700371417100F10400EAD108B070BD923B00002DE9F0431C4D01222E460C201F274FF0800E4FF0080C194B00FB02581401234418705F70164998F8059021445B
-:401C8000B9F1000F07D098F8044024064CBF887081F802C001E081F802E000FB0261CC880132E4B29C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307215971D4D1CB
-:401CC000054BFF221A70BDE8F08300BFD492FF1F70600040FC5F00400A600040064B074A1B7802EBC30253681A7C824286BF03EBC003586900207047C892FF1FB83B000044
-:401D00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFA8463F4AC3681478007ADFF800C1E4B203EBC0000C2600274FF0010E834268D01A78A24263D11CF829
-:401D40000420597891425ED19A7893F8039002F07F0206FB02FA05EB0A01CF7093F802B009F0030981F804B093F803B005F80AB0B3F804A0A1F808A093F902A0BAF1000FB6
-:401D80000BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E009E0B9F1010F0CBF4FF005094FF0090981F805904F704FEA02191A4906FB0282494481F802E0B2F806
-:401DC00008A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F806A011495FFA8AFA494481F806A0B2F80690C9F3072981F80790B2F806905FFA89F981F80490D288FA
-:401E0000C2F307224A71083394E7BDE8F88F00BFCD92FF1FD492FF1FC992FF1FFC5F004070600040BA92FF1F08B5064B18780138C0B2FFF753FF20B143681B7900EBC3008A
-:401E4000406908BDCD92FF1F00212DE9F84F0B464E4E0C2707FB01F401313219092933554FF000059370494CD3701381937253705371EFD118B1464B1D70464B1D70464B16
-:401E80001A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8F8E0DB790C2713F0400F3E4B4FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB0541C368D0
-:401EC00003EB02094B4531D093F802A00AF07F06AE4229D10E89B3F804B0B6B25E4538BFA1F808B01E7893F801B01EF80660B3451AD181F804A0DE780E7093F902A0DE78D3
-:401F0000BAF1000F06F0030607DA012E0CBF07260D264E7181F8018006E0012E0CBF052609264E7181F801C00833CBE70135092DC3D1C1680A328B1C0A440C20083393423E
-:401F400009D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF767FF114B0121186000230C2000FB0142D3801289013113449BB203F00102134409299BB2F2D1BDE88B
-:401F8000F84FFFF767BEBDE8F88F00BFD492FF1FBA92FF1F4293FF1FCD92FF1FCB92FF1FD092FF1F114B1B7903F07F035A1E072A19D80F490C2202FB031291781B0141F08E
-:401FC000010191700021D170517841F002015170127912F0800F074A1A4414BF8D2389239370FFF715BC0020704700BF00600040D492FF1FFC5F004030B4194B1A7902F0D8
-:402000007F02531E072B27D8164B0C2404FB02339978154D01F0FE0199700021D97029461201505D114400F07F0050555A7802F0FD025A701A795B78120605D5012B01D167
-:402040008C7006E00D2303E0012B0CBF082309238B7030BCFFF7DCBB002030BC704700BF00600040D492FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2FFF72EFE80
-:4020800043681B798B4201D2012909D8074A0848535CDBB24354A3780120DBB2535410BD002010BDCD92FF1F00600040BA92FF1F4293FF1F38B5874A874C13780021DBB254
-:4020C00021801806517840F188800A2900F20081DFE811F05800FE00FE00FE00FE00FE000B00FE007900FE007D00D3787949012B09D17A4B1A787A4B03EBC2035B685B68FE
-:402100006360122310E0CB78022B12D18878FFF7E5FD002800F0DC80436863606368DA7863689B7843EA02232380BDE83840FFF78FBCCB78032B21D16A4B00228878D5B29B
-:40214000854203D3634A92783AB910E0187801320028F7D018780344F0E75E4A62499278097C914203D16148FFF73EFD5F4B1A78002A00F0AD801A78228018E0BDE8384099
-:4021800000F012BF13F0030313D0022B40F0A0802380504B0C211B7903F07F02544B01FB02339A78534BD2B21A7000225A706360BBE702222280504A11784E4AC9B2117026
-:4021C00053706260B1E7012323804C4BEFE70123238013794A4A1344E9E701390A2977D8DFE801F037764F76067676760A7620009378444ADBB25AE0937803F0FF0153B928
-:402200003E4B1A7891425FD019703F4B01201870FFF71AFE58E0481EC0B2FFF75FFD0028EED155E0FFF722FF002851D0294A374913791279DBB2D2B20A70354A3049D25C1E
-:40224000CB5C9A4240D0304B01221A70FFF758FD3AE003F00303012B2BD009D3022B37D11C4B9B78002B33D1BDE83840FFF7C4BE184B9B78012B2BD11F4A137803F0FD03CA
-:4022800015E003F00303012B13D008D3022B1FD1104B9B78E3B9BDE83840FFF783BE0D4B9B78012B14D1144A137843F0020313700AE0084B1A795AB998781B791549DBB239
-:4022C000CA5C22EA0002CA54BDE83840FFF7A0BA002038BD00600040BC92FF1FC892FF1FB83B00001C3C00008F3C00006093FF1FD492FF1F7992FF1FCB92FF1FCD92FF1FBA
-:40230000BA92FF1FB892FF1FCC92FF1FC992FF1F4293FF1FCF92FF1F014B1870704700BF72640040014B1878704700BF68650040014B1870704700BF7A650040064A0123C8
-:40234000136002F688321268E0211064034A1170A2F540721360704780E100E000E400E0014B1870704700BF7A64004073B515461E460B4C04230022019200920A46014658
-:402380001846237000F022FC32462946207800F0DDFB0221207800F0C7FB207802B070BDD080FF1F074A0223136002F688321268E0215064044A11706FF440710A44136017
-:4023C000704700BF80E100E001E400E073B515461E460B4C05230022019200920A4601461846237000F0F2FB32462946207800F0ADFB0221207800F097FB207802B070BD84
-:40240000D180FF1F064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B04221A60704700E100E0014B04221A60704780E100E013
-:40244000014B1870704700BF7B650040014B1870704700BF73640040704738B505460078012428B100F038FD285D0134E4B2F8E738BD08B50D2000F02FFDBDE808400A20C6
-:4024800000F02ABD014B1870704700BF7865004010B500F081FD204A044613780A2043F002031370137C43F00203137412F80A3C43F0010302F80A3C937943F0010393712B
-:4024C00002F5AB52137843F003031370134B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222183B1A70094A137843F0AA
-:402500000803137000F0ECFB064B10222046BDE810401A6000F044BDAB4300400E5900402F5B004080E200E008B500F035FD0F4A137803F0FE031370A2F5AA521D3A13785D
-:4025400003F0FD031370137C03F0FD03137412F80A3C03F0FE0302F80A3C937903F0FE039371BDE8084000F01BBD00BF08590040044A137803F03F0343EA8010C0B2107082
-:40258000704700BF08590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2E4
-:4025C000883103F6C41393FBF1F305490B60054B1A8070470A590040A43B00004A93FF1F4C93FF1F5093FF1F08B5102000F036FA0721042000F0BCFB0749042000F0AAFB02
-:40260000064A0C20137843F006031370FFF7BCFF034B00221A8008BDE1260000095900404893FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF72ABF7B92FF1FA6
-:40264000044B1A7802F0FB021A701A7842F001021A7070470859004010B5084B1C7814F0010403D10028F9D0002404E0204600F037FB024B1B78204610BD00BF09590040D9
-:40268000034A044B1B881088181A00B2704700BF5093FF1FA25B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F20223F1
-:4026C00091FBF3F30028D8BF5B42134493FBF1F000B270474A93FF1F4C93FF1F4893FF1F7047000010B500F057FC214A044613780A2043F001031370137C43F001031374BC
-:4027000012F80A3C43F0020302F80A3C937943F00203937102F5AA521832137843F003031370144B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CBE
-:40274000CE2203F8062CA3F597530222123B1A70094A137843F00803137000F0C1FA074B08222046BDE810401A6000F019BC00BFAB43004006590040275B004080E200E0CF
-:4027800008B500F009FC0F4A137803F0FE031370A2F5AA52153A137803F0FE031370137C03F0FE03137412F80A3C03F0FD0302F80A3C937903F0FD039371BDE8084000F0BB
-:4027C000EFBB00BF00590040044A137803F03F0343EA8010C0B21070704700BF00590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF095
-:40280000000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A80704702590040AE3B00005693FF1F5C93FF1F5493FF1FFC
-:4028400008B5102000F014F90721032000F090FA0749032000F07EFA064A0C20137843F006031370FFF7BCFF034B00221A8008BD39290000015900405893FF1F10B5054C6D
-:4028800023781BB9FFF7DCFF01232370BDE81040FFF728BF7C92FF1F044B1A7802F0FB021A701A7842F001021A7070470059004010B5084B1C7814F0010403D10028F9D0AE
-:4028C000002404E0204600F00BFA024B1B78204610BD00BF01590040034A044B1B881088181A00B2704700BF5493FF1FA05B00400E4A13881BB223B111880A2309B25943E7
-:4029000001E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270475693FF1F5C93FF1F5893FF1F70470000014B1870E9
-:40294000704700BF7B640040014B1870704700BF7F640040014B1870704700BF7C640040014B1870704700BF7E640040F7B516461F460B4C00230325019300930A460146B2
-:402980002846257000F022F93A463146207800F0DDF80221207800F0C7F8207803B0F0BDE080FF1FF7B516461F460B4C00230225019300930A4601462846257000F006F917
-:4029C0003A463146207800F0C1F82946207800F0ABF8207803B0F0BDE180FF1FF7B516461F460B4C00230125019300930A4601462846257000F0EAF83A463146207800F06F
-:402A0000A5F80221207800F08FF8207803B0F0BDE280FF1F73B515461E460B4C0023019300930A4601461846237000F0CFF832462946207800F08AF80221207800F074F880
-:402A4000207802B070BD00BFE380FF1F024B1878C0F38010704700BF8F450040034A00F0F800137803431370704700BF02410040034A00F0F800137803431370704700BF74
-:402A800006410040074A7F23802113705170064A013BDBB202F80839002BF9D1034A1370704700BFE480FF1FF87B00400078004017280FD8084B0001C25C11B142F020028D
-:402AC00001E002F0DF02C254C25C42F00102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C254C25C02F0DF02C25400207047012070471070004024
-:402B000017280DD8074900010B4603441A7942F004021A71435C43F00103435400207047012070471070004017280BD8064A0001835C490003F0F10301F00E0119438154A3
-:402B400000207047012070471070004041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F5EC4081809ABFC280002001207047000017289FBF6F
-:402B8000034B00011954002088BF0120704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120704700BF1470004017289FBF034B0001185C00F04D
-:402BC000070088BFFF20704714700040172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF8082003F00F0343EA0213DBB263709DF80C30002003F08B
-:402C00000F03A370E07010BD012010BD10B500F0C3F90A4A5378182B0AD91478013B5370E30003F1804303F5F0431B78137000E0FF2400F0B5F9204610BD00BFE480FF1F33
-:402C4000030610B5044611D400F0A6F9084AE300117803F1804303F5F04319705378147001335370BDE8104000F09AB910BD00BFE480FF1F30B504060CD411F4704509D1B0
-:402C8000C40004F1804404F5F0442180A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280002001207047000038B50446084DB4F5004F05D988
-:402CC000286800F061F9A4F50044F6E7034B58686043BDE8384000F057B900BFEC80FF1F024B1B7A584300F04FB900BFEC80FF1F0E4B00F003001A78490102F0FC02104300
-:402D000018701A7801F0600142F080021A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF83430040014B01221A70704784430040044B00F08C
-:402D40000F021B6853F8220043F82210704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BF08ED00E000F01F0000F16040490100F56440C9B29B
-:402D8000017070470F4B10B50F4900240F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72DB68B3FBF2F3084A1360084B4FF400421C60C3F883
-:402DC000E82010BD8092FF1F312E000010E000E0EC80FF1F14E000E018E000E0024A136843F002031360704710E000E008B5FFF7F5FF034A136843F00103136008BD00BFD3
-:402E000010E000E010B5054CA3691BB9FFF7BAFF0123A361BDE81040FFF7E8BF8092FF1F024B1868C0F30040704700BF10E000E038B5FFF7F5FF012808D1054D002455F891
-:402E4000243003B198470134052CF8D138BD00BF8492FF1F024B03EB80035868596070478092FF1F134B144A1B78DBB20360127843EA0223114A0360127843EA0243104A07
-:402E80000360127843EA026303600E4B0E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA02634360704700BF0301004904010049EC460040B2
-:402EC000020100490101004900010049050100490601004900000000FEB5494652465B460EB40746244909688A46244A12682448022100F071F8030020480068C018204936
-:402F000000F06AF8143883460121C9430C460125002600F041F8814651460B7823400B705846013000F030F83800F04028400B78234003430B70584600F026F80136072E00
-:402F4000F2D9002001300138013001200B78234003430B705846043000F016F8484600F01FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F6B
-:402F800000C20100000000000230800803D000BF01380046FCD17047EFF3108072B6704780F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F021C
-:402FC000044B01FB02339B7A00E013790020704700600040D492FF1F002902D0B0FBF1F0704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BFA1
-:40300000014B1868704700BF5C81FF1F0E4B70B51E460E4C0025E41AA410A54204D056F8253098470135F8E700F04EFE084B094C1E46E41AA4100025A54204D056F8253071
-:4030400098470135F8E770BDD43C0000D43C0000D43C0000DC3C000003460244934202D003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF432
-:403080000273ADF80C300CBF234604F1FF33029305934FF6FF7300910491ADF80E3002461E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000022
-:4030C00007B5009313460A46014603480068FFF7CBFF03B05DF804FB5C81FF1F2DE9F0478E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656977
-:4031000005EB450595FBF3F57B1C43449D4238BF1D4653050FD5294600F04AFB064698B13A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B9E0
-:403140002169504600F0E8FA0C23CAF80030A3894FF0FF3043F04003A381BDE8F08726613E44266046466561ED1BA560464528BF464649463246206800F0B3FAA3680020A9
-:403180009B1BA36023681E442660BDE8F08700002DE9F04F9DB003938B8980461C060D4616460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B6150
-:4031C0000023099320238DF82930DFF89CB130238DF82A3037463C4614F8013B1BB9B7EB060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780FE
-:40320000099B4B4409933B78002B00F0A08000234FF0FF3204930793059206938DF853301A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F0184379
-:403240000490EFE7D90644BF20228DF853201A0744BF2B228DF8532022782A2A03D0079A00210A200BE0039A111D12680391002A10DA524243F00200079204900BE027468C
-:403280003B780134303B092B03D800FB02320121F5E701B107923B782E2B1ED17B782A2B0AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781CA7
-:4032C0000A2407463A780130303A092A03D804FB01210123F5E703B1059103223978224800F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1CEB
-:403300008DF8281000F0D4F988B1194B33B9039B073323F007030833039314E003AB00932A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F12A
-:40334000FF3F824603D0099B5344099342E7AB895B0601D4099801E04FF0FF301DB0BDE8F08F00BFA33C0000A93C0000AD3C000000000000DD3000002DE9F04791461F4627
-:403380000A698B6806469342B8BF1346C9F8003091F843200C46DDF8208012B10133C9F800302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E05B
-:4033C0000123524639463046C04701301AD00135E368D9F800209B1A9D42F1DB94F843302268003318BF012392060FD5E118302081F843005A1C94F845102244023382F884
-:40340000431003E04FF0FF30BDE8F08704F1430239463046C0470130F4D02268D9F80050E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED1843
-:403440004FF000091A344D4509D00123224639463046C0470130D5D009F10109F3E70020BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8054
-:4034800011D8632A22D009D8002A00F0BB80582A40F0CA8081F84520834955E0642A1ED0692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A6091
-:4034C0003EE0752A24D0782A3AD0ADE01A6801F14205111D1960136884F84230A8E021681A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E045
-:403500001368002B3CDA2D225B4284F8432037E021681A6811F0800F02D0111D196007E011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE068
-:4035400078225A4984F845202268186812F0800F00F104051D6003D1550601D5038800E00368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E08A
-:4035800049490A226568002DA56008DB206820F0040020602BB9002D7DD175460CE0002B79D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0737
-:4035C00008D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0323612EE008681A6810F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198064
-:4036000000E0196000232361754616E01A68111D1960156800216268284600F049F808B1401B6060636804E004F1420584F8422001232361002384F84330CDF800803B468C
-:4036400003AA21463046FFF797FE013002D14FF0FF3026E023692A4639463046C0470130F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135CC
-:40368000E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B7804F1420584F842308AE705B0BDE8F083923B0000B43C000010B5C9B202449042034605D01C78013064
-:4036C0008C42F8D1184610BD002010BD10B5431E0A44914204D011F8014B03F8014FF8E710BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014DA2
-:4037000001F8014DF8E710BD994204D011F8014B02F8014FF8E710BD38B50546002944D051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A342E7
-:403740000DD92268A018834201BF18685B681218226063600C6023E0A24203D813465A68002AF9D118681918A1420BD12168014458188242196013D11068526801441960EE
-:403780005A600DE002D90C232B6009E021686018824201BF106852680918216062605C602846BDE8384000F098B838BDA092FF1F70B5CD1C25F0030508350C2D38BF0C2534
-:4037C000002D064601DBA94202D90C23336046E000F082F8234B1C681A462146A1B10B685B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4695
-:4038000015E00C464968E9E7174C23681BB9304600F052F820602946304600F04DF8431C18D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A48
-:403840000ED05A42E25070BD211A304600F034F80130EBD10C233360304600F03EF8002070BD00BFA092FF1F9C92FF1FF8B5074615460E4621B91146BDE8F840FFF798BFAB
-:403880001AB9FFF749FF2846F8BD00F027F885420ED929463846FFF78BFF044650B131462A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C002305467D
-:4038C00008462360FDF7F4FB431C02D1236803B12B6038BD8493FF1F7047704751F8040C0028BEBF091851F8043CC0180438704700000000050209020B020D020F021102BB
-:403900001302150228000000000104000100000000000000000157494E55534200003030303031000000000000000000E0000000000105000100D6000000070000002A0075
-:4039400044006500760069006300650049006E0074006500720066006100630065004700550049004400730000009E0000007B00330064003200370035006300660065004E
-:403980002D0035003400330035002D0034006400640035002D0061006300630061002D003900660062003900390035006500320066003600330038007D0000007B00330058
-:4039C00064003200370035006300660065002D0035003400330035002D0034006400640035002D0061006300630061002D00390066006200390039003500650032006600B4
-:403A00003600330038007D00000000007265706C792030782530327800686F6D696E6700626567696E6E696E67207365656B2066726F6D20256420746F2025640066696E14
-:403A40006973686564207365656B00796573006E6F0057616974696E6720666F72205553422E2E2E00555342207265616479005363616E6E696E67206472697665732E2E1C
-:403A80002E00647269766520303A20257320647269766520313A20257300636F6D6D616E6420307825303278006661696C2025642B25642B2564203D3D2025642C206E6F40
-:403AC00074202564007061737365643D256400756E64657272756E206166746572202564207061636B65747300636F756E743D256420693D256420643D256400636D645FEF
-:403B0000777269746500703D25642063723D25642063773D256420663D256420773D256420696E6465783D256420756E64657272756E3D256400756E64657272756E210015
-:403B4000737563636573730073746172742065726173696E670073746F702065726173696E670069646C650000510040100040510040300000000140001000140140000858
-:403B800000400140000A004C01400002005001402000303132333435363738394142434445460000000100000004000000100001000000040000001001000000C03B000072
-:403BC000010000008F3C0000000000000000000001000000D83B000001000000613C000004000000FA3B0000000000000000000000000000F83B0000FF0000000102400099
-:403C0000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500780045006E00670069006E0065002A0343006F0077006C00CE
-:403C4000610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010080320904000004FF00000107050102400000070582024000E5
-:403C8000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B2000686C4C00656667454647003031323334353637383961629E
-:403CC0006364656600000000F8B500BFF8BC08BC9E467047590000002D110000F8B500BFF8BC08BC9E46704735000000003D0000C880FF1F980000002812000000000000F3
-:403D0000000000008893FF1FFFFF0000675000400C00000007000000FFFFFFFF7F8000003F0000000000007D00FA0000400000000090D003000000000000000000000000EE
-:403D40000000000000000000000000000000000000000000A13C00000000000000000000000000000000000000000000000000000000000000000000000000000000000066
-:403D80000000000000000000000000000000000000000000FC80FF1F0000000000000000000000000000000000000000000000000000000000000000000000000000000069
+:4000000000800020110000004910000049100000064A08B5136843F020031360044B1A6803F53F5302331A6001F02CF8E8460040FA46004010B5054C237833B9044B13B14F
+:400040000448AFF300800123237010BD6881FF1F00000000D0380000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF0000000039
+:400080006C81FF1FD0380000C880FF1F000000000A4A0B4B116801310B40002BBEBF03F1FF3363F03F030133136011685368994202BF024B01221A72704700BF8881FF1FB4
+:4000C0003F0000800A4A0B4B516801310B40002BBEBF03F1FF3363F03F030133536051681368994202BF024B01221A72704700BF8881FF1F3F000080114BDA68196919B9FD
+:4001000001221A75597514E09969521A19698A4294BF587D00201875187D094908B1002204E0086982428CBF002201224A75DA689A611B7D13B1002002F04AB9704700BF6C
+:400140008881FF1F10B5C4B2204601F05DF90128FAD110BD08B572B60F4B0F49DA680132DA60DA690132C82A08BF0022DA611A6AD8690132A72A08BF00220A621B6A002B0F
+:400180000CBF02230023002814BF184643F0010002F086FE62B608BD8881FF1F38B50446C5B2284602F0B6F8062002F0D3FA44F00200C0B202F0AEF8062002F0CBFA2846F9
+:4001C00002F0A8F8BDE83840062002F0ADBA10B5642402F099F828B9FFF7E0FF013CF8D1204610BD012010BD70B5C4B2054620460E4601F009F9012805D0204601F022FA20
+:400200002846FFF79FFF204601F006F9314605460246204601F0C2F9204601F0F5F80028FAD1284670BD000038B5044D0024285D013402F03FFA402CF9D138BDAC81FF1FBB
+:4002400008B502F059FC002002F062FC02F074FC02F07EFC80B208BD10B50446012002F071F8642002F060FAFFF7EAFF2080002002F068F8642002F057FAFFF7E1FF60807C
+:4002800010BD08B502F064FD002002F06DFD02F07FFD02F089FD80B208BD10B50446FFF796FF322002F040FAFFF7EBFF20800120FFF774FF322002F037FAFFF7E2FF6080BA
+:4002C00010BD0FB400B593B014AB53F8042B402102A8019302F0E4FE02A802F080F802F08AF813B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF723FF62780A
+:400300002146BDE81040042001F0D6B8E438000007B50023ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB000010B5074C94F8643043B1002001F0DEFFDE
+:40034000002002F071FD002384F8643010BD00BF8881FF1F38B5104D837895F8672004469A4204D0FFF7E4FF002385F86A302368C5F865302279094B1A71A378002B14BF41
+:400380000220012002F050FDE07802F047FD2079BDE8384002F07EBD8881FF1FED81FF1F38B50D4C94F8645065B904F16500FFF7D1FF012001F0A2FF4FF47A7002F0B4F954
+:4003C00084F86A50E368E366012384F86430BDE8384002F0E7B900BF8881FF1FF8B5214C0546FFF7DDFF94F86A3003B15DB91E48FFF767FFFFF7EBFE0120002384F86A0078
+:40040000236702F0A7F92A46216F1848FFF759FF144E0027236F9D4216D001F075FF00B13767236F9D4205DD0120FFF7B7FE336F013305E005DA0020FFF7B0FE336F013B03
+:40044000336702F0AFF9E5E7322002F06DF92A2DCCBF0020012002F029FDBDE8F8400448FFF72FBF8881FF1FF1380000F8380000153900002DE9F04F99B062B602F0FCF91F
+:400480009E49042002F020FA9D4801F049FF9D4802F0ECFC9C4801F07DFF02F0CDFB02F09FFA002002F0C0FC01F098FF0221002000F060FF954C012001F0D8F8002384F868
+:4004C0006730FFF76DFFFFF782FE84F87400FFF72FFF012384F86730FFF762FFFFF777FE84F87500FFF724FF894B94F87400894994F875202546002A14BF0A461A4600286F
+:4005000008BF19468448FFF7DCFE0321084602F029F9264602F046F994F8643043B1EA6EEB689B1A41F28832934201D9FFF700FF00F058FF18B97948FFF7C3FE04E000F06D
+:4005400057FF0028F7D10BE000F04CFF10B902F029F9F9E77248FFF7B4FE032001F072F8032000F051FF0128D4D16E48FFF7F2FE6D490320FFF738FE94F876106B48FFF7E5
+:40058000A0FE94F87630023B142B00F2D683DFE813F01500D4031E00D4032400D4035000D4037600D403D900D403C101D4030803D4032C03D4033303D4034D0303238DF851
+:4005C00020308DF821300F238DF822302AE394F87800FFF703FF564B21E340F2DC57FFF7DFFE00232375E068227D02F0FF012AB9EB681B1ABB42F7DD0B4611E083B100227E
+:40060000174696F87810F068277594F814E0BEF1000F02D1EB681B1AF7E701329142F3DA07228DF8202004228DF82120ADF82230F8E20220FFF786FD4FF000080DF1200A54
+:4006400002F0B0F84FF480790027C9EB0803DA1907F80A200137402FF9D10220FFF772FD3A465146022000F027FFB9F10109EBD108F10108B8F1400FE2D12E4B38E04FF06E
+:40068000010A4FF000080DF1200B02F08BF84FF0000959460120FFF7A7FD08EB090300270493049B1BF807203B44DBB29A4209D08DE80C0041463B464A461F48FFF701FEDC
+:4006C0004FF0000A0137402FEBD109F10109B9F5807FDED108F10108B8F1400FD5D151461648FFF7EEFDBAF1000F00F01B81144B1B8807A8ADF81C3095E200BF5501000004
+:40070000F900000091000000C50000008881FF1F27390000233900002A3900004239000055390000ED81FF1FFE81FF1F5F390000D4380000D63800006E3900008A390000D6
+:40074000D8380000206FFFF749FE94F8780001F0F9FD94F8780001F0DDFD02F00DFCB94BDFF8FC821A78002702F0FB021A701A7842F001021A701A7802F0FE021A701A786C
+:4007800002F0FE021A7002F0FBFB0220FFF7DAFC012141F6FF734FF48042084602F04AFB84F8B60001F06CFF08F807000137402FF8D1DFF8B0A200270AF195091FFA89F80A
+:4007C0000137402F14BF3A4600221AF8010F2244062392F82420402101F086FF424646F24F419AF8000001F091FF08F14008402F1FFA88F8E4D196F8793053B196F87C30B1
+:40080000336100233375237D002BFCD000233375336100234FF0FF32236062602372236894F8B600234493F8241001F0E1FE94F8B60001F09FFE012194F8B60001F072FE9E
+:400840002368002BFCD0002398467360D6F80CA0012701F0A7FFE368B4F87A20CAEB030393420DD367B1042195F8B60001F0CCFE94F8B60001F0D8FE0028F9D107463072C3
+:40088000237AFBB96A682B689A4202D1002FE0D118E00220FFF756FC6968402209EB8111022000F009FE6A68674B01321340002BBEBF03F1FF3363F03F03013308F101081C
+:4008C0006360C6E70220277AFFF73CFC00221146022000F0F1FD0220FFF734FCFFB2FFF7A3FC002001F016FD37B15848FFF7E9FC0220FFF70DFD06E0554B08A81B88ADF869
+:400900002030FFF7F3FC227D4146237A5148FFF7D8FC15E25048FFF7D4FCD4F87A7017F03F0701D0032009E2286FFFF757FD95F8780001F007FD95F8780001F0EBFC01204C
+:4009400001F006FD02F018FB444BDFF814811A7842F004021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F007FB01214FF4804341F6FF72084601F0BF
+:40098000EDFC85F8B60001F07BFE08F807000137402FF8D1DFF8CC90002709F195031FFA83F804930137402F14BF3A46002219F8010F2244052392F82420402101F094FEA6
+:4009C000414646F24A5299F8000001F09FFE08F14008402F1FFA88F8E4D100274FF0FF33376098467360BB463B46D6F87A9037725FEA99190CBF4FF0010A4FF0000A2168BA
+:400A0000114A01310A40002ABCBF02F1FF3262F03F026068B8BF013282426FD02BB1227A002A7AD12A7D002A77D12068049A059302EB8010BAF1000F16D040223F2102F079
+:400A4000FBFA1CE09F6400403F00008094390000DA380000AE390000C13900009A650040AC81FF1FAB81FF1F014601370120FFF7BBFBC7EB0903D3F1000A4AEB030A21684C
+:400A8000B34A01310A40002ABEBF02F1FF3262F03F02013222606268059B01322ED12A683F2A2BD14FF00008C5F8048001F084FC85F808806B6895F8B6002B4493F82410D5
+:400AC00001F096FD95F8B60001F054FD012195F8B60001F027FD95F87E302B6185F81480237D002BFCD04FF00008012086F8148001F06EFC404601F02BFC00E023B1237A40
+:400B00005BB92B7D4BB90123626842453FF477AF0BF1010BD5F8048071E701F053FC012001F016FC002001F053FC042194F8B60001F06AFD94F8B60001F076FD804600285F
+:400B4000F8D196F8B60001F003FD337D327A0293012303920193CDF800A05B463A4649467C48FFF7AEFBC6F81080BAF1000F0BD0FFF75AFB002001F0CDFB237A63B176484B
+:400B8000FFF79FFB0220D9E0B945F1D073490120FFF72AFB0137F7E77148FFF792FB714B3DE094F8780001F0CDFB206FFFF716FC6D48FFF786FB94F87930236100232375F4
+:400BC000237D002BFCD0012001F002FC00233375237D002BFCD0002001F0FAFB002363483361FFF76EFB624B19E0002084F86A00FFF7F4FB5F4B12E094F8743023B195F867
+:400C000075200AB985F8782094F875201AB113B9012385F878305848FFF79CFB574B1B88ADF8203008A8FFF761FB89E0FFF780FB02F080F8002002F023F82A2701F04EFFDD
+:400C4000002001F0F1FE3A46002108A802F0F4F917238DF820308DF8217001F0A3FD002001F04CFB002002F0DFF8C82001F05CFD0DF12200FFF7F0FA0DF13600FFF70DFBE9
+:400C800001F090FD012002F0CFF8322001F04CFD0DF12600FFF7E0FA0DF13A00FFF7FDFA012001F02BFB4FF4967001F03DFD01F079FD0DF12E00FFF7CFFA0DF14200FFF703
+:400CC000ECFA002001F01AFB4FF4967001F02CFD01F068FD022002F0A7F8322001F024FD0DEB0700FFF7B8FA0DF13E00FFF7D5FA012001F003FB4FF4967001F015FD01F023
+:400D000051FD0DF13200FFF7A7FA0DF14600FFF7C4FA002001F0F2FA4FF4967001F004FD01F040FD002002F07FF8002384F86A3001F082FF01F054FE74E70120FFF7E8FA75
+:400D4000032000F07FFC0E48FFF7BBFAFFF7E2BB3F000080CB390000FB3900004092FF1F053A0000DC3800000D3A00001B3A0000DE380000E0380000FE81FF1FE238000096
+:400D8000283A00002DE9F04172B6874A874D1378002443F020031370062606FB045300219A881868013402F047F9072CF5D18048804D002450F8041F04F1105303F14C02D0
+:400DC00021F0FF064D33C9B20B4452005B0002329A4206D012F8027C12F801EC07F806E0F5E7A8420C44E5D1734A00231360936013619361714A724D1168724A724C116044
+:400E0000724A19261168724A724F116072490A7842F002020A700A7C42F002020A742A78A1F5863142F040022A7041390A7842F010020A70694A07CA03C469492280086863
+:400E4000684A2834106009791171674A07CA03C42280664AE83C07CA03C42280644A083407CA03C42280634A03CAC4F80A006248C4F80E100178614C41F008010170604995
+:400E800061200870A1F5F061012008808E7092E803005C4A84E80300062111705221A2F580721170584A594912781C46D2B20A70574A4FF4E261118041F2512122F8021C31
+:400EC0003B784FF4F07003F0010343EA440303F0030402F049F8013E64D0032CF0D14D4A4FF4807313804C49072313704B4800230B704821017013705371494B02221A706B
+:400F000004229A7290F89A33464F43F0010380F89A3390F89933DFF82C8143F0030380F899332B78C12043F080032B70344B18703D4B3E481B783C78DBB298F80060E4B280
+:400F400003F0070ED34080F800E0F6B2437044F003033B7046F0030388F80030344B1970344940230B708B700B728B72082381F81F32202180F8B51280F8BA222E4A0A208F
+:400F8000117082F82D3001F0E5FB2C4B88F8006044223C702A4C1A7095E80F0007C42380BDE8F081FEE700BFE84600402D3A0000FCFFFF4794000048007600405C0B004894
+:400FC000A043004020760040C0510040600B0048287600402542004003500140140B0048200B0048CB510040280B0048340B0048400B00484C0B004822430040004100404B
+:4010000000480040004300400F010049A14600402242004004400040064000400840004001400040F8460040CF0100496E5800401D510040015900402B5B004076580040B5
+:40104000B0430040F946004008B501F0C9FF03680C2B00D1FEE7FEE7084908B50B68084A1844821A802A01DC086005E001F0B8FF0C2303604FF0FF33184608BDCC80FF1F34
+:401080009093FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F8046BF7E7114653F8046C8C1AA64202D041F8045BF9E701381033E5E757
+:4010C00001F094FFFFF7D6F9FEE700BF01000000FC3B0000124A134B10B51A60124A134C1368134843F4007313600023032B98BF54F823204FEA830188BF0E4A0133302B02
+:401100004250F3D10C4B1A780C4B1A700C4B084A1A60FFF737FEBDE8104001F0EDB900BF0004FA050CED00E014ED00E0000000000080FF1F49100000BC760040C080FF1F72
+:4011400008ED00E0F8B501F017FF4B4A01271378022643F001031370137C484C43F001031374474B02F5E3521F700B3203F8946C1378054603F07F031370002001F0EAFA93
+:401180002378404A03F0F90323701378384603F0DF03137023783B43237001F0DBFA282001F0D8FA384B30461A7802F07F021A701A7802F0BF021A7023783343237001F0BE
+:4011C000C9FA2378314A43F0040323700023137053702F4AFF2199540133092BFBD1284601F0CEFE0721172001F0FCFA2949172001F0EAFA0721182001F0F4FA2649182051
+:4012000001F0E2FA0721152001F0ECFA2349152001F0DAFA0721052001F0E4FA2049052001F0D2FA0721062001F0DCFA1D49062001F0CAFA0721084601F0D4FA1A490720CB
+:4012400001F0C2FA0721082001F0CCFA1749082001F0BAFA0021162001F0C4FA1449162001F0B2FA07210C2001F0BCFABDE8F84010490C2001F0A8BAA54300409443004068
+:401280009D60004012600040F851004084600040B592FF1F131B00004D190000111B0000451A0000711A0000A11A0000D91A0000191B00008D1B0000214B224A10B51870D4
+:4012C00000231370204A40201370204A0F2413701F4A13701F4A13701F4A13701F4A13701F4B4FF400021A604FF080721A604FF400121A6020221A601860802018604FF4F9
+:4013000080701860174804704FF480001860164B1A70933B19B91A7802F0FE0202E01A7842F001021A70114B03221A70802203F8202C012001F018FE0D4B04221A7010BD04
+:40134000D092FF1FD692FF1FD492FF1FD592FF1FD192FF1FC092FF1FD392FF1F4893FF1F00E100E09E6000409C600040286000401260004070B5074C054623780E461BB9B6
+:40138000FFF7E0FE0123237031462846BDE87040FFF792BF8092FF1F0A4A002313700A4A13700A4A13700A4A13700A4A13700A4A13700A4A13700A4B03221A70802203F84C
+:4013C000202C7047D692FF1FD492FF1FD592FF1FD192FF1FC092FF1FD392FF1F4893FF1F28600040014B1878704700BFD592FF1F044B1A7802F0FF001AB118780022C0B28E
+:401400001A707047D492FF1F024A0C2303FB002040787047DC92FF1F431E072B0CD8074A064B00010344805C5B7800F00F0043EA0020023880B2704700207047FC5F004062
+:401440001A4A38B50C2303FB00231B79090C13F0800F00F1FF35044619BF8AB24FF480438BB24FF48042032D18D8DFE805F002070C110021084601F01BF80DE000210846F4
+:4014800000F0FAFF08E00021084600F0D9FF03E00021084600F0B8FF054B1855EDB2072D03D801F0EDF8034B185538BDDC92FF1FAC92FF1FB592FF1F431E072B2DE9F0470D
+:4014C0000446894615465CD82F4F0C2202FB0072D388DFF8B8A09BB2C3F500739D424FF00C0303FB007388BFD588DB7884BFC5F50075ADB2254A43EA15230601B354B244E9
+:40150000EBB28AF80130224B1A5C9846FF2A01D1FFF796FF0C2303FB047200215170B9F1000F28D03DB31B4F385D01F011F811232946FE2218F8040001F0D6F806F5C04262
+:4015400078321FFA89F118F8040001F0DFF8124D18F80410385D01F04BF80121385D00F0E1FF735D43F002037355735D03F0FD037355BDE8F08703FB04746379DBB28AF8A7
+:401580000230BDE8F08700BFDC92FF1FFC5F0040B592FF1FAC92FF1F706000402DE9F047044615468846002940D0431E072B3FD8FFF732FFA84203D22046FFF72DFF0546CA
+:4015C0001D4E335DFF2B03D141462046FFF738FFDFF868A027011AF8040000F0B9FF1223FE222946305D01F07FF807F5C0411FFA88F27831305D01F089F8DFF84490315DE9
+:401600001AF8040000F0F4FF01211AF8040000F089FF17F8093043F0020307F8093017F8093003F0FD0307F8093002E00D4600E000252846BDE8F087B592FF1FAC92FF1F51
+:4016400070600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B200011A54704700BFDC92FF1FFE5F0040431E072B9FBF024B000108221A547047FE5F00407B
+:4016800030B51A4A1A491B4D0878138803449BB21380194A00231488D8B2A4B27CB1082B0CD050680078C0B2E85450680133013050601088013880B21080ECE718460B78A4
+:4016C0000E4C082B0E4A00D040B10E4D2B7883F080032B700F232370022301E0022323701370094B1870087030BD00BF4C93FF1F4893FF1F00600040C492FF1FC192FF1F34
+:40170000D692FF1FD292FF1F4993FF1F074B02221A70074B80221A70064B0F221A70064A00231370054A012013707047D692FF1FD292FF1FC192FF1F4893FF1F4993FF1F11
+:4017400030B5164B16491B780A8803F00F03023BDBB21A4492B20A80124C134A0020118889B279B173B15568215C013BC9B229705168DBB20131516011880130013989B2B5
+:401780001180ECE7094A1370094A137883F080031370084B0B221A7030BD00BF296000404C93FF1F00600040C492FF1F4993FF1FD292FF1FC192FF1F064A06231370064ACF
+:4017C00001201370054B80221A70054B00221A70704700BFD692FF1FC192FF1FD292FF1F4993FF1F054B9A683AB19A68044910709A680988518000229A607047C492FF1F2D
+:401800004C93FF1F08B5124B1A78D2B21A701B78DBB21A0602D50F4A137008BD0220FFF7E1FF0D4B1B7803F06003202B05D0402B06D043B900F012FC04E001F0A5FB01E04F
+:4018400000F046FD10B9034B03221A7008BD00BF28600040C192FF1F0060004008B5084A084B0120197813880B449BB21380064B00221A70FFF7B6FF044B03221A7008BDC9
+:401880004C93FF1F4893FF1FD692FF1FC192FF1F08B50C4B1B78DBB2042B07D0062B09D0022B0DD1BDE80840FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A70E0
+:4018C00008BD00BFD692FF1FC192FF1F08B5054B002201201A70FFF785FF034B03221A7008BD00BFD692FF1FC192FF1F08B50A4B1A7832B11A78094942F080020A700022E6
+:401900001A70074B002201201A70FFF76BFF054B03221A7008BD00BFC092FF1F08600040D692FF1FC192FF1F074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF742
+:40194000C5BFFFF7D3BF7047D692FF1F38B51D4C2378DBB2DD0634D518060AD503F00F03012B2ED1FFF74EFF174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5DF
+:40198000FFF786FF23781B061BD4104B1A78104B1B7813430F4A13701278934211D10A4A0849154613782078DBB2000605D41378DBB20B700B7803F00F0328788342F1D1E2
+:4019C00038BD38BD28600040C192FF1FD292FF1F4993FF1F29600040054A00231380054A916819B191680B7092685380704700BF4C93FF1FC492FF1F0E4808B503889BB255
+:401A000013B9FFF783FE13E00B4B02221A700B4B00221A70FFF7E0FF094AD1799379028843EA012392B2934238BF0380FFF728FE012008BDC492FF1FD692FF1FD292FF1F00
+:401A400000600040084B01221A700F3B9B7C074B1A7B02F00302012A1EBFDA7B82F08002DA7301225A7370470B600040DC92FF1F094B02221A700F3B93F82230074B1A7EF8
+:401A800002F00302012A1EBFDA7E82F08002DA7601225A76704700BF0B600040DC92FF1F0B4B04221A700F3B93F83230094B93F8242002F00302012A1EBF93F8272082F048
+:401AC000800283F82720012283F82520704700BF0B600040DC92FF1F0B4B08221A700F3B93F84230094B93F8302002F00302012A1EBF93F8332082F0800283F833200122D0
+:401B000083F83120704700BF0B600040DC92FF1F7047FFF741BC0000F0B5184B184E19780C27C9B201234FF0000C31B3CA0720D5144A4FEA031E7244947850782040C5074E
+:401B40000DD507FB03652C79240608D5147804F0FE0414706D790C4CEDB204F80E50840706D507FB036425792D0658BF84F801C090700133DBB24908D7E7F0BD9F60004080
+:401B8000DC92FF1F70600040FE5F004000F0ACBC70B50446184B88B003AA03F11006154618685968083303C5B3422A46F7D11B782B70FCB12223237001AD0323284663703F
+:401BC00000F08AFE002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143C0132082AC1700371417100F10400EAD108B070BD573A00002DE9F043B7
+:401C00001C4D01222E460C201F274FF0800E4FF0080C194B00FB02581401234418705F70164998F805902144B9F1000F07D098F8044024064CBF887081F802C001E081F877
+:401C400002E000FB0261CC880132E4B29C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307215971D4D1054BFF221A70BDE8F08300BFDC92FF1F70600040FC5F004028
+:401C80000A600040064B074A1B7802EBC30253681A7C824286BF03EBC003586900207047D092FF1FB83A00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFEA
+:401CC000A8463F4AC3681478007ADFF800C1E4B203EBC0000C2600274FF0010E834268D01A78A24263D11CF80420597891425ED19A7893F8039002F07F0206FB02FA05EB77
+:401D00000A01CF7093F802B009F0030981F804B093F803B005F80AB0B3F804A0A1F808A093F902A0BAF1000F0BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E007
+:401D400009E0B9F1010F0CBF4FF005094FF0090981F805904F704FEA02191A4906FB0282494481F802E0B2F808A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F81A
+:401D800006A011495FFA8AFA494481F806A0B2F80690C9F3072981F80790B2F806905FFA89F981F80490D288C2F307224A71083394E7BDE8F88F00BFD592FF1FDC92FF1F91
+:401DC000D192FF1FFC5F004070600040C292FF1F08B5064B18780138C0B2FFF753FF20B143681B7900EBC300406908BDD592FF1F00212DE9F84F0B464E4E0C2707FB01F46E
+:401E000001313219092933554FF000059370494CD3701381937253705371EFD118B1464B1D70464B1D70464B1A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8E0
+:401E4000F8E0DB790C2713F0400F3E4B4FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB0541C36803EB02094B4531D093F802A00AF07F06AE4229D10E89B3F8A4
+:401E800004B0B6B25E4538BFA1F808B01E7893F801B01EF80660B3451AD181F804A0DE780E7093F902A0DE78BAF1000F06F0030607DA012E0CBF07260D264E7181F80180C8
+:401EC00006E0012E0CBF052609264E7181F801C00833CBE70135092DC3D1C1680A328B1C0A440C200833934209D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF737
+:401F000067FF114B0121186000230C2000FB0142D3801289013113449BB203F00102134409299BB2F2D1BDE8F84FFFF767BEBDE8F88F00BFDC92FF1FC292FF1F4A93FF1F7A
+:401F4000D592FF1FD392FF1FD892FF1F114B1B7903F07F035A1E072A19D80F490C2202FB031291781B0141F0010191700021D170517841F002015170127912F0800F074A54
+:401F80001A4414BF8D2389239370FFF715BC0020704700BF00600040DC92FF1FFC5F004030B4194B1A7902F07F02531E072B27D8164B0C2404FB02339978154D01F0FE0155
+:401FC00099700021D97029461201505D114400F07F0050555A7802F0FD025A701A795B78120605D5012B01D18C7006E00D2303E0012B0CBF082309238B7030BCFFF7DCBB3C
+:40200000002030BC704700BF00600040DC92FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2FFF72EFE43681B798B4201D2012909D8074A0848535CDBB24354A378F6
+:402040000120DBB2535410BD002010BDD592FF1F00600040C292FF1F4A93FF1F38B58A4A8A4C13780021DBB221801806517840F18D800A2900F20581DFE811F05D00030155
+:4020800003010301030103010B0003017E0003018200D3787C49012B09D17D4B1A787D4B03EBC2035B685B686360122310E0CB78022B12D18878FFF7E5FD002800F0E18000
+:4020C000436863606368DA7863689B7843EA02232380BDE83840FFF78FBCCB78032B26D16D4B00228878D5B2854209D3664A91786A4AEE2908BF1346634A917881B106E046
+:40210000187801320028F1D018780344EAE764499278097C914203D16248FFF739FD614B1A78002A00F0AD801A78228018E0BDE8384000F029BF13F0030313D0022B40F0A3
+:40214000A0802380504B0C211B7903F07F02564B01FB02339A78554BD2B21A7000225A706360B6E702222280514A11784F4AC9B2117053706260ACE7012323804D4BEFE722
+:402180000123238013794C4A1344E9E701390A2977D8DFE801F037764F76067676760A7620009378454ADBB25AE0937803F0FF0153B9404B1A7891425FD01970404B012062
+:4021C0001870FFF715FE58E0481EC0B2FFF75AFD0028EED155E0FFF71DFF002851D02A4A384913791279DBB2D2B20A70364A3249D25CCB5C9A4240D0314B01221A70FFF788
+:4022000053FD3AE003F00303012B2BD009D3022B37D11D4B9B78002B33D1BDE83840FFF7BFBE194B9B78012B2BD1214A137803F0FD0315E003F00303012B13D008D3022B3C
+:402240001FD1114B9B78E3B9BDE83840FFF77EBE0D4B9B78012B14D1154A137843F0020313700AE0084B1A795AB998781B791749DBB2CA5C22EA0002CA54BDE83840FFF71A
+:402280009BBA002038BD00BF00600040C492FF1FD092FF1FB83A00001C3B0000A43A00008F3B00006893FF1FDC92FF1F8192FF1FD392FF1FD592FF1FC292FF1FC092FF1FB0
+:4022C000D492FF1FD192FF1F4A93FF1FD792FF1F074B1A78120609D55B78012B06D1054B054A5A6012781A80FFF786BB0020704700600040C492FF1F7C3A0000014B18707E
+:40230000704700BF7B650040014B1878704700BF6B640040014B1870704700BF75650040064A0123136002F688321268E0211064034A1170A2F540721360704780E100E038
+:4023400000E400E0014B1870704700BF7E640040014B1870704700BF7D64004073B515461E460B4C05230022019200920A4601461846237000F064F932462946207800F0D1
+:402380001FF90221207800F009F9207802B070BDD080FF1F064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B04221A607047FE
+:4023C00000E100E0014B04221A60704780E100E0014B1870704700BF78650040704738B505460078012428B100F066FD285D0134E4B2F8E738BD08B50D2000F05DFDBDE81C
+:4024000008400A2000F058BDF7B516461F460B4C00230325019300930A4601462846257000F00EF93A463146207800F0C9F80221207800F0B3F8207803B0F0BDE080FF1F52
+:40244000F7B516461F460B4C00230225019300930A4601462846257000F0F2F83A463146207800F0ADF82946207800F097F8207803B0F0BDE180FF1FF7B516461F460B4CCE
+:4024800000230125019300930A4601462846257000F0D6F83A463146207800F091F80221207800F07BF8207803B0F0BDE280FF1F73B515461E460B4C0023019300930A46DE
+:4024C00001461846237000F0BBF832462946207800F076F80221207800F060F8207802B070BD00BFE380FF1F024B1878C0F38010704700BF8F450040074A7F2380211370A9
+:402500005170064A013BDBB202F80839002BF9D1034A1370704700BFE480FF1FF87B00400078004017280FD8084B0001C25C11B142F0200201E002F0DF02C254C25C42F096
+:402540000102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C254C25C02F0DF02C25400207047012070471070004017280DD8074900010B460344B6
+:402580001A7942F004021A71435C43F00103435400207047012070471070004017280BD8064A0001835C490003F0F10301F00E0119438154002070470120704710700040C7
+:4025C00041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F5EC4081809ABFC280002001207047000017289FBF034B00011954002088BF012020
+:40260000704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120704700BF1470004017289FBF034B0001185C00F0070088BFFF207047147000402E
+:40264000172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF8082003F00F0343EA0213DBB263709DF80C30002003F00F03A370E07010BD012010BDC8
+:4026800010B500F079FC0A4A5378182B0AD91478013B5370E30003F1804303F5F0431B78137000E0FF2400F06BFC204610BD00BFE480FF1F030610B5044611D400F05CFC32
+:4026C000084AE300117803F1804303F5F04319705378147001335370BDE8104000F050BC10BD00BFE480FF1F30B504060CD411F4704509D1C40004F1804404F5F0442180BE
+:40270000A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280002001207047000038B50446084DB4F5004F05D9286800F017FCA4F50044F6E70B
+:40274000034B58686043BDE8384000F00DBC00BFEC80FF1F024B1B7A584300F005BC00BFEC80FF1F0E4B00F003001A78490102F0FC02104318701A7801F0600142F0800287
+:402780001A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF83430040014B01221A70704784430040044B00F00F021B6853F8220043F82210C4
+:4027C000704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BF08ED00E000F01F0000F16040490100F56440C9B2017070470F4B10B50F490024CC
+:402800000F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72DB68B3FBF2F3084A1360084B4FF400421C60C3F8E82010BD8492FF1FA5280000F5
+:4028400010E000E0EC80FF1F14E000E018E000E0024A136843F002031360704710E000E008B5FFF7F5FF034A136843F00103136008BD00BF10E000E010B5054CA3691BB9F6
+:40288000FFF7BAFF0123A361BDE81040FFF7E8BF8492FF1F024B1868C0F30040704700BF10E000E038B5FFF7F5FF012808D1054D002455F8243003B198470134052CF8D1C3
+:4028C00038BD00BF8892FF1F024B03EB80035868596070478492FF1F134B144A1B78DBB20360127843EA0223114A0360127843EA0243104A0360127843EA026303600E4B60
+:402900000E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA02634360704700BF0301004904010049EC46004002010049010100490001004991
+:40294000050100490601004910B500F015FB204A044613780A2043F002031370137C43F00203137412F80A3C43F0010302F80A3C937943F00103937102F5AB52137843F0C1
+:4029800003031370134B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222183B1A70094A137843F008031370FFF7CAFE4B
+:4029C000064B10222046BDE810401A6000F0D8BAAB4300400E5900402F5B004080E200E008B500F0C9FA0F4A137803F0FE031370A2F5AA521D3A137803F0FD031370137CD7
+:402A000003F0FD03137412F80A3C03F0FE0302F80A3C937903F0FE039371BDE8084000F0AFBA00BF08590040044A137803F03F0343EA8010C0B21070704700BF085900401A
+:402A4000082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FB1F
+:402A8000F1F305490B60054B1A8070470A590040683A00005293FF1F5493FF1F5893FF1F08B5102000F0A6F907210420FFF79AFE07490420FFF788FE064A0C20137843F002
+:402AC00006031370FFF7BCFF034B00221A8008BD992B0000095900405093FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF72ABFA092FF1F044B1A7802F0FB0262
+:402B00001A701A7842F001021A7070470859004010B5084B1C7814F0010403D10028F9D0002404E02046FFF715FE024B1B78204610BD00BF09590040034A044B1B88108826
+:402B4000181A00B2704700BF5893FF1FA25B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BFCA
+:402B80005B42134493FBF1F000B270475293FF1F5493FF1F5093FF1F7047000010B500F0EBF9214A044613780A2043F001031370137C43F00103137412F80A3C43F00203F7
+:402BC00002F80A3C937943F00203937102F5AA521832137843F003031370144B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F5CD
+:402C000097530222123B1A70094A137843F008031370FFF79FFD074B08222046BDE810401A6000F0ADB900BFAB43004006590040275B004080E200E008B500F09DF90F4AAB
+:402C4000137803F0FE031370A2F5AA52153A137803F0FE031370137C03F0FE03137412F80A3C03F0FD0302F80A3C937903F0FD039371BDE8084000F083B900BF005900406D
+:402C8000044A137803F03F0343EA8010C0B21070704700BF00590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910102D
+:402CC0000A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A80704702590040723A00005E93FF1F6493FF1F5C93FF1F08B5102000F084F8A9
+:402D000007210320FFF76EFD07490320FFF75CFD064A0C20137843F006031370FFF7BCFF034B00221A8008BDF12D0000015900406093FF1F10B5054C23781BB9FFF7DCFFC0
+:402D400001232370BDE81040FFF728BFA192FF1F044B1A7802F0FB021A701A7842F001021A7070470059004010B5084B1C7814F0010403D10028F9D0002404E02046FFF7A0
+:402D8000E9FC024B1B78204610BD00BF01590040034A044B1B881088181A00B2704700BF5C93FF1FA05B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B8A
+:402DC0001B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270475E93FF1F6493FF1F6093FF1F70470000034A00F0F80013780343137066
+:402E0000704700BF02410040034A00F0F800137803431370704700BF06410040014B1870704700BF77650040014B1870704700BF7465004073B515461E460B4C04230022C3
+:402E4000019200920A46014618462370FFF7F8FB324629462078FFF7B3FB02212078FFF79DFB207802B070BDFC80FF1F074A0223136002F688321268E0215064044A1170A6
+:402E80006FF440710A441360704700BF80E100E001E400E0014B1870704700BF78640040014B1870704700BF7B640040014B1870704700BF79650040FEB5494652465B460F
+:402EC0000EB40746244909688A46244A12682448022100F071F8030020480068C018204900F06AF8143883460121C9430C460125002600F041F8814651460B7823400B7016
+:402F00005846013000F030F83800F04028400B78234003430B70584600F026F80136072EF2D9002001300138013001200B78234003430B705846043000F016F8484600F07F
+:402F40001FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F00C20100000000000230800803D000BF01380046FCD17047EFF3108072B67047A4
+:402F800080F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F02044B01FB02339B7A00E013790020704700600040DC92FF1F002902D0B0FBF1F0F4
+:402FC000704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BF014B1868704700BF6081FF1F0E4B70B51E460E4C0025E41AA410A54204D056F8C7
+:40300000253098470135F8E700F0DEFD084B094C1E46E41AA4100025A54204D056F8253098470135F8E770BDD43B0000D43B0000D43B0000DC3B000003460244934202D0A0
+:4030400003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF40273ADF80C300CBF234604F1FF33029305934FF6FF7300910491ADF80E300246EB
+:403080001E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000007B5009313460A46014603480068FFF7CBFF03B05DF804FB6081FF1F2DE9F04703
+:4030C0008E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656905EB450595FBF3F57B1C43449D4238BF1D4653050FD5294600F04AFB064698B1FA
+:403100003A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B92169504600F0E8FA0C23CAF80030A3894FF0FF3043F04003A381BDE8F087266174
+:403140003E44266046466561ED1BA560464528BF464649463246206800F0B3FAA36800209B1BA36023681E442660BDE8F08700002DE9F04F9DB003938B8980461C060D46C4
+:4031800016460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B610023099320238DF82930DFF89CB130238DF82A3037463C4614F8013B1BB9B7EB2C
+:4031C000060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780099B4B4409933B78002B00F0A08000234FF0FF3204930793059206938DF8533038
+:403200001A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F018430490EFE7D90644BF20228DF853201A0744BF2B228DF8532022782A2A03D0079AE1
+:4032400000210A200BE0039A111D12680391002A10DA524243F00200079204900BE027463B780134303B092B03D800FB02320121F5E701B107923B782E2B1ED17B782A2BC0
+:403280000AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781C0A2407463A780130303A092A03D804FB01210123F5E703B1059103223978224843
+:4032C00000F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1C8DF8281000F0D4F988B1194B33B9039B073323F007030833039314E003AB00936E
+:403300002A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F1FF3F824603D0099B5344099342E7AB895B0601D4099801E04FF0FF301DB0BDE883
+:40334000F08F00BFA33B0000A93B0000AD3B000000000000BD3000002DE9F04791461F460A698B6806469342B8BF1346C9F8003091F843200C46DDF8208012B10133C9F83C
+:4033800000302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E00123524639463046C04701301AD00135E368D9F800209B1A9D42F1DB94F843306A
+:4033C0002268003318BF012392060FD5E118302081F843005A1C94F845102244023382F8431003E04FF0FF30BDE8F08704F1430239463046C0470130F4D02268D9F8005092
+:40340000E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED184FF000091A344D4509D00123224639463046C0470130D5D009F10109F3E700207C
+:40344000BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8011D8632A22D009D8002A00F0BB80582A40F0CA8081F84520834955E0642A1ED0BC
+:40348000692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A603EE0752A24D0782A3AD0ADE01A6801F14205111D1960136884F84230A8E02168C0
+:4034C0001A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E01368002B3CDA2D225B4284F8432037E021681A6811F0800F02D0111D196007E072
+:4035000011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE078225A4984F845202268186812F0800F00F104051D6003D1550601D5038800E061
+:403540000368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E049490A226568002DA56008DB206820F0040020602BB9002D7DD175460CE0002B3D
+:4035800079D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0708D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0323612EE008681A687C
+:4035C00010F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198000E0196000232361754616E01A68111D1960156800216268284600F049F808B172
+:40360000401B6060636804E004F1420584F8422001232361002384F84330CDF800803B4603AA21463046FFF797FE013002D14FF0FF3026E023692A4639463046C047013070
+:40364000F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B7804F1420584F8423012
+:403680008AE705B0BDE8F083573A0000B43B000010B5C9B202449042034605D01C7801308C42F8D1184610BD002010BD10B5431E0A44914204D011F8014B03F8014FF8E7C8
+:4036C00010BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014D01F8014DF8E710BD994204D011F8014B02F8014FF8E710BD38B50546002944D089
+:4037000051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A3420DD92268A018834201BF18685B681218226063600C6023E0A24203D813465A68A1
+:40374000002AF9D118681918A1420BD12168014458188242196013D110685268014419605A600DE002D90C232B6009E021686018824201BF106852680918216062605C609A
+:403780002846BDE8384000F098B838BDA892FF1F70B5CD1C25F0030508350C2D38BF0C25002D064601DBA94202D90C23336046E000F082F8234B1C681A462146A1B10B683D
+:4037C0005B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4615E00C464968E9E7174C23681BB9304600F052F820602946304600F04DF8431C4D
+:4038000018D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A0ED05A42E25070BD211A304600F034F80130EBD10C233360304600F03EF800206A
+:4038400070BD00BFA892FF1FA492FF1FF8B5074615460E4621B91146BDE8F840FFF798BF1AB9FFF749FF2846F8BD00F027F885420ED929463846FFF78BFF044650B131468C
+:403880002A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C0023054608462360FDF7D8FB431C02D1236803B12B6038BD8C93FF1F7047704751F8040C10
+:4038C0000028BEBF091851F8043CC0180438704700000000050209020B020D020F021102130215027265706C792030782530327800686F6D696E6700626567696E6E696E71
+:4039000067207365656B2066726F6D20256420746F2025640066696E6973686564207365656B00796573006E6F00647269766520303A20257320647269766520313A202589
+:40394000730057616974696E6720666F72205553422E2E2E0055534220726561647900636F6D6D616E6420307825303278006661696C2025642B25642B2564203D3D2025B5
+:40398000642C206E6F74202564007061737365643D256400756E64657272756E206166746572202564207061636B65747300636F756E743D256420693D256420643D256436
+:4039C00000636D645F777269746500703D25642063723D25642063773D256420663D256420773D256420696E6465783D256420756E64657272756E3D256400756E6465723A
+:403A000072756E2100737563636573730073746172742065726173696E670073746F702065726173696E670069646C65000051004010004051004030000000014000100080
+:403A4000140140000800400140000A004C0140000200500140200030313233343536373839414243444546000001000000040000001000010000000400000010280000002A
+:403A8000000104000100000000000000000157494E5553420000303030303100000000000000000012034D005300460054003100300030000100000001000000C03A00005A
+:403AC000010000008F3B0000000000000000000001000000D83A000001000000613B000004000000FA3A0000000000000000000000000000F83A0000FF000000010240009F
+:403B0000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500780045006E00670069006E0065002A0343006F0077006C00CF
+:403B4000610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010080320904000004FF00000107050102400000070582024000E6
+:403B8000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B2000686C4C00656667454647003031323334353637383961629F
+:403BC0006364656600000000F8B500BFF8BC08BC9E46704759000000D5100000F8B500BFF8BC08BC9E46704735000000003C0000C880FF1FA0000000281200000000000046
+:403C0000000000009093FF1FFF000000675000400C00000007000000FFFFFFFF7F8000003F0000000000C05D80BB000030000000006CDC02FF00000000000000000000002F
+:403C4000000000000000000000000000000000000000000000000000A13B000000000000000000000000000000000000000000000000000000000000000000000000000068
+:403C80000000000000000000000000000000000000000000000000000081FF1F00000000000000000000000000000000000000000000000000000000000000000000000065
+:403CC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C4
+:403D00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083
+:403D40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043
+:403D80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003
 :403DC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C3
 :403E00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082
 :403E40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042
@@ -4098,52 +4098,52 @@
 :40FF80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041
 :40FFC0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
 :0200000480007A
-:400000000145004008520040015B004001650040020101402C0201402D0301400F0501400B0701406308014056090140570A01404A0B0140500C01404A0D0140480E014042
-:40004000390F01400415014004170140671801404B190140361A0140471B01400D40014010410140134201400D43014004440140064501400A460140084701400B48014097
-:4000800010490140144C01400C4D014006500140045101407E02080109441180180219016009610A7C402721290AE204E6080F011001150126012E012F013001310138026A
-:4000C00039023E013F01580459045B045F01810883048C018D0E910194029701A404AD04AE04AF0AB004B102B301B402B50CB601B802B908BE51BF04D608D804D909DB0401
-:40010000DC90DD90DF01020208080C02100213081540170818081A801B801C80200821012210231026012A802C02300233043708388039023D405840600268026B0C6D4004
-:40014000782088028B109840B040C001C214C4A5CA18CC43CE19D608D808DE04E208E68080088201928094809C289E80A201A602B044B380B404B610E604EA01EE44804068
-:40018000842094809C209E80A602AA40E211E608EA01EE0C00800121020403020403052106FC0704080109210A020B080C040E100F4010FF11011404152F162019201A0495
-:4001C0001B011C041D211EF91F0E220224042608271028042A402B2F2D0F2E02311F336034FF39083A0C3E104003450C470E481149FF4AFF4BFF50045609581859045A044E
-:400200005B045C995D995F0162C081028407850186388702880189048C028D048E04902091049208940895029610983F99029C089D049E30A105A503A704A802A902AA0417
-:40024000AC3FAD02B43FB507B63FBF10D608D804D904DB04DC09DD90DF010010010803010490050909240A420C030E020F24100A15081602172119401A021B501E101F107B
-:400280002120242025052603272029982B402C022F18300831803202332035983701388039013B183C803D113E0447084F0856085A805F4062806302670269806B026C0881
-:4002C0006D116E846F21759076467F01814087018E08908094209581971499049C019DC99E449F03A382A408A682A729C0F7C2FFC4F3CA7FCCFFCEFFD040D618D818DE1080
-:40030000E210EA01EE0C0101041205010624084209800A100B200C040D700F80107011081201130414061508170219071A081B081D801E601F102140221023802404250F16
-:4003400027F028042B0F2C802D01300F320F348035FF3670380A3B0C3E103F105804590A5B045C995F01824185F186418704888089208A018B118CF18E0291F1924E930218
-:40038000954096419711980199109A149BE19F0EA1F1A308A580A641A711A801AA28B00FB10FB3F0B4F0BA02BB02D80BD90BDB04DC99DF010108020203080510076208017B
-:4003C00009200A220D020E1410021240131414081508188819041A221B821C801D121F1021282501277029892B082D022F103008314033213608376238A039013A043E1454
-:4004000068026D407A107E80800481408D108F019108921495809702980899029D109F72A218A440A509A701A809B340B408B502B640C0F7C27FC46FCACFCCFFCE6FDE8298
-:40044000E401E8F0EC20EE40020103C4070808050A020B040C380D200F82101011C7120813181602170418081A301B041F302520274128042B042C062E012F043020320715
-:40048000330F341837F43B083E04580459085B045C995F0182108303840285628604870489208A108B508DFC8E108F0192039420964097809A109B1C9C409E209F10A07C22
-:4004C000A162A201A308A61CA710A940AA10AB30AC02AE08AF10B01FB11FB360B460B780D808D908DC99DF0100A001800204036004020706081009080A800B010C080E8878
-:400500001218134215401608180419201A841B201C081EA02105220923112504268429922A242D802E102F20301031083350340136883722380439823B103D0A3E203F4070
-:40054000611062106D406F047B037F028A08900292509508968297129C019D329F62A018A444A501A690A721C0DFC27FC4CFCA7FCCFECEFFDE18E020E208EA8000020120A4
-:40058000024803C004C20502062407440A030B900E9011FC129013011690170318201AC01B901E901F9020FC21C222012328269027902A9C2B9C2F90321F331F34E037E015
-:4005C0003A203B80420647E0482049FF4AFF4BFF4F83580859085A045B045C995D095F0180E28208861088E28A049210942096D09A03A0FCA201A440A630A880AA30AE1C91
-:40060000B2E0B41FD808DB04DC09DF01009001C6032005260610072009010A140B420D200E100F40121013121548171218101A241B101C201D201E101F0820022204230148
-:4006400029862B08300131103204335039043B1148054A0252015AAA6120628263206A406C097B037F0282018610C07FC27FC4FECA0FCC0FCE07D204D60FD80FDE188A02E6
-:40068000A602E604EE02A602B680E401EE020010022003020406063807040802090C0A040BF10C080D0C0F20100813081408150C17101808190C1B401C081F0221802204B3
-:4006C000230C250327FC281A29012A202B022DFF2E01303F31FF3E013F01580459045B045F0181238280830C842286CC870188308A028B2F8CC88D0F9123924894C8952367
-:40070000970898D499239B049CC89F10A0C8A120A302A4C8A52FA802AB40AC80AE01B080B261B31FB41FB560B760B808B9A0BE11C046C620C808C9FFCAFFCBFFCD20CEF004
-:40074000D110D804D904DA04DB04DC99DD09DF01E108E240E340E480E640E7400010010803820490050909080A420B040E020F941002110A120415401721184019181C80B4
-:40078000218C2314274029182A022D4A2F0830083361350436413720381039413A043D013F9440404A085010584059205F806C026D4082409080910192029410950896C023
-:4007C000971C99049A069B219D099F08A008A105A2C1A3E6A442A580A708B340B610C0FFC2FFC4DFCAF7CCFFCEFFD001D204D61CEE120008060209020D01100411041202D8
-:4008000018041F04220428012C063006310132013302340835043A023E143F055608580459045B045C995D905F0181028405881090019236930198019C319E0AAC05AD012B
-:40084000B00CB102B210B420B501B603BE04BF11D608D804D904DB04DC09DD90DF0101080240051809200A400E820F08100811401280154019231A501C101D101E821F0E2C
-:4008800020402120220827882F02300232803601382039803F0158205A805F40600862406701680869806F0180408210844887408B018E4090209140941096409708982064
-:4008C00099089C409D239F88A002A280A304A608A708B020B410C06CC2DAC48BCA10CC89CE8CD61CD81CE001E622EE021B011F083140330836843B4083408540C630CCF07B
-:40090000CE10E220E61030803204364037043A083F80848088029740A340A604AE80AF01CCF0CE60E2105004570880049002960897409A049E089F04A002A120A644A80182
-:40094000AA04B520D460E680EA80EE208E08900297409A049E08A002A120A640AA04AB0CAE04EA80EEB014407008C404DC0160808740A408B040D802EA011B0482209780E6
-:400980009940B008B140B480C608E809EC040B880F4197899940A220AB05AF04C20F24088004900297409A04A002A120AE40C820E480EE4050015120560470027F018301EC
-:4009C00090029A04A002A120AF40D4E0DC80DE20E620EE40070208080D010E021F10520854085940622095029940A220AF40B101C001C20DC601D407D802EA04800887021E
-:400A00008E019B02A201A408AF10B008B608E208EA01EC02010109010D010F0111011D0100FF01AB02021105BF0000A09F001F0000000000000000001000000040000000B7
-:400A400000000000C0000000FF0000B84700470000010000800000008000800000000000000707000700000027001801270018010004000000050000000000000000000052
-:400A80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036
-:400AC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F6
-:400B000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B5
-:400B40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000075
+:400000000145004009520040015B0040016400400301014002030140080501400C0701405A0801404F0901405E0A0140480B0140510C0140490D01404F0E01403E0F014057
+:40004000261401403215014028160140371701405B1801404A190140521A0140561B01400C4001400D4101400B4201400E4301400244014007450140094601400E47014042
+:400080000D4801400F490140194C01400D4D014006500140045101407E02084409021080110218011904601361197C4027212A0A8840E204E620A440EE028602980CA44036
+:4000C000A808AC04E282EA08EE04870289028A048F10980C9940A202A440AD40E64AEA01EE0C02080301041706E80701080809020A400C800D030E08100F11021408150176
+:4001000016201702181019021A071C081EF01F0220012204230224012502260628012A022B012CFF2D0330FF35033E013F105608580459045B045D905F01808081748301C8
+:400140008480867E8752884089528A108C408D528E20907E910793089524975B983E9A409B049C409D329E049FC0A040A152A202A440A552A608A87EA952AD20AE01AF8055
+:40018000B103B31CB6FFB7E0BB88BE40D804D904DB04DC90DF010008011002800301051007620A050B400D200E020F501080114412091554170119801E8020402101228854
+:4001C00023612704284029942D512F103001312032883510368939023B943C083E013F505C80640268016A406D806F08840288019140928293809408950A964097159801FC
+:400200009B089C229D159E069F20A004A128A201A401A540A648A708AC80C0FFC2FBC4FFCAFFCCFFCEFFD610D810E280E608E808EA01EE0C002001110250050106100901A8
+:400240000A030B1E0D110E1C107C110D120213221440151116301D041E1020802461260428612A082E103060310332803330341F350437083E043F1040234520480249FF27
+:400280004AFF4BFF4D204EF05110580B59045A045C995D095F0161086240634064806640674081408201840188078B128C078D368E088F0992109309940799249A069C019B
+:4002C0009D079E02A006A209A401A604A801A92DAA06AB12AC0FAD3FB140B401B507B61EB738BE10BF01D804D90BDB04DC99DF0100800122032005550A410B200E800F1598
+:400300001080112012221401154A172019221A101D401E061F40201821AA22012308244026A027042E402F0831823208342036803701381839423D903E02421448805C40CC
+:400340006D106F0178027C028701891091409281932096409C029D229E049F04A040A110A202A320A401A940AF48B340C0FFC2FDC4FFCA30CCBBCEBFD006D610DE81E2802C
+:40038000007C0160028206100710080109400A240D7C0E030F02121013031501161C1704180119011A481B081E101F1022102310268027102B102E102F1C301F311F3320DC
+:4003C000354036F03A805608580B590B5B045C995D905F01800482118314851086E08782881F89088A208B108D1F8F40901F9240951097219B149C019E1E9F14A3E4A41F55
+:40040000A680A808AA11AC02AE11AF14B1F0B30FB4F0B60FBA20BB02D80BD90BDB04DC99DF010102024003240444068007240A410C800D220F201222131014011502170861
+:4004400019C01A031B301C401F412080210223B024182530262128402A402C812D822E102F2031403324344036213784380839023A803B303C143EC03F015F40670169402A
+:4004800078027C0291029290960297129C029D629E049F04A202A441A522A621A730AA12C0FEC2F9C4B7CAF9CCFECEFFD610D810DE81EE02001C010102020306061008010D
+:4004C00009040A040B010E0312101507180119071A081E102102221023012A1C2D072E10301F3107580B590B5B045C995F0181E782908310878488208AC08B188E908F84EC
+:40050000929093849508969097229801990E9A489B419D019E039F06A29CA3E4A4C1A624A784AA90AB84ACFCAE02B21FB4E0B5F8B707BA20BB80C202C60EC804C9FFCAFF6A
+:40054000CBFFCF83D80BD90BDA04DB04DC99DD09DF01004203640552070109220A020D620F201080120213101522174418401D181F10210122022550269029022B012C803A
+:400580002D022E102F203120330436A0370539223B103C8A3D203F0245484605470848044B1057405C405E225F086520660167226A8078027C0283408D48C0DFC2FBC4FBE9
+:4005C000CAE9CCF6CEF5D020D6F0D8F0DE810A010C01130115012301260134013501382039203E103F105608580459045B045D905F018C029001930195019C04A602A902A1
+:40060000B002B204B301B401B702B802B908BE15BF44D804D904DB04DF01030507010E400F011308170418041E281F022304268027102B402F08330537055B405D805E2030
+:40064000614065C06B056E406F0883488B068C048E808F4093019F10A604A844AA10AF50B001B220B404C083C290C424CA21CCC3D638D808E204E6A0E811EA08EE035608FE
+:400680005B045D9080018505870289088D068F019002930194049510972098089B029D04A130A204A520A710A908AA08AD08B002B107B208B330B404B508B601BE41BF11A1
+:4006C000D608D804D904DB04DC99DD90DF01000208080A080B8010041302188419081A012080210822202809290A3004329238083A803B2059605F406110628067016801DA
+:4007000081088204868087408A018D209208980C99429A809B029D109F10A202A440A910B280C008C20EC40ACA0FCC0FCE0ED61CD81CE001E408E662EC04EE0A00100260BB
+:4007400003010453070209020A080B200C010D030F0410401210130115081604170119091A531BF21C011D801E021F022053210223102401250226022740280129022BFC12
+:400780002C132DFF2E203070320F340F35FF360F3A023F10580459045B045C095F018020840185028602870188208C028D018E01902094F89604970198109A039C049D0478
+:4007C0009E40A020A10BA480A508A604A813A902AAE4AC07AE08AF02B104B2FFB308B503B703BBA0BE04BF01D804D904DB04DC90DF01002A03010501072509200B920D227D
+:400800000E211365155619081C021D051F1420102180228223162610280229082A212C042D402F64324835203680372938403B043E093F506A406F027D017E808204842025
+:4008400088208E4290409142928293C19408951D9605973498029A019B2C9CE09D159E049F03A128A209A308A480AA02B140B504B740C0FFC2FFC4FFCAFFCCFACEFAE210B7
+:40088000E480E662EE2A0001011F02080401050106400704080109010A200B080C010D1F0E021001121013401401154016FE18041B1F1C801D011E011F0221012201231E7A
+:4008C00027202804291F2AF92CFF2D012F1032FF333F35403E043F10400246E0470C481849FF4AFF4BFF50045601580459045A045B045C905D095F0162C08040843286C42E
+:4009000088408C068E08922294F8960498809A049C40A040A410A602A840AE01B0FFB4FFB822D804DB04DC09DF010052032004500640072009A00B900E620F04114012402C
+:40094000132114441540170819081D101F21202421042204231029282A82312832013340351036103956400442804301502466086710680469146A416B416F02708071025A
+:40098000720683028440860490509142920293859408951C96059702980499209B289C409D109E089F01A001A1A8A201A4B4A502A720AB08AF42B320B480B620C0FFC2FFD1
+:4009C000C4FBCA0FCC0FCE0FD004E040E210E440E831EC40EE201B011F083020330836843B4083408820C630CCF0CE10E22032043380364037043B043F80A340A604AE80F7
+:400A0000AF41CCF0CE60EE405010570484408A80960897049F04A644A780D460E24086048C10942096089704A040A280A640A784AA04AB04E610EA80EE201420C40458108D
+:400A40005E019820A404AC04D401D6011B049502960198209C10A404B101C608EA0408080B080F41870495029601970199809C10A404AB05AC20AD80C20F240883048B04A7
+:400A80008E409704A040A280A704AE40AF80C820E620EE50528054405A40722076808AA09240A040A280AA80B404D4E0DC80DE20EC20070208020D811C085320568059806E
+:400AC0005F0185808A018F039502960199809C10A404AC08AF40C001C20DC601D407D601E208E40975018C028D018F209802A720AA80B010DE04E002E208E402E804010148
+:400B00000D010F0111011B011D0100FF01AB020211050000BF0000A09F001F000000000000000000100000004000000000000000C0000000FF0000B8470047000001000013
+:400B400080000002820082000000000000070700070000001D0018011D00180100040000000500000000000000000000000000000000000000000000000000000000000065
 :400B80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035
 :400BC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F5
 :400C000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B4
@@ -4615,12 +4615,12 @@
 :0200000490105A
 :04000000BC90ACAF55
 :0200000490303A
-:0200000021B02D
+:0200000064D4C6
 :0200000490402A
 :4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C0
 :400040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080
 :400080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040
 :4000C0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 :0200000490501A
-:0C00000000012E16106900002E3032198D
+:0C00000000012E16106900002E30753D26
 :00000001FF
--- a/FluxEngine.cydsn/FluxEngine.cydwr
+++ b/FluxEngine.cydsn/FluxEngine.cydwr
@@ -272,7 +272,7 @@
        <Data key="derive_type" value="AUTO" />
        <Data key="desired_freq" value="1600000" />
        <Data key="desired_unit" value="0" />
-        <Data key="divider" value="40" />
+        <Data key="divider" value="30" />
        <Data key="domain" value="DIGITAL" />
        <Data key="enabled" value="True" />
        <Data key="minus_accuracy" value="0.25" />
@@ -390,7 +390,7 @@
        <Data key="derive_type" value="AUTO" />
        <Data key="desired_freq" value="1600000" />
        <Data key="desired_unit" value="0" />
-        <Data key="divider" value="40" />
+        <Data key="divider" value="30" />
        <Data key="domain" value="DIGITAL" />
        <Data key="enabled" value="True" />
        <Data key="minus_accuracy" value="0.25" />
@@ -604,7 +604,7 @@
        <Data key="check_tolerance" value="True" />
        <Data key="clock_version" value="v1" />
        <Data key="derive_type" value="BUILTIN" />
-        <Data key="desired_freq" value="64" />
+        <Data key="desired_freq" value="48" />
        <Data key="desired_unit" value="6" />
        <Data key="divider" value="0" />
        <Data key="domain" value="0" />
@@ -816,7 +816,7 @@
    <Group key="v1">
      <Data key="cy_boot" value="cy_boot_v6_10" />
      <Data key="Em_EEPROM_Dynamic" value="Em_EEPROM_Dynamic_v2_20" />
-      <Data key="LIN_Dynamic" value="LIN_Dynamic_v6_0" />
+      <Data key="LIN_Dynamic" value="LIN_Dynamic_v5_0" />
    </Group>
  </Group>
  <Data key="DataVersionKey" value="2" />
@@ -4214,7 +4214,7 @@
  </Group>
  <Group key="System3">
    <Data key="CYDEV_CONFIG_FASTBOOT_ENABLED" value="True" />
-    <Data key="CYDEV_CONFIG_UNUSED_IO" value="AllowButWarn" />
+    <Data key="CYDEV_CONFIG_UNUSED_IO" value="Disallowed" />
    <Data key="CYDEV_CONFIGURATION_ECC" value="True" />
    <Data key="CYDEV_CONFIGURATION_MODE" value="COMPRESSED" />
    <Data key="CYDEV_DEBUGGING_DPS" value="Disable" />
--- a/FluxEngine.cydsn/FluxEngine.cyprj
+++ b/FluxEngine.cydsn/FluxEngine.cyprj
--- a/FluxEngine.cydsn/Sampler/Sampler.v
+++ b/FluxEngine.cydsn/Sampler/Sampler.v
@@ -23,49 +23,36 @@ module Sampler (

 reg [5:0] counter;

+reg index_q;
+reg rdata_q;
+
 reg index_edge;
 reg rdata_edge;

 reg req_toggle;

-reg rdata_toggle;
-reg old_rdata_toggle;
-
-reg index_toggle;
-reg old_index_toggle;
-
-always @(posedge rdata)
-begin
-    rdata_toggle <= ~rdata_toggle;
-end
-
-always @(posedge index)
-begin
-    index_toggle <= ~index_toggle;
-end
-
 always @(posedge sampleclock)
 begin
    if (reset)
    begin
-        old_rdata_toggle <= 0;
-        old_index_toggle <= 0;
-        
        index_edge <= 0;
        rdata_edge <= 0;
+        index_q <= 0;
+        rdata_q <= 0;
        counter <= 0;
        req_toggle <= 0;
    end
    else
    begin
-        /* If data_toggle or index_toggle have changed state, this means that they've
-         * gone high since the last sampleclock. */
+        /* Both index and rdata are active high -- positive-going edges
+         * indicate the start of an index pulse and read pulse, respectively.
+         */
         
-        index_edge <= index_toggle != old_index_toggle;
-        old_index_toggle <= index_toggle;
+        index_edge <= index && !index_q;
+        index_q <= index;
        
-        rdata_edge <= rdata_toggle != old_rdata_toggle;
-        old_rdata_toggle <= rdata_toggle;
+        rdata_edge <= rdata && !rdata_q;
+        rdata_q <= rdata;
        
        if (rdata_edge || index_edge || (counter == 6'h3f)) begin
            opcode <= { rdata_edge, index_edge, counter };
--- a/FluxEngine.cydsn/Sequencer/Sequencer.v
+++ b/FluxEngine.cydsn/Sequencer/Sequencer.v
@@ -20,13 +20,14 @@ module Sequencer (

 localparam STATE_LOAD = 0;
 localparam STATE_WRITING = 1;
+localparam STATE_WAITING = 2;

-reg state;
+reg [1:0] state;
 reg [5:0] countdown;
 reg pulsepending;

 assign req = (!reset && (state == STATE_LOAD));
-assign wdata = (!reset && (state == STATE_WRITING) && (countdown == 0) && pulsepending);
+assign wdata = (!reset && (state == STATE_WAITING) && (countdown == 0) && pulsepending);
 assign debug_state = 0;

 reg olddataclock;
@@ -37,11 +38,6 @@ assign dataclocked = !olddataclock && dataclock;
 reg oldsampleclock;
 reg sampleclocked;

-reg oldindex;
-wire indexed;
-always @(posedge clock) oldindex <= index;
-assign indexed = !oldindex && index;
-
 always @(posedge clock)
 begin
    if (reset)
@@ -65,10 +61,7 @@ begin
                if (dataclocked)
                begin
                    pulsepending <= opcode[7];
-                    if (opcode[5:0] == 0)
-                        countdown <= 0;
-                    else
-                        countdown <= opcode[5:0] - 1; /* compensate for extra tick in state machine */
+                    countdown <= opcode[5:0] - 1; /* compensate for extra tick in state machine */
                    
                    state <= STATE_WRITING;
                end
@@ -79,12 +72,15 @@ begin
                if (sampleclocked)
                begin
                    if (countdown == 0)
-                        state <= STATE_LOAD;
+                        state <= STATE_WAITING;
                    else
                        countdown <= countdown - 1;
                    sampleclocked <= 0;
                end
            end
+            
+            STATE_WAITING:
+                state <= STATE_LOAD;
        endcase
    end
 end
--- a/FluxEngine.cydsn/TopDesign/TopDesign.cysch
+++ b/FluxEngine.cydsn/TopDesign/TopDesign.cysch
--- a/FluxEngine.cydsn/main.c
+++ b/FluxEngine.cydsn/main.c
@@ -147,7 +147,7 @@ static void set_drive_flags(struct set_drive_frame* flags)
    
    current_drive_flags = *flags;
    DRIVESELECT_REG_Write(flags->drive ? 2 : 1); /* select drive 1 or 0 */
-    DENSITY_REG_Write(!flags->high_density); /* double density bit */
+    DENSITY_REG_Write(flags->high_density); /* density bit */
    INDEX_REG_Write(flags->index_mode);
 }

@@ -221,7 +221,7 @@ static int usb_read(int ep, uint8_t buffer[FRAME_SIZE])
 static void cmd_get_version(struct any_frame* f)
 {
    DECLARE_REPLY_FRAME(struct version_frame, F_FRAME_GET_VERSION_REPLY);
-    r.version = FLUXENGINE_PROTOCOL_VERSION;
+    r.version = FLUXENGINE_VERSION;
    send_reply((struct any_frame*) &r);
 }

@@ -905,6 +905,7 @@ int main(void)
    USBFS_Start(0, USBFS_DWR_VDDD_OPERATION);
    USBFS_DisableOutEP(FLUXENGINE_DATA_OUT_EP_NUM);
    
+    detect_drives();
    CyWdtStart(CYWDT_1024_TICKS, CYWDT_LPMODE_DISABLED);
    
    for (;;)
@@ -925,8 +926,6 @@ int main(void)
                CyWdtClear();
            print("USB ready");
            USBFS_EnableOutEP(FLUXENGINE_CMD_OUT_EP_NUM);
-            print("Scanning drives...");
-            detect_drives();
        }
        
        if (USBFS_GetEPState(FLUXENGINE_CMD_OUT_EP_NUM) == USBFS_OUT_BUFFER_FULL)
@@ -938,75 +937,3 @@ int main(void)
        }
    }
 }
-
-const uint8_t USBFS_MSOS_CONFIGURATION_DESCR[USBFS_MSOS_CONF_DESCR_LENGTH] = {
-/*  Length of the descriptor 4 bytes       */   0x28u, 0x00u, 0x00u, 0x00u,
-/*  Version of the descriptor 2 bytes      */   0x00u, 0x01u,
-/*  wIndex - Fixed:INDEX_CONFIG_DESCRIPTOR */   0x04u, 0x00u,
-/*  bCount - Count of device functions.    */   0x01u,
-/*  Reserved : 7 bytes                     */   0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
-/*  bFirstInterfaceNumber                  */   0x00u,
-/*  Reserved                               */   0x01u,
-/*  compatibleId - "WINUSB\0\0"            */   'W', 'I', 'N', 'U', 'S', 'B', 0, 0,
-/*  subcompatibleID - "00001\0\0"          */   '0', '0', '0', '0', '1',
-                                                0x00u, 0x00u, 0x00u,
-/*  Reserved : 6 bytes                     */   0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u
-};
-
-const uint8_t USBFS_MSOS_EXTENDED_PROPERTIES_DESCR[224] = {
-    /* Length; 4 bytes       */   224, 0, 0, 0,
-    /* Version; 2 bytes      */   0x00, 0x01, /* 1.0 */
-    /* wIndex                */   0x05, 0x00,
-    /* Number of sections    */   0x01, 0x00,
-    /* Property section size */   214, 0, 0, 0,
-    /* Property data type    */   0x07, 0x00, 0x00, 0x00, /* 7 = REG_MULTI_SZ Unicode */
-    /* Property name length  */   42, 0,
-    /* Property name         */   'D', 0, 'e', 0, 'v', 0, 'i', 0, 'c', 0, 'e', 0,
-                                  'I', 0, 'n', 0, 't', 0, 'e', 0, 'r', 0, 'f', 0,
-                                  'a', 0, 'c', 0, 'e', 0, 'G', 0, 'U', 0, 'I', 0,
-                                  'D', 0, 's', 0, 0,   0,
-    /* Property data length  */   158, 0, 0, 0,
-    /* GUID #1 data          */   '{', 0, '3', 0, 'd', 0, '2', 0, '7', 0, '5', 0,
-                                  'c', 0, 'f', 0, 'e', 0, '-', 0, '5', 0, '4', 0,
-                                  '3', 0, '5', 0, '-', 0, '4', 0, 'd', 0, 'd', 0,
-                                  '5', 0, '-', 0, 'a', 0, 'c', 0, 'c', 0, 'a', 0,
-                                  '-', 0, '9', 0, 'f', 0, 'b', 0, '9', 0, '9', 0,
-                                  '5', 0, 'e', 0, '2', 0, 'f', 0, '6', 0, '3', 0,
-                                  '8', 0, '}', 0, '\0', 0,
-    /* GUID #2 data          */   '{', 0, '3', 0, 'd', 0, '2', 0, '7', 0, '5', 0,
-                                  'c', 0, 'f', 0, 'e', 0, '-', 0, '5', 0, '4', 0,
-                                  '3', 0, '5', 0, '-', 0, '4', 0, 'd', 0, 'd', 0,
-                                  '5', 0, '-', 0, 'a', 0, 'c', 0, 'c', 0, 'a', 0,
-                                  '-', 0, '9', 0, 'f', 0, 'b', 0, '9', 0, '9', 0,
-                                  '5', 0, 'e', 0, '2', 0, 'f', 0, '6', 0, '3', 0,
-                                  '8', 0, '}', 0, '\0', 0, '\0', 0
-};
-
-uint8 USBFS_HandleVendorRqst(void)
-{
-    if (!(USBFS_bmRequestTypeReg & USBFS_RQST_DIR_D2H))
-        return false;
-
-    switch (USBFS_bRequestReg)
-    {
-        case USBFS_GET_EXTENDED_CONFIG_DESCRIPTOR:
-            switch (USBFS_wIndexLoReg)
-            {
-                case 4:
-                    USBFS_currentTD.pData = (volatile uint8 *) &USBFS_MSOS_CONFIGURATION_DESCR[0u];
-                    USBFS_currentTD.count = USBFS_MSOS_CONFIGURATION_DESCR[0u];
-                    return USBFS_InitControlRead();
-                    
-                case 5:
-                    USBFS_currentTD.pData = (volatile uint8 *) &USBFS_MSOS_EXTENDED_PROPERTIES_DESCR[0u];
-                    USBFS_currentTD.count = USBFS_MSOS_EXTENDED_PROPERTIES_DESCR[0u];
-                    return USBFS_InitControlRead();
-            }
-
-        default:
-            break;
-    }
-
-    return true;
-}
-
--- a/FluxEngine.cydsn/patcher.vbs
+++ b/FluxEngine.cydsn/patcher.vbs
@@ -0,0 +1,18 @@
+const READ = 1
+const WRITE = 2
+
+filename = "Generated_Source\PSoC5\USBFS_descr.c"
+set fso = CreateObject("Scripting.FileSystemObject")
+
+set file = fso.OpenTextFile(filename, READ)
+text = file.ReadAll
+file.Close
+
+set r = New RegExp
+r.MultiLine = True
+r.Pattern = "/\* +compatibleID.*\n.*"
+text = r.replace(text, "'W', 'I', 'N', 'U', 'S', 'B', 0, 0,")
+
+set file = fso.CreateTextFile(filename, True)
+file.Write text
+file.Close
--- a/138
+++ b/138
@@ -1,110 +1,64 @@
-ifeq ($(BUILDTYPE),)
-    buildtype_Darwin = osx
-    buildtype_Haiku = haiku
-    BUILDTYPE := $(buildtype_$(shell uname -s ))
-        ifeq ($(BUILDTYPE),)
-                BUILDTYPE := unix
-        endif
-endif
-export BUILDTYPE
+PACKAGES = zlib sqlite3 libusb-1.0 protobuf

-ifeq ($(BUILDTYPE),windows)
-	MINGW = i686-w64-mingw32-
-	CC = $(MINGW)gcc
-	CXX = $(MINGW)g++ -std=c++17
-	CFLAGS += -g -O3
-	CXXFLAGS += \
-		-fext-numeric-literals \
-		-Wno-deprecated-enum-float-conversion \
-		-Wno-deprecated-enum-enum-conversion
-	LDFLAGS += -static
-	AR = $(MINGW)ar
-	PKG_CONFIG = $(MINGW)pkg-config -static
-	WINDRES = $(MINGW)windres
-	WX_CONFIG = /usr/i686-w64-mingw32/sys-root/mingw/bin/wx-config-3.0 --static=yes
-	EXT = .exe
-else
-	CC = gcc
-	CXX = g++ -std=c++17
-	CFLAGS = -g -O3
-	LDFLAGS =
-	AR = ar
-	PKG_CONFIG = pkg-config
-	ifeq ($(BUILDTYPE),osx)
-	else
-		LDFLAGS += -pthread -Wl,--no-as-needed
-	endif
+export CFLAGS = -x c++ --std=c++14 -ffunction-sections -fdata-sections
+export LDFLAGS = -pthread

-endif
+export COPTFLAGS = -Os
+export LDOPTFLAGS = -Os

-HOSTCC = gcc
-HOSTCXX = g++ -std=c++17
-HOSTCFLAGS = -g -O3
-HOSTLDFLAGS =
-
-REALOBJ = .obj
-OBJ = $(REALOBJ)/$(BUILDTYPE)
-DESTDIR ?=
-PREFIX ?= /usr/local
-BINDIR ?= $(PREFIX)/bin
-
-# Special Windows settings.
+export CDBGFLAGS = -O0 -g
+export LDDBGFLAGS = -O0 -g

 ifeq ($(OS), Windows_NT)
-	EXT ?= .exe
-	MINGWBIN = /mingw32/bin
-	CCPREFIX = $(MINGWBIN)/
-	PKG_CONFIG = $(MINGWBIN)/pkg-config
-	WX_CONFIG = /usr/bin/sh $(MINGWBIN)/wx-config --static=yes
-	PROTOC = $(MINGWBIN)/protoc
-	WINDRES = windres
-	LDFLAGS += \
-		-static
-	CXXFLAGS += \
-		-fext-numeric-literals \
-		-Wno-deprecated-enum-float-conversion \
-		-Wno-deprecated-enum-enum-conversion
+export PROTOC = /mingw32/bin/protoc
+export CXX = /mingw32/bin/g++
+export AR = /mingw32/bin/ar rc
+export RANLIB = /mingw32/bin/ranlib
+export STRIP = /mingw32/bin/strip
+export CFLAGS += -I/mingw32/include/libusb-1.0 -I/mingw32/include
+export LDFLAGS +=
+export LIBS += -L/mingw32/lib -static -lz -lsqlite3 -lusb-1.0 -lprotobuf
+export EXTENSION = .exe
+else

-	# Required to get the gcc run - time libraries on the path.
-	export PATH := $(PATH):$(MINGWBIN)
+packages-exist = $(shell pkg-config --exists $(PACKAGES) && echo yes)
+ifneq ($(packages-exist),yes)
+$(warning These pkg-config packages are installed: $(shell pkg-config --list-all | sort | awk '{print $$1}'))
+$(error You must have these pkg-config packages installed: $(PACKAGES))
 endif

-# Special OSX settings.
+export PROTOC = protoc
+export CXX = g++
+export AR = ar rc
+export RANLIB = ranlib
+export STRIP = strip
+export CFLAGS += $(shell pkg-config --cflags $(PACKAGES))
+export LDFLAGS +=
+export LIBS += $(shell pkg-config --libs $(PACKAGES))
+export EXTENSION =

 ifeq ($(shell uname),Darwin)
-	LDFLAGS += \
-		-framework IOKit \
-		-framework Foundation 
+AR = ar rcS
+RANLIB += -c -no_warning_for_no_symbols
 endif

-.PHONY: all
-all: +all README.md
+endif
+export XXD = xxd

-.PHONY: binaries tests
-binaries: all
-tests: all
-	
-README.md: $(OBJ)/scripts/+mkdocindex/mkdocindex$(EXT)
-	@echo $(PROGRESSINFO) MKDOC $@
-	@csplit -s -f$(OBJ)/README. README.md '/<!-- FORMATSSTART -->/' '%<!-- FORMATSEND -->%'
-	@(cat $(OBJ)/README.00 && $< && cat $(OBJ)/README.01) > README.md
+CFLAGS += -Ilib -Idep/fmt -Iarch

-.PHONY: tests
+export OBJDIR = .obj

-clean::
-	$(hide) rm -rf $(REALOBJ)
+all: .obj/build.ninja
+	@ninja -f .obj/build.ninja
+	@if command -v cscope > /dev/null; then cscope -bRq; fi

-include build/ab.mk
+clean:
+	@echo CLEAN
+	@rm -rf $(OBJDIR)

-DOCKERFILES = \
-	debian11 \
-    debian12 \
-    fedora40 \
-    fedora41 \
-	manjaro
+.obj/build.ninja: mkninja.sh Makefile
+	@echo MKNINJA $@
+	@mkdir -p $(OBJDIR)
+	@sh $< > $@

-docker-%: tests/docker/Dockerfile.%
-	docker build -t $* -f $< .
-
-.PHONY: dockertests
-dockertests: $(foreach f,$(DOCKERFILES), docker-$(strip $f) .WAIT)
--- a/README.md
+++ b/README.md
@@ -2,14 +2,12 @@ FluxEngine
 ==========

 (If you're reading this on GitHub, the formatting's a bit messed up. [Try the
-version on cowlark.com instead.](http://cowlark.com/fluxengine/))
+version on cowlark.com instead.](http://cowlark.com/fluxengine/)

-**Breaking news!** As of 2024-10-01, the FluxEngine client software works
-(to a point) with [Applesauce](doc/applesauce.md) hardware.
-
-<div style="text-align: center">
-<a href="doc/screenshot.jpg"><img src="doc/screenshot.jpg" style="width:60%" alt="screenshot of the GUI in action"></a>
-</div>
+**Breaking news!** As of 2021-05-21, the command line environment has changed
+_substantially_ (to make it more consistent and flexible, and allow some new
+backend features like multi-format IBM scheme disks, which are popular with
+CP/M). If things don't work the way you expect, please check the documentation.

 What?
 -----
@@ -32,14 +30,17 @@ Don't believe me? Watch the demo reel!
 </div>

 **New!** The FluxEngine client software now works with
-[Greaseweazle](https://github.com/keirf/Greaseweazle/wiki) and
-[Applesauce](https://applesaucefdc.com/) hardware. So, if you can't find a PSoC5
-development kit, or don't want to use the Cypress Windows tools for programming
-it, you can use one of these instead. Very nearly all FluxEngine features are
-available with the Greaseweazle and it works out-of-the box; the Applesauce is a
-bit less supported but still works. See the [dedicated Greaseweazle
-documentation page](doc/greaseweazle.md) or the [Applesauce
-page](doc/applesauce.md) for more information.
+[GreaseWeazle](https://github.com/keirf/Greaseweazle/wiki) hardware. So, if you
+can't find a PSoC5 development kit, or don't want to use the Cypress Windows
+tools for programming it, you can use one of these instead. Very nearly all
+FluxEngine features are available with the GreaseWeazle and it works out-of-the
+box. See the [dedicated GreaseWeazle documentation page](doc/greaseweazle.md)
+for more information.
+
+**Important note.** On 2020-04-02 I changed the bytecode format (and firmware).
+Flux files will need to be upgraded with `fluxengine upgradefluxfile`. The new
+format should be more reliable and use way, way less bandwidth. Sorry for the
+inconvenience.

 Where?
 ------
@@ -64,85 +65,71 @@ following friendly articles:
  - [Using a FluxEngine](doc/using.md) ∾ what to do with your new hardware ∾
    flux files and image files ∾ knowing what you're doing

-  - [Using Greaseweazle hardware with the FluxEngine client
-    software](doc/greaseweazle.md) ∾ what works ∾ what doesn't work ∾ where to
-    go for help
+  - [Using GreaseWeazle hardware with the FluxEngine client
+	software](doc/greaseweazle.md) ∾ what works ∾ what doesn't work ∾ where to
+	go for help

-  - [Configuring for your drive](doc/drives.md) ∾ but I don't have a 80 track
-    drive! ∾ reading and writing 40 track disks ∾ Shugart and Apple II
-
-  - [Direct filesystem access](doc/filesystem.md) ∾ imaging files is a pain
-    ∾ accessing files directly ∾ features and limitation ∾ it works on disk
-    images too, you say?
-    
  - [Troubleshooting dubious disks](doc/problems.md) ∾ it's not an exact
-    science ∾ the sector map ∾ clock detection and the histogram
+	science ∾ the sector map ∾ clock detection and the histogram

-  - [Disk densities](doc/driveresponse.md) ∾ what's the difference between an HD
-    and DD disk? ∾ you can't do that with that ∾ measuring your drive's ability to
-    work with exotic formats ∾ I think my drive is broken
+  - [Checking your drive](doc/driveresponse.md) ∾ you can't do that with that ∾
+	measuring your drive's ability to work with exotic formats

 Which?
 ------

 The current support state is as follows.

-Dinosaurs (🦖) have yet to be observed in real life --- I've written the encoder
-and/or decoder based on Kryoflux (or other) dumps I've found. I don't (yet) have
-real, physical disks in my hand to test the capture process, or hardware to
-verify that written disks work.
+Dinosaurs (🦖) have yet to be observed in real life --- I've written the
+decoder based on Kryoflux (or other) dumps I've found. I don't (yet) have
+real, physical disks in my hand to test the capture process.

-Unicorns (🦄) are completely real --- this means that I've read actual, physical
-disks with these formats and/or written real, physical disks and then used them
-on real hardware, and so know they work (or had reports from people who've had
-it work).
+Unicorns (🦄) are completely real --- this means that I've read actual,
+physical disks with these formats and so know they work (or had reports from
+people who've had it work).

-If a filesystem is listed, this means that FluxEngine natively supports that
-particular filesystem and can read (and sometimes write, support varies) files
-directly from disks, flux files or disk images. Some formats have multiple
-choices because they can store multiple types of file system.
+### Old disk formats

-<!-- FORMATSSTART -->
-<!-- This section is automatically generated. Do not edit. -->
-
-| Profile | Format | Read? | Write? | Filesystem? |
-|:--------|:-------|:-----:|:------:|:------------|
-| [`acornadfs`](doc/disk-acornadfs.md) | Acorn ADFS: BBC Micro, Archimedes | 🦖 |  |  |
-| [`acorndfs`](doc/disk-acorndfs.md) | Acorn DFS: Acorn Atom, BBC Micro series | 🦄 |  | ACORNDFS  |
-| [`aeslanier`](doc/disk-aeslanier.md) | AES Lanier "No Problem": 616kB 5.25" 77-track SSDD hard sectored | 🦖 |  |  |
-| [`agat`](doc/disk-agat.md) | Agat: 840kB 5.25" 80-track DS | 🦖 | 🦖 |  |
-| [`amiga`](doc/disk-amiga.md) | Amiga: 880kB 3.5" DSDD | 🦄 | 🦄 | AMIGAFFS  |
-| [`ampro`](doc/disk-ampro.md) | Ampro Little Board: CP/M | 🦖 |  | CPMFS  |
-| [`apple2`](doc/disk-apple2.md) | Apple II: Prodos, Appledos, and CP/M | 🦄 | 🦄 | APPLEDOS CPMFS PRODOS  |
-| [`atarist`](doc/disk-atarist.md) | Atari ST: Almost PC compatible | 🦄 | 🦄 |  |
-| [`bk`](doc/disk-bk.md) | BK: 800kB 5.25"/3.5" 80-track 10-sector DSDD | 🦖 | 🦖 |  |
-| [`brother`](doc/disk-brother.md) | Brother word processors: GCR family | 🦄 | 🦄 | BROTHER120 FATFS  |
-| [`commodore`](doc/disk-commodore.md) | Commodore: 1541, 1581, 8050 and variations | 🦄 | 🦄 | CBMFS  |
-| [`eco1`](doc/disk-eco1.md) | VDS Eco1: CP/M; 1210kB 77-track mixed format DSHD | 🦖 |  | CPMFS  |
-| [`epsonpf10`](doc/disk-epsonpf10.md) | Epson PF-10: CP/M; 3.5" 40-track DSDD | 🦖 |  | CPMFS  |
-| [`f85`](doc/disk-f85.md) | Durango F85: 461kB 5.25" 77-track SS | 🦖 |  |  |
-| [`fb100`](doc/disk-fb100.md) | Brother FB-100: 100kB 3.5" 40-track SSSD | 🦖 |  |  |
-| [`hplif`](doc/disk-hplif.md) | Hewlett-Packard LIF: a variety of disk formats used by HP | 🦄 | 🦄 | LIF  |
-| [`ibm`](doc/disk-ibm.md) | IBM PC: Generic PC 3.5"/5.25" disks | 🦄 | 🦄 | FATFS  |
-| [`icl30`](doc/disk-icl30.md) | ICL Model 30: CP/M; 263kB 35-track DSSD | 🦖 |  | CPMFS  |
-| [`mac`](doc/disk-mac.md) | Macintosh: 400kB/800kB 3.5" GCR | 🦄 | 🦄 | MACHFS  |
-| [`micropolis`](doc/disk-micropolis.md) | Micropolis: 100tpi MetaFloppy disks | 🦄 | 🦄 |  |
-| [`ms2000`](doc/disk-ms2000.md) | : MS2000 Microdisk Development System |  |  | MICRODOS  |
-| [`mx`](doc/disk-mx.md) | DVK MX: Soviet-era PDP-11 clone | 🦖 |  |  |
-| [`n88basic`](doc/disk-n88basic.md) | N88-BASIC: PC8800/PC98 5.25" 77-track 26-sector DSHD | 🦄 | 🦄 |  |
-| [`northstar`](doc/disk-northstar.md) | Northstar: 5.25" hard sectored | 🦄 | 🦄 |  |
-| [`psos`](doc/disk-psos.md) | pSOS: 800kB DSDD with PHILE | 🦄 | 🦄 | PHILE  |
-| [`rolandd20`](doc/disk-rolandd20.md) | Roland D20: 3.5" electronic synthesiser disks | 🦄 | 🦖 | ROLAND  |
-| [`rx50`](doc/disk-rx50.md) | Digital RX50: 400kB 5.25" 80-track 10-sector SSDD | 🦖 | 🦖 |  |
-| [`smaky6`](doc/disk-smaky6.md) | Smaky 6: 308kB 5.25" 77-track 16-sector SSDD, hard sectored | 🦖 |  | SMAKY6  |
-| [`tartu`](doc/disk-tartu.md) | Tartu: The Palivere and variations | 🦄 | 🦖 | CPMFS  |
-| [`tids990`](doc/disk-tids990.md) | Texas Instruments DS990: 1126kB 8" DSSD | 🦖 | 🦖 |  |
-| [`tiki`](doc/disk-tiki.md) | Tiki 100: CP/M |  |  | CPMFS  |
-| [`victor9k`](doc/disk-victor9k.md) | Victor 9000 / Sirius One: 1224kB 5.25" DSDD GCR | 🦖 | 🦖 |  |
-| [`zilogmcz`](doc/disk-zilogmcz.md) | Zilog MCZ: 320kB 8" 77-track SSSD hard-sectored | 🦖 |  | ZDOS  |
+| Format                                    | Read? | Write? | Notes |
+|:------------------------------------------|:-----:|:------:|-------|
+| [IBM PC compatible](doc/disk-ibm.md)      |  🦄   |   🦄   | and compatibles (like the Atari ST) |
+| [Acorn ADFS](doc/disk-acornadfs.md)       |  🦄   |   🦖*  | single- and double- sided           |
+| [Acorn DFS](doc/disk-acorndfs.md)         |  🦄   |   🦖*  |                                     |
+| [Ampro Little Board](doc/disk-ampro.md)   |  🦖   |   🦖*  |                                     |
+| [Apple II DOS 3.3](doc/disk-apple2.md)    |  🦄   |        | doesn't do logical sector remapping |
+| [Amiga](doc/disk-amiga.md)                |  🦄   |   🦄   |                                     |
+| [Commodore 64 1541/1581](doc/disk-c64.md) |  🦄   |   🦄   | and probably the other formats      |
+| [Brother 120kB](doc/disk-brother.md)      |  🦄   |   🦖   |                                     |
+| [Brother 240kB](doc/disk-brother.md)      |  🦄   |   🦄   |                                     |
+| [Brother FB-100](doc/disk-fb100.md)       |  🦖   |        | Tandy Model 100, Husky Hunter, knitting machines |
+| [Macintosh 800kB](doc/disk-macintosh.md)  |  🦄   |   🦄   | and probably the 400kB too          |
+| [TRS-80](doc/disk-trs80.md)               |  🦖   |   🦖*  | a minor variation of the IBM scheme |
 {: .datatable }

-<!-- FORMATSEND -->
+`*`: these formats are variations of the generic IBM format, and since the
+IBM writer is completely generic, it should be configurable for these
+formats... theoretically. I don't have the hardware to try it.
+
+### Even older disk formats
+
+These formats are for particularly old, weird architectures, even by the
+standards of floppy disks. They've largely been implemented from single flux
+files with no access to physical hardware. Typically the reads were pretty
+bad and I've had to make a number of guesses as to how things work. They do,
+at least, check the CRC so what data's there is probably good.
+
+| Format                                   | Read? | Write? | Notes |
+|:-----------------------------------------|:-----:|:------:|-------|
+| [AES Superplus / No Problem](doc/disk-aeslanier.md) |  🦖   | | hard sectors! |
+| [Durango F85](doc/disk-durangof85.md)    |  🦖   |        | 5.25" |
+| [DVK MX](doc/disk-mx.md)                 |  🦖   |        | Soviet PDP-11 clone |
+| [VDS Eco1](doc/disk-eco1.md)             |  🦖   |        | 8" mixed format |
+| [Micropolis](doc/disk-micropolis.md)     |  🦄   |        | Micropolis 100tpi drives |
+| [Northstar(doc/disk-northstar.md)        |  🦖   |   🦖   | 5.25" hard sectors |
+| [TI DS990 FD1000](doc/disk-tids990.md)   |  🦄   |  🦄    | 8" |
+| [Victor 9000](doc/disk-victor9k.md)      |  🦖   |        | 8" |
+| [Zilog MCZ](doc/disk-zilogmcz.md)        |  🦖   |        | 8" _and_ hard sectors |
+{: .datatable }

 ### Notes

@@ -159,7 +146,7 @@ choices because they can store multiple types of file system.
    There hasn't been a lot of demand for this yet; if you have a pressing
    need to write weird disks, [please
    ask](https://github.com/davidgiven/fluxengine/issues/new). I haven't
-    implemented write support for PC disks because they're boring and I'm lazy,
+    implement write support for PC disks because they're boring and I'm lazy,
    and also because they vary so much that figuring out how to specify them
    is hard.

@@ -213,12 +200,17 @@ There may or may not be anything interesting there.
 License
 -------

-Everything here _except the contents of the `dep` directory_ is © 2022 The
-FluxEngine Authors (mostly me, David Given; see the VCS history for the other
-people) and is licensed under the MIT open source license. Please see
+Everything here _except the contents of the `dep` directory_ is © 2019 David
+Given and is licensed under the MIT open source license. Please see
 [COPYING](COPYING) for the full text. The tl;dr is: you can do what you like
 with it provided you don't claim you wrote it.

+As an exception, `dep/fmt` contains a copy of [fmt](http://fmtlib.net),
+maintained by Victor Zverovich (`vitaut <https://github.com/vitaut>`) and
+Jonathan Müller (`foonathan <https://github.com/foonathan>`) with
+contributions from many other people. It is licensed under the terms of the
+BSD license. Please see the contents of the directory for the full text.
+
 As an exception, `dep/emu` contains parts of the OpenBSD C library
 code, maintained by Todd Miller and William A. Rowe (and probably others). It is licensed
 under the terms of the 3-clause BSD license. Please see the contents of the
@@ -236,28 +228,5 @@ text.

 As an exception, `dep/snowhouse` contains the snowhouse assertion library,
 taken from https://github.com/banditcpp/snowhouse. It is Boost Standard License
-1.0 licensed. Please see the contents of the directory for the full text. Note
-that this is only used during the build and no code ends up in the output
-binaries.
+1.0 licensed. Please see the contents of the directory for the full text.

-As an exception, `dep/libusbp` contains the libusbp library, taken from
-https://github.com/pololu/libusbp. It is MIT licensed. Please see the contents
-of the directory for the full text.
-
-As an exception, `dep/fatfs` contains the fatfs library, taken from
-http://elm-chan.org/fsw/ff/00index_e.html. It is single-clause BSD licensed.
-Please see the contents of the directory for the full text.
-
-As an exception, `dep/adflib` contains the adflib library, written by Laurent
-Clevy et al, taken from https://github.com/lclevy/ADFlib. It is GPL 2.0
-licensed. Please see the contents of the directory for the full text.
-
-As an exception, `dep/hfsutils` contains a partial copy of the hfsutils
-package, written by Robert Leslie et al, taken from
-https://www.mars.org/home/rob/proj/hfs. It is GPL 2.0 licensed. Please see the
-contents of the directory for the full text.
-
-__Important:__ Because of all these exceptions, if you distribute the
-FluxEngine package as a whole, you must comply with the terms of _all_ of the
-licensing terms. This means that __effectively the FluxEngine package is
-distributable under the terms of the GPL 2.0__.
--- a/arch/aeslanier/aeslanier.h
+++ b/arch/aeslanier/aeslanier.h
@@ -1,21 +1,22 @@
 #ifndef AESLANIER_H
 #define AESLANIER_H

-/* MFM:
- * 
- * Raw bits:
- *    5    5    5    5    5    1    2    2
- * 0101 0101 0101 0101 0101 0001 0010 0010
- * 0 0  0 0  0 0  0 0  0 0  0 0  0 1  0 1
- *        0         0         0         5
- * Decoded bits.
- */
-
 #define AESLANIER_RECORD_SEPARATOR 0x55555122
-#define AESLANIER_SECTOR_LENGTH 256
-#define AESLANIER_RECORD_SIZE (AESLANIER_SECTOR_LENGTH + 4)
+#define AESLANIER_SECTOR_LENGTH    256
+#define AESLANIER_RECORD_SIZE      (AESLANIER_SECTOR_LENGTH + 5)

-extern std::unique_ptr<Decoder> createAesLanierDecoder(
-    const DecoderProto& config);
+class Sector;
+class Fluxmap;
+class AesLanierDecoderProto;
+
+class AesLanierDecoder : public AbstractDecoder
+{
+public:
+	AesLanierDecoder(const AesLanierDecoderProto&) {}
+    virtual ~AesLanierDecoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+};

 #endif
--- a/arch/aeslanier/aeslanier.proto
+++ b/arch/aeslanier/aeslanier.proto
@@ -1,4 +1,4 @@
 syntax = "proto2";

-message AesLanier5DecoderProto {}
+message AesLanierDecoderProto {}

--- a/arch/aeslanier/decoder.cc
+++ b/arch/aeslanier/decoder.cc
@@ -1,65 +1,65 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
+#include "globals.h"
+#include "decoders/decoders.h"
 #include "aeslanier.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
+#include "crc.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "sector.h"
+#include "bytes.h"
+#include "record.h"
 #include "fmt/format.h"
 #include <string.h>

 static const FluxPattern SECTOR_PATTERN(32, AESLANIER_RECORD_SEPARATOR);

-/* This is actually M2FM, rather than MFM, but it our MFM/FM decoder copes fine
- * with it. */
+/* This is actually M2FM, rather than MFM, but it our MFM/FM decoder copes fine with it. */

-class AesLanierDecoder : public Decoder
+static Bytes reverse_bits(const Bytes& input)
 {
-public:
-    AesLanierDecoder(const DecoderProto& config): Decoder(config) {}
+    Bytes output;
+    ByteWriter bw(output);

-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(SECTOR_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        /* Skip ID mark (we know it's a AESLANIER_RECORD_SEPARATOR). */
-
-        readRawBits(16);
-
-        const auto& rawbits = readRawBits(AESLANIER_RECORD_SIZE * 16);
-        const auto& bytes =
-            decodeFmMfm(rawbits).slice(0, AESLANIER_RECORD_SIZE);
-        const auto& reversed = bytes.reverseBits();
-
-        _sector->logicalTrack = reversed[1];
-        _sector->logicalSide = 0;
-        _sector->logicalSector = reversed[2];
-
-        /* Check header 'checksum' (which seems far too simple to mean much). */
-
-        {
-            uint8_t wanted = reversed[3];
-            uint8_t got = reversed[1] + reversed[2];
-            if (wanted != got)
-                return;
-        }
-
-        /* Check data checksum, which also includes the header and is
-         * significantly better. */
-
-        _sector->data = reversed.slice(1, AESLANIER_SECTOR_LENGTH);
-        uint16_t wanted = reversed.reader().seek(0x101).read_le16();
-        uint16_t got = crc16ref(MODBUS_POLY_REF, _sector->data);
-        _sector->status = (wanted == got) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createAesLanierDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new AesLanierDecoder(config));
+    for (uint8_t b : input)
+        bw.write_8(reverse_bits(b));
+    return output;
+}
+
+AbstractDecoder::RecordType AesLanierDecoder::advanceToNextRecord()
+{
+    _sector->clock = _fmr->seekToPattern(SECTOR_PATTERN);
+    if (_fmr->eof() || !_sector->clock)
+        return UNKNOWN_RECORD;
+    return SECTOR_RECORD;
+}
+
+void AesLanierDecoder::decodeSectorRecord()
+{
+    /* Skip ID mark. */
+
+    readRawBits(16);
+
+    const auto& rawbits = readRawBits(AESLANIER_RECORD_SIZE*16);
+    const auto& bytes = decodeFmMfm(rawbits).slice(0, AESLANIER_RECORD_SIZE);
+    const auto& reversed = reverse_bits(bytes);
+
+    _sector->logicalTrack = reversed[1];
+    _sector->logicalSide = 0;
+    _sector->logicalSector = reversed[2];
+
+    /* Check header 'checksum' (which seems far too simple to mean much). */
+
+    {
+        uint8_t wanted = reversed[3];
+        uint8_t got = reversed[1] + reversed[2];
+        if (wanted != got)
+            return;
+    }
+
+    /* Check data checksum, which also includes the header and is
+        * significantly better. */
+
+    _sector->data = reversed.slice(1, AESLANIER_SECTOR_LENGTH);
+    uint16_t wanted = reversed.reader().seek(0x101).read_le16();
+    uint16_t got = crc16ref(MODBUS_POLY_REF, _sector->data);
+    _sector->status = (wanted == got) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/aeslanier5/aeslanier5.h
+++ b/arch/aeslanier5/aeslanier5.h
@@ -1,21 +0,0 @@
-#ifndef AESLANIER5_H
-#define AESLANIER5_H
-
-/* Format is FM:
- *
- *    a    a    a    a    f    b    e    f
- * 1010 1010 1010 1010 1111 1011 1110 1111
- *  0 0  0 0  0 0  0 0  1 1  0 1  1 0  1 1
- *         0         0         d         b
- * 
- * However, note that this pattern is _not_ reversed...
- */
-
-#define AESLANIER5_RECORD_SEPARATOR 0xaaaaaaaaaaaafbefLL
-#define AESLANIER5_SECTOR_LENGTH 151
-#define AESLANIER5_RECORD_SIZE (AESLANIER5_SECTOR_LENGTH + 3)
-
-extern std::unique_ptr<Decoder> createAesLanier5Decoder(
-    const DecoderProto& config);
-
-#endif
--- a/arch/aeslanier5/aeslanier5.proto
+++ b/arch/aeslanier5/aeslanier5.proto
@@ -1,4 +0,0 @@
-syntax = "proto2";
-
-message AesLanierDecoderProto {}
-
--- a/arch/aeslanier5/decoder.cc
+++ b/arch/aeslanier5/decoder.cc
@@ -1,78 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "aeslanier5.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
-#include "fmt/format.h"
-#include <string.h>
-
-static const FluxPattern SECTOR_PATTERN(32, AESLANIER5_RECORD_SEPARATOR);
-
-/* This is actually FM, rather than MFM, but it our MFM/FM decoder copes fine
- * with it. */
-
-class AesLanier5Decoder : public Decoder
-{
-public:
-    AesLanier5Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(SECTOR_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        /* Skip ID mark (we know it's a AESLANIER5_RECORD_SEPARATOR). */
-
-        readRawBits(SECTOR_PATTERN.length());
-
-        const auto& rawbits = readRawBits(AESLANIER5_RECORD_SIZE * 16);
-        const auto& bytes =
-            decodeFmMfm(rawbits).slice(0, AESLANIER5_RECORD_SIZE);
-        const auto& reversed = bytes.reverseBits();
-
-        uint8_t encodedTrack = reversed[0];
-        uint8_t encodedSector = reversed[1];
-
-        _sector->logicalTrack = encodedTrack >> 1;
-        _sector->logicalSide = 0;
-        _sector->logicalSector = encodedSector;
-
-        /* Check header 'checksum' (which seems far too simple to mean much). */
-
-        {
-            uint8_t wanted = reversed[2];
-            uint8_t got = reversed[0] + reversed[1];
-            if (wanted != got)
-                return;
-        }
-
-        /* Check data checksum, which also includes the header and is
-         * significantly better. */
-
-        _sector->data = reversed.slice(3, AESLANIER5_SECTOR_LENGTH);
-        uint8_t wanted, got;
-        ByteReader br(_sector->data);
-        if ((encodedSector == 0) || (encodedSector == 8))
-        {
-            wanted = br.seek(17).read_8() + br.seek(150).read_8();
-            got = sumBytes(_sector->data.slice(0, 17)) + sumBytes(_sector->data.slice(18, 132));
-        }
-        else
-        {
-            wanted = br.seek(150).read_8();
-            got = sumBytes(_sector->data.slice(0, AESLANIER5_SECTOR_LENGTH-1));
-        }
-        _sector->status = (wanted == got) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createAesLanier5Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new AesLanier5Decoder(config));
-}
--- a/arch/agat/agat.cc
+++ b/arch/agat/agat.cc
@@ -1,20 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "agat.h"
-#include "lib/core/bytes.h"
-#include "fmt/format.h"
-
-uint8_t agatChecksum(const Bytes& bytes)
-{
-    uint16_t checksum = 0;
-
-    for (uint8_t b : bytes)
-    {
-        if (checksum > 0xff)
-            checksum = (checksum + 1) & 0xff;
-
-        checksum += b;
-    }
-
-    return checksum & 0xff;
-}
--- a/arch/agat/agat.h
+++ b/arch/agat/agat.h
@@ -1,19 +0,0 @@
-#ifndef AGAT_H
-#define AGAT_H
-
-#define AGAT_SECTOR_SIZE 256
-
-static constexpr uint64_t SECTOR_ID = 0x8924555549111444;
-static constexpr uint64_t DATA_ID = 0x8924555514444911;
-
-class Encoder;
-class EncoderProto;
-class Decoder;
-class DecoderProto;
-
-extern std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createAgatEncoder(const EncoderProto& config);
-
-extern uint8_t agatChecksum(const Bytes& bytes);
-
-#endif
--- a/arch/agat/agat.proto
+++ b/arch/agat/agat.proto
@@ -1,19 +0,0 @@
-syntax = "proto2";
-
-import "lib/config/common.proto";
-
-message AgatDecoderProto {}
-
-message AgatEncoderProto {
-	optional double target_clock_period_us = 1
-		[default=2.00, (help)="Data clock period of target format."];
-	optional double target_rotational_period_ms = 2
-		[default=200.0, (help)="Rotational period of target format."];
-	optional int32 post_index_gap_bytes = 3
-		[default=40, (help)="Post-index gap before first sector header."];
-	optional int32 pre_sector_gap_bytes = 4
-		[default=11, (help)="Gap before each sector header."];
-	optional int32 pre_data_gap_bytes = 5
-		[default=2, (help)="Gap before each sector data record."];
-}
-
--- a/arch/agat/decoder.cc
+++ b/arch/agat/decoder.cc
@@ -1,90 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "agat.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
-#include "fmt/format.h"
-#include <string.h>
-
-// clang-format off
-/*
- * data:    X  X  X  X   X  X  X  X   X  -  -  X   -  X  -  X   -  X  X  -   X  -  X  -  = 0xff956a
- * flux:   01 01 01 01  01 01 01 01  01 00 10 01  00 01 00 01  00 01 01 00  01 00 01 00  = 0x555549111444
- * 
- * data:    X  X  X  X   X  X  X  X   -  X  X  -   X  -  X  -   X  -  -  X   -  X  -  X  = 0xff6a95
- * flux:   01 01 01 01  01 01 01 01  00 01 01 00  01 00 01 00  01 00 10 01  00 01 00 01  = 0x555514444911
- *
- * Each pattern is prefixed with this one:
- *
- * data:          -  -   -  X   -  -   X  - = 0x12
- * flux:    (10) 10 10  10 01  00 10  01 00 = 0xa924
- * magic:   (10) 10 00  10 01  00 10  01 00 = 0x8924
- *                  ^
- *
- * This seems to be generated by emitting A4 in MFM and then a single 0 bit to
- * shift it out of phase, so the data bits become clock bits and vice versa.
- *
- *           X - X - - X - -  = 0xA4
- *          0100010010010010  = MFM encoded
- *           1000100100100100 = with trailing zero
- *            - - - X - - X - = effective bitstream = 0x12
- */
-// clang-format on
-
-static const FluxPattern SECTOR_PATTERN(64, SECTOR_ID);
-static const FluxPattern DATA_PATTERN(64, DATA_ID);
-
-static const FluxMatchers ALL_PATTERNS = {&SECTOR_PATTERN, &DATA_PATTERN};
-
-class AgatDecoder : public Decoder
-{
-public:
-    AgatDecoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ALL_PATTERNS);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw64() != SECTOR_ID)
-            return;
-
-        auto bytes = decodeFmMfm(readRawBits(64)).slice(0, 4);
-        if (bytes[3] != 0x5a)
-            return;
-
-        _sector->logicalTrack = bytes[1] >> 1;
-        _sector->logicalSector = bytes[2];
-        _sector->logicalSide = bytes[1] & 1;
-        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-    }
-
-    void decodeDataRecord() override
-    {
-        if (readRaw64() != DATA_ID)
-            return;
-
-        Bytes bytes = decodeFmMfm(readRawBits((AGAT_SECTOR_SIZE + 2) * 16))
-                          .slice(0, AGAT_SECTOR_SIZE + 2);
-
-        if (bytes[AGAT_SECTOR_SIZE + 1] != 0x5a)
-            return;
-
-        _sector->data = bytes.slice(0, AGAT_SECTOR_SIZE);
-        uint8_t wantChecksum = bytes[AGAT_SECTOR_SIZE];
-        uint8_t gotChecksum = agatChecksum(_sector->data);
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new AgatDecoder(config));
-}
--- a/arch/agat/encoder.cc
+++ b/arch/agat/encoder.cc
@@ -1,118 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "agat.h"
-#include "lib/core/crc.h"
-#include "lib/data/image.h"
-#include "lib/data/layout.h"
-#include "arch/agat/agat.pb.h"
-#include "lib/encoders/encoders.pb.h"
-
-class AgatEncoder : public Encoder
-{
-public:
-    AgatEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.agat())
-    {
-    }
-
-private:
-    void writeRawBits(uint64_t data, int width)
-    {
-        _cursor += width;
-        _lastBit = data & 1;
-        for (int i = 0; i < width; i++)
-        {
-            unsigned pos = _cursor - i - 1;
-            if (pos < _bits.size())
-                _bits[pos] = data & 1;
-            data >>= 1;
-        }
-    }
-
-    void writeBytes(const Bytes& bytes)
-    {
-        encodeMfm(_bits, _cursor, bytes, _lastBit);
-    }
-
-    void writeByte(uint8_t byte)
-    {
-        Bytes b;
-        b.writer().write_8(byte);
-        writeBytes(b);
-    }
-
-    void writeFillerRawBytes(int count, uint16_t byte)
-    {
-        for (int i = 0; i < count; i++)
-            writeRawBits(byte, 16);
-    };
-
-    void writeFillerBytes(int count, uint8_t byte)
-    {
-        Bytes b{byte};
-        for (int i = 0; i < count; i++)
-            writeBytes(b);
-    };
-
-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        auto trackLayout = Layout::getLayoutOfTrack(
-            trackInfo->logicalTrack, trackInfo->logicalSide);
-
-        double clockRateUs = _config.target_clock_period_us() / 2.0;
-        int bitsPerRevolution =
-            (_config.target_rotational_period_ms() * 1000.0) / clockRateUs;
-        _bits.resize(bitsPerRevolution);
-        _cursor = 0;
-
-        writeFillerRawBytes(_config.post_index_gap_bytes(), 0xaaaa);
-
-        for (const auto& sector : sectors)
-        {
-            /* Header */
-
-            writeFillerRawBytes(_config.pre_sector_gap_bytes(), 0xaaaa);
-            writeRawBits(SECTOR_ID, 64);
-            writeByte(0x5a);
-            writeByte((sector->logicalTrack << 1) | sector->logicalSide);
-            writeByte(sector->logicalSector);
-            writeByte(0x5a);
-
-            /* Data */
-
-            writeFillerRawBytes(_config.pre_data_gap_bytes(), 0xaaaa);
-            auto data = sector->data.slice(0, AGAT_SECTOR_SIZE);
-            writeRawBits(DATA_ID, 64);
-            writeBytes(data);
-            writeByte(agatChecksum(data));
-            writeByte(0x5a);
-        }
-
-        if (_cursor >= _bits.size())
-            error("track data overrun");
-        fillBitmapTo(_bits, _cursor, _bits.size(), {true, false});
-
-        auto fluxmap = std::make_unique<Fluxmap>();
-        fluxmap->appendBits(_bits,
-            calculatePhysicalClockPeriod(_config.target_clock_period_us() * 1e3,
-                _config.target_rotational_period_ms() * 1e6));
-        return fluxmap;
-    }
-
-private:
-    const AgatEncoderProto& _config;
-    uint32_t _cursor;
-    bool _lastBit;
-    std::vector<bool> _bits;
-};
-
-std::unique_ptr<Encoder> createAgatEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new AgatEncoder(config));
-}
--- a/arch/amiga/amiga.cc
+++ b/arch/amiga/amiga.cc
@@ -1,7 +1,8 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
 #include "amiga.h"
-#include "lib/core/bytes.h"
+#include "bytes.h"
 #include "fmt/format.h"

 uint32_t amigaChecksum(const Bytes& bytes)
@@ -18,61 +19,61 @@ uint32_t amigaChecksum(const Bytes& bytes)

 static uint8_t everyother(uint16_t x)
 {
-    /* aabb ccdd eeff gghh */
-    x &= 0x6666; /* 0ab0 0cd0 0ef0 0gh0 */
-    x >>= 1;     /* 00ab 00cd 00ef 00gh */
-    x |= x << 2; /* abab cdcd efef ghgh */
-    x &= 0x3c3c; /* 00ab cd00 00ef gh00 */
-    x >>= 2;     /* 0000 abcd 0000 efgh */
-    x |= x >> 4; /* 0000 abcd abcd efgh */
-    return x;
+	                  /* aabb ccdd eeff gghh */
+	x &= 0x6666;      /* 0ab0 0cd0 0ef0 0gh0 */
+	x >>= 1;          /* 00ab 00cd 00ef 00gh */
+	x |= x << 2;      /* abab cdcd efef ghgh */
+	x &= 0x3c3c;      /* 00ab cd00 00ef gh00 */
+	x >>= 2;          /* 0000 abcd 0000 efgh */
+	x |= x >> 4;      /* 0000 abcd abcd efgh */
+	return x;
 }

 Bytes amigaInterleave(const Bytes& input)
 {
-    Bytes output;
-    ByteWriter bw(output);
+	Bytes output;
+	ByteWriter bw(output);

-    /* Write all odd bits. (Numbering starts at 0...) */
+	/* Write all odd bits. (Numbering starts at 0...) */

-    {
-        ByteReader br(input);
-        while (!br.eof())
-        {
-            uint16_t x = br.read_be16();
-            x &= 0xaaaa;       /* a0b0 c0d0 e0f0 g0h0 */
-            x |= x >> 1;       /* aabb ccdd eeff gghh */
-            x = everyother(x); /* 0000 0000 abcd efgh */
-            bw.write_8(x);
-        }
-    }
+	{
+		ByteReader br(input);
+		while (!br.eof())
+		{
+			uint16_t x = br.read_be16();
+			x &= 0xaaaa;       /* a0b0 c0d0 e0f0 g0h0 */
+			x |= x >> 1;       /* aabb ccdd eeff gghh */
+			x = everyother(x); /* 0000 0000 abcd efgh */
+			bw.write_8(x);
+		}
+	}

-    /* Write all even bits. */
+	/* Write all even bits. */

-    {
-        ByteReader br(input);
-        while (!br.eof())
-        {
-            uint16_t x = br.read_be16();
-            x &= 0x5555;       /* 0a0b 0c0d 0e0f 0g0h */
-            x |= x << 1;       /* aabb ccdd eeff gghh */
-            x = everyother(x); /* 0000 0000 abcd efgh */
-            bw.write_8(x);
-        }
-    }
+	{
+		ByteReader br(input);
+		while (!br.eof())
+		{
+			uint16_t x = br.read_be16();
+			x &= 0x5555;       /* 0a0b 0c0d 0e0f 0g0h */
+			x |= x << 1;       /* aabb ccdd eeff gghh */
+			x = everyother(x); /* 0000 0000 abcd efgh */
+			bw.write_8(x);
+		}
+	}

-    return output;
+	return output;
 }

 Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
 {
    assert(!(len & 1));
    const uint8_t* odds = &input[0];
-    const uint8_t* evens = &input[len / 2];
+    const uint8_t* evens = &input[len/2];
    Bytes output;
    ByteWriter bw(output);

-    for (size_t i = 0; i < len / 2; i++)
+    for (size_t i=0; i<len/2; i++)
    {
        uint8_t o = *odds++;
        uint8_t e = *evens++;
@@ -81,15 +82,11 @@ Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
         * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
         */
        uint16_t result =
-            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL) *
-                     0x0102040810204081ULL >>
-                 49) &
-                0x5555) |
-            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL) *
-                     0x0102040810204081ULL >>
-                 48) &
-                0xAAAA);
-
+            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL)
+                * 0x0102040810204081ULL >> 49) & 0x5555) |
+            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL)
+                * 0x0102040810204081ULL >> 48) & 0xAAAA);
+        
        bw.write_be16(result);
    }

@@ -99,6 +96,6 @@ Bytes amigaDeinterleave(const uint8_t*& input, size_t len)

 Bytes amigaDeinterleave(const Bytes& input)
 {
-    const uint8_t* ptr = input.cbegin();
-    return amigaDeinterleave(ptr, input.size());
+	const uint8_t* ptr = input.cbegin();
+	return amigaDeinterleave(ptr, input.size());
 }
--- a/arch/amiga/amiga.h
+++ b/arch/amiga/amiga.h
@@ -1,16 +1,45 @@
 #ifndef AMIGA_H
 #define AMIGA_H

-#include "lib/encoders/encoders.h"
+#include "encoders/encoders.h"

 #define AMIGA_SECTOR_RECORD 0xaaaa44894489LL

 #define AMIGA_TRACKS_PER_DISK 80
 #define AMIGA_SECTORS_PER_TRACK 11
-#define AMIGA_RECORD_SIZE 0x21c
+#define AMIGA_RECORD_SIZE 0x21f

-extern std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config);
+class Sector;
+class Fluxmap;
+class SectorSet;
+class AmigaDecoderProto;
+class AmigaEncoderProto;
+
+class AmigaDecoder : public AbstractDecoder
+{
+public:
+	AmigaDecoder(const AmigaDecoderProto&) {}
+    virtual ~AmigaDecoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+
+	std::set<unsigned> requiredSectors(Track& track) const;
+};
+
+class AmigaEncoder : public AbstractEncoder
+{
+public:
+	AmigaEncoder(const AmigaEncoderProto& config):
+		_config(config) {}
+	virtual ~AmigaEncoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	const AmigaEncoderProto& _config;
+};

 extern uint32_t amigaChecksum(const Bytes& bytes);
 extern Bytes amigaInterleave(const Bytes& input);
--- a/arch/amiga/amiga.proto
+++ b/arch/amiga/amiga.proto
@@ -1,6 +1,6 @@
 syntax = "proto2";

-import "lib/config/common.proto";
+import "lib/common.proto";

 message AmigaDecoderProto {}

--- a/arch/amiga/decoder.cc
+++ b/arch/amiga/decoder.cc
@@ -1,85 +1,67 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "amiga.h"
-#include "lib/core/bytes.h"
+#include "bytes.h"
 #include "fmt/format.h"
-#include "lib/decoders/decoders.pb.h"
 #include <string.h>
 #include <algorithm>

-/*
+/* 
 * Amiga disks use MFM but it's not quite the same as IBM MFM. They only use
 * a single type of record with a different marker byte.
- *
+ * 
 * See the big comment in the IBM MFM decoder for the gruesome details of how
 * MFM works.
 */
-
+         
 static const FluxPattern SECTOR_PATTERN(48, AMIGA_SECTOR_RECORD);

-class AmigaDecoder : public Decoder
+AbstractDecoder::RecordType AmigaDecoder::advanceToNextRecord()
 {
-public:
-    AmigaDecoder(const DecoderProto& config):
-        Decoder(config),
-        _config(config.amiga())
-    {
-    }
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(SECTOR_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw48() != AMIGA_SECTOR_RECORD)
-            return;
-
-        const auto& rawbits = readRawBits(AMIGA_RECORD_SIZE * 16);
-        if (rawbits.size() < (AMIGA_RECORD_SIZE * 16))
-            return;
-        const auto& rawbytes = toBytes(rawbits).slice(0, AMIGA_RECORD_SIZE * 2);
-        const auto& bytes = decodeFmMfm(rawbits).slice(0, AMIGA_RECORD_SIZE);
-
-        const uint8_t* ptr = bytes.begin();
-
-        Bytes header = amigaDeinterleave(ptr, 4);
-        Bytes recoveryinfo = amigaDeinterleave(ptr, 16);
-
-        _sector->logicalTrack = header[1] >> 1;
-        _sector->logicalSide = header[1] & 1;
-        _sector->logicalSector = header[2];
-
-        uint32_t wantedheaderchecksum =
-            amigaDeinterleave(ptr, 4).reader().read_be32();
-        uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(0, 40));
-        if (gotheaderchecksum != wantedheaderchecksum)
-            return;
-
-        uint32_t wanteddatachecksum =
-            amigaDeinterleave(ptr, 4).reader().read_be32();
-        uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(56, 1024));
-
-        Bytes data;
-        data.writer().append(amigaDeinterleave(ptr, 512)).append(recoveryinfo);
-        _sector->data = data;
-        _sector->status = (gotdatachecksum == wanteddatachecksum)
-                              ? Sector::OK
-                              : Sector::BAD_CHECKSUM;
-    }
-
-private:
-    const AmigaDecoderProto& _config;
-    nanoseconds_t _clock;
-};
-
-std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new AmigaDecoder(config));
+    _sector->clock = _fmr->seekToPattern(SECTOR_PATTERN);
+    if (_fmr->eof() || !_sector->clock)
+        return UNKNOWN_RECORD;
+    return SECTOR_RECORD;
 }
+
+void AmigaDecoder::decodeSectorRecord()
+{
+    const auto& rawbits = readRawBits(AMIGA_RECORD_SIZE*16);
+	if (rawbits.size() < (AMIGA_RECORD_SIZE*16))
+		return;
+    const auto& rawbytes = toBytes(rawbits).slice(0, AMIGA_RECORD_SIZE*2);
+    const auto& bytes = decodeFmMfm(rawbits).slice(0, AMIGA_RECORD_SIZE);
+
+    const uint8_t* ptr = bytes.begin() + 3;
+
+    Bytes header = amigaDeinterleave(ptr, 4);
+    Bytes recoveryinfo = amigaDeinterleave(ptr, 16);
+
+    _sector->logicalTrack = header[1] >> 1;
+    _sector->logicalSide = header[1] & 1;
+    _sector->logicalSector = header[2];
+
+    uint32_t wantedheaderchecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
+    uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(6, 40));
+    if (gotheaderchecksum != wantedheaderchecksum)
+        return;
+
+    uint32_t wanteddatachecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
+    uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(62, 1024));
+
+    _sector->data.clear();
+    _sector->data.writer().append(amigaDeinterleave(ptr, 512)).append(recoveryinfo);
+    _sector->status = (gotdatachecksum == wanteddatachecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+}
+
+std::set<unsigned> AmigaDecoder::requiredSectors(Track& track) const
+{
+	static std::set<unsigned> sectors = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	return sectors;
+}
+
--- a/arch/amiga/encoder.cc
+++ b/arch/amiga/encoder.cc
@@ -1,149 +1,126 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 #include "amiga.h"
-#include "lib/core/crc.h"
-#include "lib/data/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
 #include "arch/amiga/amiga.pb.h"
-#include "lib/encoders/encoders.pb.h"

 static bool lastBit;

 static int charToInt(char c)
 {
-    if (isdigit(c))
-        return c - '0';
-    return 10 + tolower(c) - 'a';
+	if (isdigit(c))
+		return c - '0';
+	return 10 + tolower(c) - 'a';
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
 {
-    for (bool bit : src)
-    {
-        if (cursor < bits.size())
-            lastBit = bits[cursor++] = bit;
-    }
+	for (bool bit : src)
+	{
+		if (cursor < bits.size())
+			lastBit = bits[cursor++] = bit;
+	}
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
 {
-    cursor += width;
-    lastBit = data & 1;
-    for (int i = 0; i < width; i++)
-    {
-        unsigned pos = cursor - i - 1;
-        if (pos < bits.size())
-            bits[pos] = data & 1;
-        data >>= 1;
-    }
+	cursor += width;
+	lastBit = data & 1;
+	for (int i=0; i<width; i++)
+	{
+		unsigned pos = cursor - i - 1;
+		if (pos < bits.size())
+			bits[pos] = data & 1;
+		data >>= 1;
+	}
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
 {
-    ByteReader br(bytes);
-    BitReader bitr(br);
+	ByteReader br(bytes);
+	BitReader bitr(br);

-    while (!bitr.eof())
-    {
-        if (cursor < bits.size())
-            bits[cursor++] = bitr.get();
-    }
+	while (!bitr.eof())
+	{
+		if (cursor < bits.size())
+			bits[cursor++] = bitr.get();
+	}
 }

-static void write_sector(std::vector<bool>& bits,
-    unsigned& cursor,
-    const std::shared_ptr<const Sector>& sector)
+static void write_sector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector)
 {
-    if ((sector->data.size() != 512) && (sector->data.size() != 528))
-        error("unsupported sector size --- you must pick 512 or 528");
+	if ((sector->data.size() != 512) && (sector->data.size() != 528))
+		Error() << "unsupported sector size --- you must pick 512 or 528";

-    uint32_t checksum = 0;
+	uint32_t checksum = 0;

-    auto write_interleaved_bytes = [&](const Bytes& bytes)
-    {
-        Bytes interleaved = amigaInterleave(bytes);
-        Bytes mfm = encodeMfm(interleaved, lastBit);
-        checksum ^= amigaChecksum(mfm);
-        checksum &= 0x55555555;
-        write_bits(bits, cursor, mfm);
-    };
+	auto write_interleaved_bytes = [&](const Bytes& bytes)
+	{
+		Bytes interleaved = amigaInterleave(bytes);
+		Bytes mfm = encodeMfm(interleaved, lastBit);
+		checksum ^= amigaChecksum(mfm);
+		checksum &= 0x55555555;
+		write_bits(bits, cursor, mfm);
+	};

-    auto write_interleaved_word = [&](uint32_t word)
-    {
-        Bytes b(4);
-        b.writer().write_be32(word);
-        write_interleaved_bytes(b);
-    };
+	auto write_interleaved_word = [&](uint32_t word)
+	{
+		Bytes b(4);
+		b.writer().write_be32(word);
+		write_interleaved_bytes(b);
+	};

-    write_bits(bits, cursor, 0xaaaa, 2 * 8);
-    write_bits(bits, cursor, AMIGA_SECTOR_RECORD, 6 * 8);
+    write_bits(bits, cursor, AMIGA_SECTOR_RECORD, 6*8);

-    checksum = 0;
-    Bytes header = {0xff, /* Amiga 1.0 format byte */
-        (uint8_t)((sector->logicalTrack << 1) | sector->logicalSide),
-        (uint8_t)sector->logicalSector,
-        (uint8_t)(AMIGA_SECTORS_PER_TRACK - sector->logicalSector)};
-    write_interleaved_bytes(header);
-    Bytes recoveryInfo(16);
-    if (sector->data.size() == 528)
-        recoveryInfo = sector->data.slice(512, 16);
-    write_interleaved_bytes(recoveryInfo);
-    write_interleaved_word(checksum);
+	checksum = 0;
+	Bytes header = 
+		{
+			0xff, /* Amiga 1.0 format byte */
+			(uint8_t) ((sector->logicalTrack<<1) | sector->logicalSide),
+			(uint8_t) sector->logicalSector,
+			(uint8_t) (AMIGA_SECTORS_PER_TRACK - sector->logicalSector)
+		};
+	write_interleaved_bytes(header);
+	Bytes recoveryInfo(16);
+	if (sector->data.size() == 528)
+		recoveryInfo = sector->data.slice(512, 16);
+	write_interleaved_bytes(recoveryInfo);
+	write_interleaved_word(checksum);

-    Bytes data = sector->data.slice(0, 512);
-    write_interleaved_word(
-        amigaChecksum(encodeMfm(amigaInterleave(data), lastBit)));
-    write_interleaved_bytes(data);
+	Bytes data = sector->data.slice(0, 512);
+	write_interleaved_word(amigaChecksum(encodeMfm(amigaInterleave(data), lastBit)));
+	write_interleaved_bytes(data);
 }

-class AmigaEncoder : public Encoder
+std::unique_ptr<Fluxmap> AmigaEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
 {
-public:
-    AmigaEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.amiga())
-    {
+	if ((physicalTrack < 0) || (physicalTrack >= AMIGA_TRACKS_PER_DISK))
+		return std::unique_ptr<Fluxmap>();
+
+	int bitsPerRevolution = 200000.0 / _config.clock_rate_us();
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;
+
+    fillBitmapTo(bits, cursor, _config.post_index_gap_ms() * 1000 / _config.clock_rate_us(), { true, false });
+	lastBit = false;
+
+	for (int sectorId=0; sectorId<AMIGA_SECTORS_PER_TRACK; sectorId++)
+	{
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		write_sector(bits, cursor, sectorData);
    }

-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        /* Number of bits for one nominal revolution of a real 200ms Amiga disk.
-         */
-        int bitsPerRevolution = 200e3 / _config.clock_rate_us();
-        std::vector<bool> bits(bitsPerRevolution);
-        unsigned cursor = 0;
+	if (cursor >= bits.size())
+		Error() << "track data overrun";
+	fillBitmapTo(bits, cursor, bits.size(), { true, false });

-        fillBitmapTo(bits,
-            cursor,
-            _config.post_index_gap_ms() * 1000 / _config.clock_rate_us(),
-            {true, false});
-        lastBit = false;
-
-        for (const auto& sector : sectors)
-            write_sector(bits, cursor, sector);
-
-        if (cursor >= bits.size())
-            error("track data overrun");
-        fillBitmapTo(bits, cursor, bits.size(), {true, false});
-
-        auto fluxmap = std::make_unique<Fluxmap>();
-        fluxmap->appendBits(bits,
-            calculatePhysicalClockPeriod(_config.clock_rate_us() * 1e3, 200e6));
-        return fluxmap;
-    }
-
-private:
-    const AmigaEncoderProto& _config;
-};
-
-std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new AmigaEncoder(config));
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(bits, _config.clock_rate_us()*1e3);
+	return fluxmap;
 }
+
--- a/arch/apple2/apple2.h
+++ b/arch/apple2/apple2.h
@@ -1,19 +1,27 @@
 #ifndef APPLE2_H
 #define APPLE2_H

-#include <memory.h>
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#define APPLE2_SECTOR_RECORD   0xd5aa96
+#define APPLE2_DATA_RECORD     0xd5aaad

-#define APPLE2_SECTOR_RECORD 0xd5aa96
-#define APPLE2_DATA_RECORD 0xd5aaad
-
-#define APPLE2_SECTOR_LENGTH 256
+#define APPLE2_SECTOR_LENGTH   256
 #define APPLE2_ENCODED_SECTOR_LENGTH 342

-#define APPLE2_SECTORS 16
+class Sector;
+class Fluxmap;
+class Apple2DecoderProto;
+
+class Apple2Decoder : public AbstractDecoder
+{
+public:
+	Apple2Decoder(const Apple2DecoderProto&) {}
+    virtual ~Apple2Decoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+};

-extern std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config);

 #endif
+
--- a/arch/apple2/apple2.proto
+++ b/arch/apple2/apple2.proto
@@ -1,22 +1,4 @@
 syntax = "proto2";

-import "lib/config/common.proto";
+message Apple2DecoderProto {}

-message Apple2DecoderProto {
-	optional uint32 side_one_track_offset = 1
-		[ default = 0, (help) = "offset to apply to track numbers on side 1" ];
-}
-
-message Apple2EncoderProto
-{
-    /* 245kHz. */
-    optional double clock_period_us = 1
-        [ default = 4, (help) = "clock rate on the real device" ];
-    
-    /* Apple II disk drives spin at 300rpm. */
-    optional double rotational_period_ms = 2
-        [ default = 200.0, (help) = "rotational period on the real device" ];
-
-	optional uint32 side_one_track_offset = 3
-		[ default = 0, (help) = "offset to apply to track numbers on side 1" ];
-}
--- a/arch/apple2/decoder.cc
+++ b/arch/apple2/decoder.cc
@@ -1,39 +1,34 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "apple2.h"
-#include "arch/apple2/apple2.pb.h"
-#include "lib/decoders/decoders.pb.h"
-#include "lib/core/bytes.h"
+#include "bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 const FluxPattern SECTOR_RECORD_PATTERN(24, APPLE2_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(24, APPLE2_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

 static int decode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

-/* This is extremely inspired by the MESS implementation, written by Nathan
- * Woods and R. Belmont:
- * https://github.com/mamedev/mame/blob/7914a6083a3b3a8c243ae6c3b8cb50b023f21e0e/src/lib/formats/ap2_dsk.cpp
+/* This is extremely inspired by the MESS implementation, written by Nathan Woods
+ * and R. Belmont: https://github.com/mamedev/mame/blob/7914a6083a3b3a8c243ae6c3b8cb50b023f21e0e/src/lib/formats/ap2_dsk.cpp
 */
 static Bytes decode_crazy_data(const uint8_t* inp, Sector::Status& status)
 {
@@ -53,11 +48,9 @@ static Bytes decode_crazy_data(const uint8_t* inp, Sector::Status& status)
        {
            /* 3 * 2 bit */
            output[i + 0] = ((checksum >> 1) & 0x01) | ((checksum << 1) & 0x02);
-            output[i + 86] =
-                ((checksum >> 3) & 0x01) | ((checksum >> 1) & 0x02);
+            output[i + 86] = ((checksum >> 3) & 0x01) | ((checksum >> 1) & 0x02);
            if ((i + 172) < APPLE2_SECTOR_LENGTH)
-                output[i + 172] =
-                    ((checksum >> 5) & 0x01) | ((checksum >> 3) & 0x02);
+                output[i + 172] = ((checksum >> 5) & 0x01) | ((checksum >> 3) & 0x02);
        }
    }

@@ -67,110 +60,53 @@ static Bytes decode_crazy_data(const uint8_t* inp, Sector::Status& status)
    return output;
 }

-static uint8_t combine(uint16_t word)
+uint8_t combine(uint16_t word)
 {
    return word & (word >> 7);
 }

-class Apple2Decoder : public Decoder
+AbstractDecoder::RecordType Apple2Decoder::advanceToNextRecord()
 {
-public:
-    Apple2Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw24() != APPLE2_SECTOR_RECORD)
-            return;
-
-        /* Read header. */
-
-        auto header = toBytes(readRawBits(8 * 8)).slice(0, 8);
-        ByteReader br(header);
-
-        uint8_t volume = combine(br.read_be16());
-        _sector->logicalTrack = combine(br.read_be16());
-        _sector->logicalSide = _sector->physicalSide;
-        _sector->logicalSector = combine(br.read_be16());
-        uint8_t checksum = combine(br.read_be16());
-
-        // If the checksum is correct, upgrade the sector from MISSING
-        // to DATA_MISSING in anticipation of its data record
-        if (checksum ==
-            (volume ^ _sector->logicalTrack ^ _sector->logicalSector))
-            _sector->status =
-                Sector::DATA_MISSING; /* unintuitive but correct */
-
-        if (_sector->logicalSide == 1)
-            _sector->logicalTrack -= _config.apple2().side_one_track_offset();
-
-        /* Sanity check. */
-
-        if (_sector->logicalTrack > 100)
-        {
-            _sector->status = Sector::MISSING;
-            return;
-        }
-    }
-
-    void decodeDataRecord() override
-    {
-        /* Check ID. */
-
-        if (readRaw24() != APPLE2_DATA_RECORD)
-            return;
-
-        // Sometimes there's a 1-bit gap between APPLE2_DATA_RECORD and
-        // the data itself.  This has been seen on real world disks
-        // such as the Apple II Operating System Kit from Apple2Online.
-        // However, I haven't seen it described in any of the various
-        // references.
-        //
-        // This extra '0' bit would not affect the real disk interface,
-        // as it was a '1' reaching the top bit of a shift register
-        // that triggered a byte to be available, but it affects the
-        // way the data is read here.
-        //
-        // While the floppies tested only seemed to need this applied
-        // to the first byte of the data record, applying it
-        // consistently to all of them doesn't seem to hurt, and
-        // simplifies the code.
-
-        /* Read and decode data. */
-
-        auto readApple8 = [&]()
-        {
-            auto result = 0;
-            while ((result & 0x80) == 0)
-            {
-                auto b = readRawBits(1);
-                if (b.empty())
-                    break;
-                result = (result << 1) | b[0];
-            }
-            return result;
-        };
-
-        constexpr unsigned recordLength = APPLE2_ENCODED_SECTOR_LENGTH + 2;
-        uint8_t bytes[recordLength];
-        for (auto& byte : bytes)
-        {
-            byte = readApple8();
-        }
-
-        // Upgrade the sector from MISSING to BAD_CHECKSUM.
-        // If decode_crazy_data succeeds, it upgrades the sector to
-        // OK.
-        _sector->status = Sector::BAD_CHECKSUM;
-        _sector->data = decode_crazy_data(&bytes[0], _sector->status);
-    }
-};
-
-std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Apple2Decoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return RecordType::SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return RecordType::DATA_RECORD;
+	return RecordType::UNKNOWN_RECORD;
+}
+
+void Apple2Decoder::decodeSectorRecord()
+{
+    /* Skip ID (as we know it's a APPLE2_SECTOR_RECORD). */
+    readRawBits(24);
+
+    /* Read header. */
+
+    auto header = toBytes(readRawBits(8*8)).slice(0, 8);
+    ByteReader br(header);
+
+    uint8_t volume = combine(br.read_be16());
+    _sector->logicalTrack = combine(br.read_be16());
+    _sector->logicalSector = combine(br.read_be16());
+    uint8_t checksum = combine(br.read_be16());
+    if (checksum == (volume ^ _sector->logicalTrack ^ _sector->logicalSector))
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+}
+
+void Apple2Decoder::decodeDataRecord()
+{
+    /* Check ID. */
+
+    Bytes bytes = toBytes(readRawBits(3*8)).slice(0, 3);
+    if (bytes.reader().read_be24() != APPLE2_DATA_RECORD)
+        return;
+
+    /* Read and decode data. */
+
+    unsigned recordLength = APPLE2_ENCODED_SECTOR_LENGTH + 2;
+    bytes = toBytes(readRawBits(recordLength*8)).slice(0, recordLength);
+
+    _sector->status = Sector::BAD_CHECKSUM;
+    _sector->data = decode_crazy_data(&bytes[0], _sector->status);
 }
--- a/arch/apple2/encoder.cc
+++ b/arch/apple2/encoder.cc
@@ -1,192 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "arch/apple2/apple2.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "lib/data/sector.h"
-#include "lib/data/image.h"
-#include "fmt/format.h"
-#include "lib/encoders/encoders.pb.h"
-#include <ctype.h>
-#include "lib/core/bytes.h"
-
-static int encode_data_gcr(uint8_t data)
-{
-    switch (data)
-    {
-#define GCR_ENTRY(gcr, data) \
-    case data:               \
-        return gcr;
-#include "data_gcr.h"
-#undef GCR_ENTRY
-    }
-    return -1;
-}
-
-class Apple2Encoder : public Encoder
-{
-public:
-    Apple2Encoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.apple2())
-    {
-    }
-
-private:
-    const Apple2EncoderProto& _config;
-
-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        int bitsPerRevolution =
-            (_config.rotational_period_ms() * 1e3) / _config.clock_period_us();
-
-        std::vector<bool> bits(bitsPerRevolution);
-        unsigned cursor = 0;
-
-        for (const auto& sector : sectors)
-            writeSector(bits, cursor, *sector);
-
-        if (cursor >= bits.size())
-            error("track data overrun by {} bits", cursor - bits.size());
-        fillBitmapTo(bits, cursor, bits.size(), {true, false});
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits,
-            calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
-                _config.rotational_period_ms() * 1e6));
-        return fluxmap;
-    }
-
-private:
-    uint8_t volume_id = 254;
-
-    /* This is extremely inspired by the MESS implementation, written by Nathan
-     * Woods and R. Belmont:
-     * https://github.com/mamedev/mame/blob/7914a6083a3b3a8c243ae6c3b8cb50b023f21e0e/src/lib/formats/ap2_dsk.cpp
-     * as well as Understanding the Apple II (1983) Chapter 9
-     * https://archive.org/details/Understanding_the_Apple_II_1983_Quality_Software/page/n230/mode/1up?view=theater
-     */
-
-    void writeSector(
-        std::vector<bool>& bits, unsigned& cursor, const Sector& sector) const
-    {
-        if ((sector.status == Sector::OK) or
-            (sector.status == Sector::BAD_CHECKSUM))
-        {
-            auto write_bit = [&](bool val)
-            {
-                if (cursor <= bits.size())
-                {
-                    bits[cursor] = val;
-                }
-                cursor++;
-            };
-
-            auto write_bits = [&](uint32_t bits, int width)
-            {
-                for (int i = width; i--;)
-                {
-                    write_bit(bits & (1u << i));
-                }
-            };
-
-            auto write_gcr44 = [&](uint8_t value)
-            {
-                write_bits((value << 7) | value | 0xaaaa, 16);
-            };
-
-            auto write_gcr6 = [&](uint8_t value)
-            {
-                write_bits(encode_data_gcr(value), 8);
-            };
-
-            // The special "FF40" sequence is used to synchronize the receiving
-            // shift register. It's written as "1111 1111 00"; FF indicates the
-            // 8 consecutive 1-bits, while "40" indicates the total number of
-            // microseconds.
-            auto write_ff40 = [&](int n = 1)
-            {
-                for (; n--;)
-                {
-                    write_bits(0xff << 2, 10);
-                }
-            };
-
-            // There is data to encode to disk.
-            if ((sector.data.size() != APPLE2_SECTOR_LENGTH))
-                error("unsupported sector size {} --- you must pick 256",
-                    sector.data.size());
-
-            // Write address syncing leader : A sequence of "FF40"s; 5 of them
-            // are said to suffice to synchronize the decoder.
-            // "FF40" indicates that the actual data written is "1111
-            // 1111 00" i.e., 8 1s and a total of 40 microseconds
-            //
-            // In standard formatting, the first logical sector apparently gets
-            // extra padding.
-            write_ff40(sector.logicalSector == 0 ? 32 : 8);
-
-            int track = sector.logicalTrack;
-            if (sector.logicalSide == 1)
-                track += _config.side_one_track_offset();
-
-            // Write address field: APPLE2_SECTOR_RECORD + sector identifier +
-            // DE AA EB
-            write_bits(APPLE2_SECTOR_RECORD, 24);
-            write_gcr44(volume_id);
-            write_gcr44(track);
-            write_gcr44(sector.logicalSector);
-            write_gcr44(volume_id ^ track ^ sector.logicalSector);
-            write_bits(0xDEAAEB, 24);
-
-            // Write data syncing leader: FF40 + APPLE2_DATA_RECORD + sector
-            // data + sum + DE AA EB (+ mystery bits cut off of the scan?)
-            write_ff40(8);
-            write_bits(APPLE2_DATA_RECORD, 24);
-
-            // Convert the sector data to GCR, append the checksum, and write it
-            // out
-            constexpr auto TWOBIT_COUNT =
-                0x56; // Size of the 'twobit' area at the start of the GCR data
-            uint8_t checksum = 0;
-            for (int i = 0; i < APPLE2_ENCODED_SECTOR_LENGTH; i++)
-            {
-                int value;
-                if (i >= TWOBIT_COUNT)
-                {
-                    value = sector.data[i - TWOBIT_COUNT] >> 2;
-                }
-                else
-                {
-                    uint8_t tmp = sector.data[i];
-                    value = ((tmp & 1) << 1) | ((tmp & 2) >> 1);
-
-                    tmp = sector.data[i + TWOBIT_COUNT];
-                    value |= ((tmp & 1) << 3) | ((tmp & 2) << 1);
-
-                    if (i + 2 * TWOBIT_COUNT < APPLE2_SECTOR_LENGTH)
-                    {
-                        tmp = sector.data[i + 2 * TWOBIT_COUNT];
-                        value |= ((tmp & 1) << 5) | ((tmp & 2) << 3);
-                    }
-                }
-                checksum ^= value;
-                // assert(checksum & ~0x3f == 0);
-                write_gcr6(checksum);
-                checksum = value;
-            }
-            if (sector.status == Sector::BAD_CHECKSUM)
-                checksum ^= 0x3f;
-            write_gcr6(checksum);
-            write_bits(0xDEAAEB, 24);
-        }
-    }
-};
-
-std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new Apple2Encoder(config));
-}
--- a/arch/arch.cc
+++ b/arch/arch.cc
@@ -1,99 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/encoders/encoders.h"
-#include "lib/decoders/decoders.h"
-#include "lib/config/config.h"
-#include "arch/agat/agat.h"
-#include "arch/aeslanier/aeslanier.h"
-#include "arch/aeslanier5/aeslanier5.h"
-#include "arch/amiga/amiga.h"
-#include "arch/apple2/apple2.h"
-#include "arch/brother/brother.h"
-#include "arch/c64/c64.h"
-#include "arch/f85/f85.h"
-#include "arch/fb100/fb100.h"
-#include "arch/ibm/ibm.h"
-#include "arch/macintosh/macintosh.h"
-#include "arch/micropolis/micropolis.h"
-#include "arch/mx/mx.h"
-#include "arch/northstar/northstar.h"
-#include "arch/rolandd20/rolandd20.h"
-#include "arch/smaky6/smaky6.h"
-#include "arch/tartu/tartu.h"
-#include "arch/tids990/tids990.h"
-#include "arch/victor9k/victor9k.h"
-#include "arch/zilogmcz/zilogmcz.h"
-#include "arch/arch.h"
-
-std::unique_ptr<Encoder> Arch::createEncoder(Config& config)
-{
-    if (!config.hasEncoder())
-        error("no encoder configured");
-    return createEncoder(config->encoder());
-}
-
-std::unique_ptr<Encoder> Arch::createEncoder(const EncoderProto& config)
-{
-    static const std::map<int,
-        std::function<std::unique_ptr<Encoder>(const EncoderProto&)>>
-        encoders = {
-            {EncoderProto::kAgat,       createAgatEncoder       },
-            {EncoderProto::kAmiga,      createAmigaEncoder      },
-            {EncoderProto::kApple2,     createApple2Encoder     },
-            {EncoderProto::kBrother,    createBrotherEncoder    },
-            {EncoderProto::kC64,        createCommodore64Encoder},
-            {EncoderProto::kIbm,        createIbmEncoder        },
-            {EncoderProto::kMacintosh,  createMacintoshEncoder  },
-            {EncoderProto::kMicropolis, createMicropolisEncoder },
-            {EncoderProto::kNorthstar,  createNorthstarEncoder  },
-            {EncoderProto::kTartu,      createTartuEncoder      },
-            {EncoderProto::kTids990,    createTids990Encoder    },
-            {EncoderProto::kVictor9K,   createVictor9kEncoder   },
-    };
-
-    auto encoder = encoders.find(config.format_case());
-    if (encoder == encoders.end())
-        error("no encoder specified");
-
-    return (encoder->second)(config);
-}
-
-std::unique_ptr<Decoder> Arch::createDecoder(Config& config)
-{
-    if (!config.hasDecoder())
-        error("no decoder configured");
-    return createDecoder(config->decoder());
-}
-
-std::unique_ptr<Decoder> Arch::createDecoder(const DecoderProto& config)
-{
-    static const std::map<int,
-        std::function<std::unique_ptr<Decoder>(const DecoderProto&)>>
-        decoders = {
-            {DecoderProto::kAgat,       createAgatDecoder       },
-            {DecoderProto::kAeslanier,  createAesLanierDecoder  },
-            {DecoderProto::kAeslanier5, createAesLanier5Decoder  },
-            {DecoderProto::kAmiga,      createAmigaDecoder      },
-            {DecoderProto::kApple2,     createApple2Decoder     },
-            {DecoderProto::kBrother,    createBrotherDecoder    },
-            {DecoderProto::kC64,        createCommodore64Decoder},
-            {DecoderProto::kF85,        createDurangoF85Decoder },
-            {DecoderProto::kFb100,      createFb100Decoder      },
-            {DecoderProto::kIbm,        createIbmDecoder        },
-            {DecoderProto::kMacintosh,  createMacintoshDecoder  },
-            {DecoderProto::kMicropolis, createMicropolisDecoder },
-            {DecoderProto::kMx,         createMxDecoder         },
-            {DecoderProto::kNorthstar,  createNorthstarDecoder  },
-            {DecoderProto::kRolandd20,  createRolandD20Decoder  },
-            {DecoderProto::kSmaky6,     createSmaky6Decoder     },
-            {DecoderProto::kTartu,      createTartuDecoder      },
-            {DecoderProto::kTids990,    createTids990Decoder    },
-            {DecoderProto::kVictor9K,   createVictor9kDecoder   },
-            {DecoderProto::kZilogmcz,   createZilogMczDecoder   },
-    };
-
-    auto decoder = decoders.find(config.format_case());
-    if (decoder == decoders.end())
-        error("no decoder specified");
-
-    return (decoder->second)(config);
-}
--- a/arch/arch.h
+++ b/arch/arch.h
@@ -1,16 +0,0 @@
-#pragma once
-
-class Encoder;
-class Decoder;
-class DecoderProto;
-class EncoderProto;
-class Config;
-
-namespace Arch
-{
-    std::unique_ptr<Decoder> createDecoder(Config& config);
-    std::unique_ptr<Decoder> createDecoder(const DecoderProto& config);
-
-    std::unique_ptr<Encoder> createEncoder(Config& config);
-    std::unique_ptr<Encoder> createEncoder(const EncoderProto& config);
-}
--- a/arch/brother/brother.h
+++ b/arch/brother/brother.h
@@ -3,19 +3,47 @@

 /* Brother word processor format (or at least, one of them) */

-#define BROTHER_SECTOR_RECORD 0xFFFFFD57
-#define BROTHER_DATA_RECORD 0xFFFFFDDB
-#define BROTHER_DATA_RECORD_PAYLOAD 256
-#define BROTHER_DATA_RECORD_CHECKSUM 3
+#define BROTHER_SECTOR_RECORD            0xFFFFFD57
+#define BROTHER_DATA_RECORD              0xFFFFFDDB
+#define BROTHER_DATA_RECORD_PAYLOAD      256
+#define BROTHER_DATA_RECORD_CHECKSUM     3
 #define BROTHER_DATA_RECORD_ENCODED_SIZE 415

-#define BROTHER_TRACKS_PER_240KB_DISK 78
-#define BROTHER_TRACKS_PER_120KB_DISK 39
-#define BROTHER_SECTORS_PER_TRACK 12
+#define BROTHER_TRACKS_PER_240KB_DISK    78
+#define BROTHER_TRACKS_PER_120KB_DISK    39
+#define BROTHER_SECTORS_PER_TRACK        12

-extern std::unique_ptr<Decoder> createBrotherDecoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createBrotherEncoder(
-    const EncoderProto& config);
+class Sector;
+class SectorSet;
+class Fluxmap;
+class BrotherDecoderProto;
+class BrotherEncoderProto;
+
+class BrotherDecoder : public AbstractDecoder
+{
+public:
+    BrotherDecoder(const BrotherDecoderProto& config) {}
+    virtual ~BrotherDecoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+};
+
+class BrotherEncoder : public AbstractEncoder
+{
+public:
+	BrotherEncoder(const BrotherEncoderProto& config):
+		_config(config)
+	{}
+
+	virtual ~BrotherEncoder() {}
+
+private:
+	const BrotherEncoderProto& _config;
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+};

 #endif
--- a/arch/brother/brother.proto
+++ b/arch/brother/brother.proto
@@ -12,7 +12,9 @@ message BrotherEncoderProto {
 	optional double post_index_gap_ms = 2 [default = 1.0];
 	optional double sector_spacing_ms = 3 [default = 16.2];
 	optional double post_header_spacing_ms = 4 [default = 0.69];
+	optional string sector_skew = 5 [default = "05a3816b4927"];

 	optional BrotherFormat format = 6 [default = BROTHER240];
+	optional int32 bias = 7 [default = 0];
 }

--- a/arch/brother/brotherdecode.h
+++ b/arch/brother/brotherdecode.h
@@ -0,0 +1,28 @@
+#ifndef BROTHER_H
+#define BROTHER_H
+
+/* Brother word processor format (or at least, one of them) */
+
+#define BROTHER_SECTOR_RECORD 0xFFFFFD57
+#define BROTHER_DATA_RECORD   0xFFFFFDDB
+#define BROTHER_DATA_RECORD_PAYLOAD  256
+#define BROTHER_DATA_RECORD_CHECKSUM 3
+
+class Sector;
+class Fluxmap;
+
+class BrotherDecoder : public AbstractDecoder
+{
+public:
+    virtual ~BrotherDecoder() {}
+
+    SectorVector decodeToSectors(const RawRecordVector& rawRecords);
+    int recordMatcher(uint64_t fifo) const;
+};
+
+extern void writeBrotherSectorHeader(std::vector<bool>& bits, unsigned& cursor,
+		int track, int sector);
+extern void writeBrotherSectorData(std::vector<bool>& bits, unsigned& cursor,
+		const std::vector<uint8_t>& data);
+
+#endif
--- a/arch/brother/data_gcr.h
+++ b/arch/brother/data_gcr.h
@@ -1,13 +1,13 @@
-GCR_ENTRY(0x55, 0)  // 00000
-GCR_ENTRY(0x57, 1)  // 00001
-GCR_ENTRY(0x5b, 2)  // 00010
-GCR_ENTRY(0x5d, 3)  // 00011
-GCR_ENTRY(0x5f, 4)  // 00100
-GCR_ENTRY(0x6b, 5)  // 00101
-GCR_ENTRY(0x6d, 6)  // 00110
-GCR_ENTRY(0x6f, 7)  // 00111
-GCR_ENTRY(0x75, 8)  // 01000
-GCR_ENTRY(0x77, 9)  // 01001
+GCR_ENTRY(0x55, 0) // 00000
+GCR_ENTRY(0x57, 1) // 00001
+GCR_ENTRY(0x5b, 2) // 00010
+GCR_ENTRY(0x5d, 3) // 00011
+GCR_ENTRY(0x5f, 4) // 00100 
+GCR_ENTRY(0x6b, 5) // 00101
+GCR_ENTRY(0x6d, 6) // 00110
+GCR_ENTRY(0x6f, 7) // 00111
+GCR_ENTRY(0x75, 8) // 01000
+GCR_ENTRY(0x77, 9) // 01001
 GCR_ENTRY(0x7b, 10) // 01010
 GCR_ENTRY(0x7d, 11) // 01011
 GCR_ENTRY(0x7f, 12) // 01100
@@ -30,3 +30,4 @@ GCR_ENTRY(0xef, 28) // 11100
 GCR_ENTRY(0xf5, 29) // 11101
 GCR_ENTRY(0xf7, 30) // 11110
 GCR_ENTRY(0xfb, 31) // 11111
+
--- a/arch/brother/decoder.cc
+++ b/arch/brother/decoder.cc
@@ -1,19 +1,19 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "sql.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "record.h"
 #include "brother.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
-#include "lib/core/crc.h"
+#include "sector.h"
+#include "bytes.h"
+#include "crc.h"
 #include <ctype.h>

 const FluxPattern SECTOR_RECORD_PATTERN(32, BROTHER_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(32, BROTHER_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

 static std::vector<uint8_t> outputbuffer;

@@ -34,89 +34,76 @@ static int decode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

 static int decode_header_gcr(uint16_t word)
 {
-    switch (word)
-    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "header_gcr.h"
-#undef GCR_ENTRY
-    }
-    return -1;
-}
-
-class BrotherDecoder : public Decoder
-{
-public:
-    BrotherDecoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw32() != BROTHER_SECTOR_RECORD)
-            return;
-
-        const auto& rawbits = readRawBits(32);
-        const auto& bytes = toBytes(rawbits).slice(0, 4);
-
-        ByteReader br(bytes);
-        _sector->logicalTrack = decode_header_gcr(br.read_be16());
-        _sector->logicalSector = decode_header_gcr(br.read_be16());
-
-        /* Sanity check the values read; there's no header checksum and
-         * occasionally we get garbage due to bit errors. */
-        if (_sector->logicalSector > 11)
-            return;
-        if (_sector->logicalTrack > 79)
-            return;
-
-        _sector->status = Sector::DATA_MISSING;
-    }
-
-    void decodeDataRecord() override
-    {
-        if (readRaw32() != BROTHER_DATA_RECORD)
-            return;
-
-        const auto& rawbits = readRawBits(BROTHER_DATA_RECORD_ENCODED_SIZE * 8);
-        const auto& rawbytes =
-            toBytes(rawbits).slice(0, BROTHER_DATA_RECORD_ENCODED_SIZE);
-
-        Bytes bytes;
-        ByteWriter bw(bytes);
-        BitWriter bitw(bw);
-        for (uint8_t b : rawbytes)
-        {
-            uint32_t nibble = decode_data_gcr(b);
-            bitw.push(nibble, 5);
-        }
-        bitw.flush();
-
-        _sector->data = bytes.slice(0, BROTHER_DATA_RECORD_PAYLOAD);
-        uint32_t realCrc = crcbrother(_sector->data);
-        uint32_t wantCrc =
-            bytes.reader().seek(BROTHER_DATA_RECORD_PAYLOAD).read_be24();
-        _sector->status =
-            (realCrc == wantCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
+	switch (word)
+	{
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "header_gcr.h"
+		#undef GCR_ENTRY
+	}                       
+	return -1;             
 };

-std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config)
+AbstractDecoder::RecordType BrotherDecoder::advanceToNextRecord()
 {
-    return std::unique_ptr<Decoder>(new BrotherDecoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return RecordType::SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return RecordType::DATA_RECORD;
+	return RecordType::UNKNOWN_RECORD;
+}
+
+void BrotherDecoder::decodeSectorRecord()
+{
+	readRawBits(32);
+	const auto& rawbits = readRawBits(32);
+	const auto& bytes = toBytes(rawbits).slice(0, 4);
+
+	ByteReader br(bytes);
+	_sector->logicalTrack = decode_header_gcr(br.read_be16());
+	_sector->logicalSector = decode_header_gcr(br.read_be16());
+
+	/* Sanity check the values read; there's no header checksum and
+		* occasionally we get garbage due to bit errors. */
+	if (_sector->logicalSector > 11)
+		return;
+	if (_sector->logicalTrack > 79)
+		return;
+
+	_sector->status = Sector::DATA_MISSING;
+}
+
+void BrotherDecoder::decodeDataRecord()
+{
+	readRawBits(32);
+
+	const auto& rawbits = readRawBits(BROTHER_DATA_RECORD_ENCODED_SIZE*8);
+	const auto& rawbytes = toBytes(rawbits).slice(0, BROTHER_DATA_RECORD_ENCODED_SIZE);
+
+	Bytes bytes;
+	ByteWriter bw(bytes);
+	BitWriter bitw(bw);
+	for (uint8_t b : rawbytes)
+	{
+		uint32_t nibble = decode_data_gcr(b);
+		bitw.push(nibble, 5);
+	}
+	bitw.flush();
+
+	_sector->data = bytes.slice(0, BROTHER_DATA_RECORD_PAYLOAD);
+	uint32_t realCrc = crcbrother(_sector->data);
+	uint32_t wantCrc = bytes.reader().seek(BROTHER_DATA_RECORD_PAYLOAD).read_be24();
+	_sector->status = (realCrc == wantCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/brother/encoder.cc
+++ b/arch/brother/encoder.cc
@@ -1,154 +1,184 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 #include "brother.h"
-#include "lib/core/crc.h"
-#include "lib/data/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
 #include "arch/brother/brother.pb.h"
-#include "lib/encoders/encoders.pb.h"
+
+FlagGroup brotherEncoderFlags;
+
+static DoubleFlag clockRateUs(
+	{ "--clock-rate" },
+	"Encoded data clock rate (microseconds).",
+	3.83);
+
+static DoubleFlag postIndexGapMs(
+	{ "--post-index-gap" },
+	"Post-index gap before first sector header (milliseconds).",
+	1.0);
+
+static DoubleFlag sectorSpacingMs(
+	{ "--sector-spacing" },
+	"Time between successive sector headers (milliseconds).",
+	16.2);
+
+static DoubleFlag postHeaderSpacingMs(
+	{ "--post-header-spacing" },
+	"Time between a sector's header and data records (milliseconds).",
+	0.69);
+
+static StringFlag sectorSkew(
+	{ "--sector-skew" },
+	"Order in which to write sectors.",
+	"05a3816b4927");

 static int encode_header_gcr(uint16_t word)
 {
-    switch (word)
-    {
-#define GCR_ENTRY(gcr, data) \
-    case data:               \
-        return gcr;
-#include "header_gcr.h"
-#undef GCR_ENTRY
-    }
-    return -1;
-}
+	switch (word)
+	{
+		#define GCR_ENTRY(gcr, data) \
+			case data: return gcr;
+		#include "header_gcr.h"
+		#undef GCR_ENTRY
+	}                       
+	return -1;             
+};

 static int encode_data_gcr(uint8_t data)
 {
-    switch (data)
-    {
-#define GCR_ENTRY(gcr, data) \
-    case data:               \
-        return gcr;
-#include "data_gcr.h"
-#undef GCR_ENTRY
-    }
-    return -1;
+	switch (data)
+	{
+		#define GCR_ENTRY(gcr, data) \
+			case data: return gcr;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
+	}                       
+	return -1;             
+};
+
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint32_t data, int width)
+{
+	cursor += width;
+	for (int i=0; i<width; i++)
+	{
+		unsigned pos = cursor - i - 1;
+		if (pos < bits.size())
+			bits[pos] = data & 1;
+		data >>= 1;
+	}
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, uint32_t data, int width)
+static void write_sector_header(std::vector<bool>& bits, unsigned& cursor,
+		int track, int sector)
 {
-    cursor += width;
-    for (int i = 0; i < width; i++)
-    {
-        unsigned pos = cursor - i - 1;
-        if (pos < bits.size())
-            bits[pos] = data & 1;
-        data >>= 1;
-    }
+	write_bits(bits, cursor, 0xffffffff, 31);
+	write_bits(bits, cursor, BROTHER_SECTOR_RECORD, 32);
+	write_bits(bits, cursor, encode_header_gcr(track), 16);
+	write_bits(bits, cursor, encode_header_gcr(sector), 16);
+	write_bits(bits, cursor, encode_header_gcr(0x2f), 16);
 }

-static void write_sector_header(
-    std::vector<bool>& bits, unsigned& cursor, int track, int sector)
+static void write_sector_data(std::vector<bool>& bits, unsigned& cursor, const Bytes& data)
 {
-    write_bits(bits, cursor, 0xffffffff, 31);
-    write_bits(bits, cursor, BROTHER_SECTOR_RECORD, 32);
-    write_bits(bits, cursor, encode_header_gcr(track), 16);
-    write_bits(bits, cursor, encode_header_gcr(sector), 16);
-    write_bits(bits, cursor, encode_header_gcr(0x2f), 16);
-}
+	write_bits(bits, cursor, 0xffffffff, 32);
+	write_bits(bits, cursor, BROTHER_DATA_RECORD, 32);

-static void write_sector_data(
-    std::vector<bool>& bits, unsigned& cursor, const Bytes& data)
-{
-    write_bits(bits, cursor, 0xffffffff, 32);
-    write_bits(bits, cursor, BROTHER_DATA_RECORD, 32);
+	uint16_t fifo = 0;
+	int width = 0;

-    uint16_t fifo = 0;
-    int width = 0;
+	if (data.size() != BROTHER_DATA_RECORD_PAYLOAD)
+		Error() << "unsupported sector size";

-    if (data.size() != BROTHER_DATA_RECORD_PAYLOAD)
-        error("unsupported sector size");
+	auto write_byte = [&](uint8_t byte)
+	{
+		fifo |= (byte << (8 - width));
+		width += 8;

-    auto write_byte = [&](uint8_t byte)
-    {
-        fifo |= (byte << (8 - width));
-        width += 8;
+		while (width >= 5)
+		{
+			uint8_t quintet = fifo >> 11;
+			fifo <<= 5;
+			width -= 5;

-        while (width >= 5)
-        {
-            uint8_t quintet = fifo >> 11;
-            fifo <<= 5;
-            width -= 5;
+			write_bits(bits, cursor, encode_data_gcr(quintet), 8);
+		}
+	};

-            write_bits(bits, cursor, encode_data_gcr(quintet), 8);
-        }
-    };
+	for (uint8_t byte : data)
+		write_byte(byte);

-    for (uint8_t byte : data)
-        write_byte(byte);
-
-    uint32_t realCrc = crcbrother(data);
-    write_byte(realCrc >> 16);
-    write_byte(realCrc >> 8);
-    write_byte(realCrc);
-    write_byte(0x58); /* magic */
+	uint32_t realCrc = crcbrother(data);
+	write_byte(realCrc>>16);
+	write_byte(realCrc>>8);
+	write_byte(realCrc);
+	write_byte(0x58); /* magic */
    write_byte(0xd4);
    while (width != 0)
        write_byte(0);
 }

-class BrotherEncoder : public Encoder
+static int charToInt(char c)
 {
-public:
-    BrotherEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.brother())
-    {
-    }
-
-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        int bitsPerRevolution = 200000.0 / _config.clock_rate_us();
-        std::vector<bool> bits(bitsPerRevolution);
-        unsigned cursor = 0;
-
-        int sectorCount = 0;
-        for (const auto& sectorData : sectors)
-        {
-            double headerMs = _config.post_index_gap_ms() +
-                              sectorCount * _config.sector_spacing_ms();
-            unsigned headerCursor = headerMs * 1e3 / _config.clock_rate_us();
-            double dataMs = headerMs + _config.post_header_spacing_ms();
-            unsigned dataCursor = dataMs * 1e3 / _config.clock_rate_us();
-
-            fillBitmapTo(bits, cursor, headerCursor, {true, false});
-            write_sector_header(bits,
-                cursor,
-                sectorData->logicalTrack,
-                sectorData->logicalSector);
-            fillBitmapTo(bits, cursor, dataCursor, {true, false});
-            write_sector_data(bits, cursor, sectorData->data);
-
-            sectorCount++;
-        }
-
-        if (cursor >= bits.size())
-            error("track data overrun");
-        fillBitmapTo(bits, cursor, bits.size(), {true, false});
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits, _config.clock_rate_us() * 1e3);
-        return fluxmap;
-    }
-
-private:
-    const BrotherEncoderProto& _config;
-};
-
-std::unique_ptr<Encoder> createBrotherEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new BrotherEncoder(config));
+	if (isdigit(c))
+		return c - '0';
+	return 10 + tolower(c) - 'a';
+}
+
+std::unique_ptr<Fluxmap> BrotherEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+	int logicalTrack;
+	if (physicalSide != 0)
+		return std::unique_ptr<Fluxmap>();
+	physicalTrack -= _config.bias();
+	switch (_config.format())
+	{
+		case BROTHER120:
+			if ((physicalTrack < 0) || (physicalTrack >= (BROTHER_TRACKS_PER_120KB_DISK*2))
+					|| (physicalTrack & 1))
+				return std::unique_ptr<Fluxmap>();
+			logicalTrack = physicalTrack/2;
+			break;
+
+		case BROTHER240:
+			if ((physicalTrack < 0) || (physicalTrack >= BROTHER_TRACKS_PER_240KB_DISK))
+				return std::unique_ptr<Fluxmap>();
+			logicalTrack = physicalTrack;
+			break;
+	}
+
+	int bitsPerRevolution = 200000.0 / clockRateUs;
+	const std::string& skew = sectorSkew.get();
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;
+
+	for (int sectorCount=0; sectorCount<BROTHER_SECTORS_PER_TRACK; sectorCount++)
+	{
+		int sectorId = charToInt(skew.at(sectorCount));
+		double headerMs = postIndexGapMs + sectorCount*sectorSpacingMs;
+		unsigned headerCursor = headerMs*1e3 / clockRateUs;
+		double dataMs = headerMs + postHeaderSpacingMs;
+		unsigned dataCursor = dataMs*1e3 / clockRateUs;
+
+		const auto& sectorData = allSectors.get(logicalTrack, 0, sectorId);
+
+		fillBitmapTo(bits, cursor, headerCursor, { true, false });
+		write_sector_header(bits, cursor, logicalTrack, sectorId);
+		fillBitmapTo(bits, cursor, dataCursor, { true, false });
+		write_sector_data(bits, cursor, sectorData->data);
+	}
+
+	if (cursor >= bits.size())
+		Error() << "track data overrun";
+	fillBitmapTo(bits, cursor, bits.size(), { true, false });
+
+	// The pre-index gap is not normally reported.
+	// std::cerr << "pre-index gap " << 200.0 - (double)cursor*clockRateUs/1e3 << std::endl;
+	
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(bits, clockRateUs*1e3);
+	return fluxmap;
 }
--- a/arch/brother/header_gcr.h
+++ b/arch/brother/header_gcr.h
@@ -76,3 +76,4 @@ GCR_ENTRY(0x6BAB, 74)
 GCR_ENTRY(0xAD5F, 75)
 GCR_ENTRY(0xDBED, 76)
 GCR_ENTRY(0x55BB, 77)
+
--- a/arch/build.py
+++ b/arch/build.py
@@ -1,107 +0,0 @@
-from build.c import cxxlibrary
-from build.protobuf import proto, protocc
-
-proto(
-    name="proto",
-    srcs=[
-        "./aeslanier/aeslanier.proto",
-        "./aeslanier5/aeslanier5.proto",
-        "./agat/agat.proto",
-        "./amiga/amiga.proto",
-        "./apple2/apple2.proto",
-        "./brother/brother.proto",
-        "./c64/c64.proto",
-        "./f85/f85.proto",
-        "./fb100/fb100.proto",
-        "./ibm/ibm.proto",
-        "./macintosh/macintosh.proto",
-        "./micropolis/micropolis.proto",
-        "./mx/mx.proto",
-        "./northstar/northstar.proto",
-        "./rolandd20/rolandd20.proto",
-        "./smaky6/smaky6.proto",
-        "./tartu/tartu.proto",
-        "./tids990/tids990.proto",
-        "./victor9k/victor9k.proto",
-        "./zilogmcz/zilogmcz.proto",
-    ],
-    deps=["lib/config+common_proto"],
-)
-
-protocc(
-    name="proto_lib", srcs=[".+proto"], deps=["lib/config+common_proto_lib"]
-)
-
-cxxlibrary(
-    name="arch",
-    srcs=[
-        "./arch.cc",
-        "./aeslanier/decoder.cc",
-        "./aeslanier5/decoder.cc",
-        "./agat/agat.cc",
-        "./agat/decoder.cc",
-        "./agat/encoder.cc",
-        "./amiga/amiga.cc",
-        "./amiga/decoder.cc",
-        "./amiga/encoder.cc",
-        "./apple2/decoder.cc",
-        "./apple2/encoder.cc",
-        "./brother/decoder.cc",
-        "./brother/encoder.cc",
-        "./c64/c64.cc",
-        "./c64/decoder.cc",
-        "./c64/encoder.cc",
-        "./f85/decoder.cc",
-        "./fb100/decoder.cc",
-        "./ibm/decoder.cc",
-        "./ibm/encoder.cc",
-        "./macintosh/decoder.cc",
-        "./macintosh/encoder.cc",
-        "./micropolis/decoder.cc",
-        "./micropolis/encoder.cc",
-        "./mx/decoder.cc",
-        "./northstar/decoder.cc",
-        "./northstar/encoder.cc",
-        "./rolandd20/decoder.cc",
-        "./smaky6/decoder.cc",
-        "./tartu/decoder.cc",
-        "./tartu/encoder.cc",
-        "./tids990/decoder.cc",
-        "./tids990/encoder.cc",
-        "./victor9k/decoder.cc",
-        "./victor9k/encoder.cc",
-        "./zilogmcz/decoder.cc",
-    ],
-    hdrs={
-        "arch/ibm/ibm.h": "./ibm/ibm.h",
-        "arch/apple2/data_gcr.h": "./apple2/data_gcr.h",
-        "arch/apple2/apple2.h": "./apple2/apple2.h",
-        "arch/amiga/amiga.h": "./amiga/amiga.h",
-        "arch/smaky6/smaky6.h": "./smaky6/smaky6.h",
-        "arch/tids990/tids990.h": "./tids990/tids990.h",
-        "arch/zilogmcz/zilogmcz.h": "./zilogmcz/zilogmcz.h",
-        "arch/amiga/amiga.h": "./amiga/amiga.h",
-        "arch/f85/data_gcr.h": "./f85/data_gcr.h",
-        "arch/f85/f85.h": "./f85/f85.h",
-        "arch/mx/mx.h": "./mx/mx.h",
-        "arch/aeslanier/aeslanier.h": "./aeslanier/aeslanier.h",
-        "arch/aeslanier5/aeslanier5.h": "./aeslanier5/aeslanier5.h",
-        "arch/northstar/northstar.h": "./northstar/northstar.h",
-        "arch/brother/data_gcr.h": "./brother/data_gcr.h",
-        "arch/brother/brother.h": "./brother/brother.h",
-        "arch/brother/header_gcr.h": "./brother/header_gcr.h",
-        "arch/macintosh/data_gcr.h": "./macintosh/data_gcr.h",
-        "arch/macintosh/macintosh.h": "./macintosh/macintosh.h",
-        "arch/agat/agat.h": "./agat/agat.h",
-        "arch/fb100/fb100.h": "./fb100/fb100.h",
-        "arch/victor9k/data_gcr.h": "./victor9k/data_gcr.h",
-        "arch/victor9k/victor9k.h": "./victor9k/victor9k.h",
-        "arch/rolandd20/rolandd20.h": "./rolandd20/rolandd20.h",
-        "arch/micropolis/micropolis.h": "./micropolis/micropolis.h",
-        "arch/c64/data_gcr.h": "./c64/data_gcr.h",
-        "arch/c64/c64.h": "./c64/c64.h",
-        "arch/tartu/tartu.h": "./tartu/tartu.h",
-        "arch/arch.h": "./arch.h",
-    },
-    deps=["lib/core", "lib/data", "lib/config", "lib/encoders", "lib/decoders"],
-)
--- a/arch/c64/c64.cc
+++ b/arch/c64/c64.cc
@@ -1,28 +0,0 @@
-#include "lib/core/globals.h"
-#include "c64.h"
-
-/*
- *   Track   Sectors/track   # Sectors   Storage in Bytes   Clock rate
- *   -----   -------------   ---------   ----------------   ----------
- *    1-17        21            357           7820             3.25
- *   18-24        19            133           7170             3.5
- *   25-30        18            108           6300             3.75
- *   31-40(*)     17             85           6020             4
- *                              ---
- *                              683 (for a 35 track image)
- *
- * The clock rate is normalised for a 200ms drive.
- */
-
-nanoseconds_t clockPeriodForC64Track(unsigned track)
-{
-    constexpr double b = 8.0;
-
-    if (track < 17)
-        return 26.0 / b;
-    if (track < 24)
-        return 28.0 / b;
-    if (track < 30)
-        return 30.0 / b;
-    return 32.0 / b;
-}
--- a/arch/c64/c64.h
+++ b/arch/c64/c64.h
@@ -1,14 +1,14 @@
 #ifndef C64_H
 #define C64_H

-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"

-#define C64_SECTOR_RECORD 0xffd49
-#define C64_DATA_RECORD 0xffd57
-#define C64_SECTOR_LENGTH 256
+#define C64_SECTOR_RECORD    0xffd49
+#define C64_DATA_RECORD      0xffd57
+#define C64_SECTOR_LENGTH    256

-/* Source: http://www.unusedino.de/ec64/technical/formats/g64.html
+/* Source: http://www.unusedino.de/ec64/technical/formats/g64.html 
   1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
   2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
   3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
@@ -17,21 +17,52 @@
   6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
   1. Header sync       (SYNC for the next sector)
 */
-#define C64_HEADER_DATA_SYNC 0xFF
-#define C64_HEADER_BLOCK_ID 0x08
-#define C64_DATA_BLOCK_ID 0x07
-#define C64_HEADER_GAP 0x55
-#define C64_INTER_SECTOR_GAP 0x55
-#define C64_PADDING 0x0F
+#define C64_HEADER_DATA_SYNC        0xFF
+#define C64_HEADER_BLOCK_ID         0x08
+#define C64_DATA_BLOCK_ID           0x07
+#define C64_HEADER_GAP              0x55
+#define C64_INTER_SECTOR_GAP        0x55
+#define C64_PADDING                 0x0F

-#define C64_TRACKS_PER_DISK 40
-#define C64_BAM_TRACK 17
+#define C64_TRACKS_PER_DISK         40
+#define C64_BAM_TRACK               17

-extern std::unique_ptr<Decoder> createCommodore64Decoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createCommodore64Encoder(
-    const EncoderProto& config);

-extern nanoseconds_t clockPeriodForC64Track(unsigned track);
+class Sector;
+class Fluxmap;
+class Commodore64DecoderProto;
+class Commodore64EncoderProto;
+
+class Commodore64Decoder : public AbstractDecoder
+{
+public:
+	Commodore64Decoder(const Commodore64DecoderProto&) {}
+    virtual ~Commodore64Decoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+};
+
+class Commodore64Encoder : public AbstractEncoder
+{
+public:
+	Commodore64Encoder(const Commodore64EncoderProto& config):
+		_config(config)
+	{}
+
+	virtual ~Commodore64Encoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	void writeSector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector) const;
+	
+private:
+	const Commodore64EncoderProto& _config;
+	uint8_t _formatByte1;
+	uint8_t _formatByte2;
+};

 #endif
--- a/arch/c64/c64.proto
+++ b/arch/c64/c64.proto
@@ -1,11 +1,13 @@
 syntax = "proto2";

-import "lib/config/common.proto";
+import "lib/common.proto";

 message Commodore64DecoderProto {}

 message Commodore64EncoderProto {
 	optional double post_index_gap_us = 1 [default=0.0,
 		(help) = "post-index gap before first sector header."];
+	optional double clock_compensation_factor = 2 [default=1.0,
+		(help) = "scale the output clock by this much."];
 }

--- a/arch/c64/decoder.cc
+++ b/arch/c64/decoder.cc
@@ -1,34 +1,32 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "c64.h"
-#include "lib/core/crc.h"
-#include "lib/core/bytes.h"
+#include "crc.h"
+#include "bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 const FluxPattern SECTOR_RECORD_PATTERN(20, C64_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(20, C64_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

 static int decode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

 static Bytes decode(const std::vector<bool>& bits)
 {
@@ -40,11 +38,11 @@ static Bytes decode(const std::vector<bool>& bits)
    while (ii != bits.end())
    {
        uint8_t inputfifo = 0;
-        for (size_t i = 0; i < 5; i++)
+        for (size_t i=0; i<5; i++)
        {
            if (ii == bits.end())
                break;
-            inputfifo = (inputfifo << 1) | *ii++;
+            inputfifo = (inputfifo<<1) | *ii++;
        }

        bitw.push(decode_data_gcr(inputfifo), 4);
@@ -54,50 +52,41 @@ static Bytes decode(const std::vector<bool>& bits)
    return output;
 }

-class Commodore64Decoder : public Decoder
+AbstractDecoder::RecordType Commodore64Decoder::advanceToNextRecord()
 {
-public:
-    Commodore64Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw20() != C64_SECTOR_RECORD)
-            return;
-
-        const auto& bits = readRawBits(5 * 10);
-        const auto& bytes = decode(bits).slice(0, 5);
-
-        uint8_t checksum = bytes[0];
-        _sector->logicalSector = bytes[1];
-        _sector->logicalSide = 0;
-        _sector->logicalTrack = bytes[2] - 1;
-        if (checksum == xorBytes(bytes.slice(1, 4)))
-            _sector->status =
-                Sector::DATA_MISSING; /* unintuitive but correct */
-    }
-
-    void decodeDataRecord() override
-    {
-        if (readRaw20() != C64_DATA_RECORD)
-            return;
-
-        const auto& bits = readRawBits(259 * 10);
-        const auto& bytes = decode(bits).slice(0, 259);
-
-        _sector->data = bytes.slice(0, C64_SECTOR_LENGTH);
-        uint8_t gotChecksum = xorBytes(_sector->data);
-        uint8_t wantChecksum = bytes[256];
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createCommodore64Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Commodore64Decoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return RecordType::SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return RecordType::DATA_RECORD;
+	return RecordType::UNKNOWN_RECORD;
+}
+
+void Commodore64Decoder::decodeSectorRecord()
+{
+    readRawBits(20);
+
+    const auto& bits = readRawBits(5*10);
+    const auto& bytes = decode(bits).slice(0, 5);
+
+    uint8_t checksum = bytes[0];
+    _sector->logicalSector = bytes[1];
+    _sector->logicalSide = 0;
+    _sector->logicalTrack = bytes[2] - 1;
+    if (checksum == xorBytes(bytes.slice(1, 4)))
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+}
+
+void Commodore64Decoder::decodeDataRecord()
+{
+    readRawBits(20);
+
+    const auto& bits = readRawBits(259*10);
+    const auto& bytes = decode(bits).slice(0, 259);
+
+    _sector->data = bytes.slice(0, C64_SECTOR_LENGTH);
+    uint8_t gotChecksum = xorBytes(_sector->data);
+    uint8_t wantChecksum = bytes[256];
+    _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/c64/encoder.cc
+++ b/arch/c64/encoder.cc
@@ -1,104 +1,161 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 #include "c64.h"
-#include "lib/core/crc.h"
-#include "lib/data/sector.h"
-#include "lib/data/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "sector.h"
+#include "writer.h"
 #include "fmt/format.h"
 #include "arch/c64/c64.pb.h"
-#include "lib/encoders/encoders.pb.h"
-#include "lib/data/layout.h"
 #include <ctype.h>
-#include "lib/core/bytes.h"
+#include "bytes.h"

 static bool lastBit;

+static double clockRateUsForTrack(unsigned track)
+{
+    /*
+     * Track   # Sectors/Track Speed Zone  bits/rotation       
+     * 1 – 17          21          3       61,538.4
+     * 18 – 24         19          2       57,142.8
+     * 25 – 30         18          1       53,333.4
+     * 31 – 35         17          0       50,000.0
+    */
+    if (track < 17)
+        return 200000.0/61538.4;
+    if (track < 24)
+        return 200000.0/57142.8;
+    if (track < 30)
+        return 200000.0/53333.4;
+    return 200000.0/50000.0;
+
+}
+
+static unsigned sectorsForTrack(unsigned track)
+{
+    /*
+     * Track   Sectors/track   # Sectors   Storage in Bytes
+     *   -----   -------------   ---------   ----------------
+     *    1-17        21            357           7820
+     *   18-24        19            133           7170
+     *   25-30        18            108           6300
+     *   31-40(*)     17             85           6020
+     *                              ---
+     *                              683 (for a 35 track image)
+     */
+    if (track < 17)
+        return 21;
+    if (track < 24)
+        return 19;
+    if (track < 30)
+        return 18;
+    return 17;
+}
+
 static int encode_data_gcr(uint8_t data)
 {
    switch (data)
    {
-#define GCR_ENTRY(gcr, data) \
-    case data:               \
-        return gcr;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+        #define GCR_ENTRY(gcr, data) \
+            case data: return gcr;
+        #include "data_gcr.h"
+        #undef GCR_ENTRY
    }
    return -1;
-}
+};

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
 {
-    for (bool bit : src) // Range-based for loop
+    for (bool bit : src)  //Range-based for loop
    {
        if (cursor < bits.size())
            bits[cursor++] = bit;
    }
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
 {
    cursor += width;
-    for (int i = 0; i < width; i++)
+    for (int i=0; i<width; i++)
    {
-        unsigned pos = cursor - i - 1;
+        unsigned pos = cursor - i - 1;              
        if (pos < bits.size())
            bits[pos] = data & 1;
        data >>= 1;
    }
 }

+void bindump(std::ostream& stream, std::vector<bool>& buffer)
+{
+    size_t pos = 0;
+
+    while ((pos < buffer.size()) and (pos <520))
+    {
+        stream << fmt::format("{:5d} : ", pos);
+        for (int i=0; i<40; i++)
+        {
+            if ((pos+i) < buffer.size())
+                stream << fmt::format("{:01b}", (buffer[pos+i]));
+            else
+                stream << "-- ";
+            if ((((pos + i + 1) % 8) == 0) and i != 0)
+                stream << "  ";
+
+        }
+        stream << std::endl;
+        pos += 40;
+    }
+}
 static std::vector<bool> encode_data(uint8_t input)
 {
    /*
-     * Four 8-bit data bytes are converted to four 10-bit GCR bytes at a time by
-     * the 1541 DOS.  RAM is only an 8-bit storage device though. This hardware
-     * limitation prevents a 10-bit GCR byte from being stored in a single
-     * memory location. Four 10-bit GCR bytes total 40 bits - a number evenly
-     * divisible by our overriding 8-bit constraint. Commodore sub- divides the
-     * 40 GCR bits into five 8-bit bytes to solve this dilemma. This explains
-     * why four 8-bit data bytes are converted to GCR form at a time. The
-     * following step by step example demonstrates how this bit manipulation is
-     * performed by the DOS.
-     *
-     * STEP 1. Four 8-bit Data Bytes
-     * $08 $10 $00 $12
-     *
-     * STEP 2. Hexadecimal to Binary Conversion
-     * 1. Binary Equivalents
-     * $08       $10         $00         $12
-     * 00001000  00010000    00000000    00010010
-     *
-     * STEP 3. Binary to GCR Conversion
-     * 1. Four 8-bit Data Bytes
-     * 00001000 00010000 00000000 00010010
-     * 2. High and Low Nybbles
-     * 0000 1000 0001 0000 0000 0000 0001 0010
-     * 3. High and Low Nybble GCR Equivalents
-     * 01010 01001 01011 01010 01010 01010 01011 10010
-     * 4. Four 10-bit GCR Bytes
-     * 0101001001 0101101010 0101001010 0101110010
-     *
-     * STEP 4. 10-bit GCR to 8-bit GCR Conversion
-     *   1. Concatenate Four 10-bit GCR Bytes
-     *   0101001001010110101001010010100101110010
-     *   2. Five 8-bit Subdivisions
-     *   01010010 01010110 10100101 00101001 01110010
-     *
-     * STEP 5. Binary to Hexadecimal Conversion
-     * 1. Hexadecimal Equivalents
-     *   01010010    01010110    10100101    00101001    01110010
-     *   $52         $56         $A5         $29         $72
-     *
-     * STEP 6. Four 8-bit Data Bytes are Recorded as Five 8-bit GCR Bytes
-     *   $08 $10 $00 $12
-     *
-     * are recorded as
-     *   $52 $56 $A5 $29 $72
-     */
+    * Four 8-bit data bytes are converted to four 10-bit GCR bytes at a time by
+    * the 1541 DOS.  RAM is only an 8-bit storage device though. This hardware
+    * limitation prevents a 10-bit GCR byte from being stored in a single
+    * memory location. Four 10-bit GCR bytes total 40 bits - a number evenly
+    * divisible by our overriding 8-bit constraint. Commodore sub- divides the
+    * 40 GCR bits into five 8-bit bytes to solve this dilemma. This explains
+    * why four 8-bit data bytes are converted to GCR form at a time. The
+    * following step by step example demonstrates how this bit manipulation is
+    * performed by the DOS.
+    *
+    * STEP 1. Four 8-bit Data Bytes
+    * $08 $10 $00 $12
+    *
+    * STEP 2. Hexadecimal to Binary Conversion
+    * 1. Binary Equivalents
+    * $08       $10         $00         $12
+    * 00001000  00010000    00000000    00010010
+    *
+    * STEP 3. Binary to GCR Conversion
+    * 1. Four 8-bit Data Bytes
+    * 00001000 00010000 00000000 00010010
+    * 2. High and Low Nybbles
+    * 0000 1000 0001 0000 0000 0000 0001 0010
+    * 3. High and Low Nybble GCR Equivalents
+    * 01010 01001 01011 01010 01010 01010 01011 10010
+    * 4. Four 10-bit GCR Bytes
+    * 0101001001 0101101010 0101001010 0101110010
+    *
+    * STEP 4. 10-bit GCR to 8-bit GCR Conversion
+    *   1. Concatenate Four 10-bit GCR Bytes
+    *   0101001001010110101001010010100101110010
+    *   2. Five 8-bit Subdivisions
+    *   01010010 01010110 10100101 00101001 01110010
+    *
+    * STEP 5. Binary to Hexadecimal Conversion
+    * 1. Hexadecimal Equivalents
+    *   01010010    01010110    10100101    00101001    01110010
+    *   $52         $56         $A5         $29         $72
+    *
+    * STEP 6. Four 8-bit Data Bytes are Recorded as Five 8-bit GCR Bytes
+    *   $08 $10 $00 $12
+    *
+    * are recorded as
+    *   $52 $56 $A5 $29 $72
+    */

    std::vector<bool> output(10, false);
    uint8_t hi = 0;
@@ -106,213 +163,187 @@ static std::vector<bool> encode_data(uint8_t input)
    uint8_t lo_GCR = 0;
    uint8_t hi_GCR = 0;

-    // Convert the byte in high and low nibble
-    lo = input >> 4; // get the lo nibble shift the bits 4 to the right
-    hi = input & 15; // get the hi nibble bij masking the lo bits (00001111)
+    //Convert the byte in high and low nibble
+    lo = input >> 4; //get the lo nibble shift the bits 4 to the right          
+    hi = input & 15; //get the hi nibble bij masking the lo bits (00001111)     

-    lo_GCR = encode_data_gcr(lo); // example value: 0000   GCR = 01010
-    hi_GCR = encode_data_gcr(hi); // example value: 1000   GCR = 01001
-    // output = [0,1,2,3,4,5,6,7,8,9]
-    // value  = [0,1,0,1,0,0,1,0,0,1]
-    //           01010 01001
+
+    lo_GCR = encode_data_gcr(lo);   //example value: 0000   GCR = 01010
+    hi_GCR = encode_data_gcr(hi);   //example value: 1000   GCR = 01001
+    //output = [0,1,2,3,4,5,6,7,8,9]
+    //value  = [0,1,0,1,0,0,1,0,0,1]
+    //          01010 01001

    int b = 4;
    for (int i = 0; i < 10; i++)
    {
-        if (i < 5)                        // 01234
-        {                                 // i = 0 op
-            output[4 - i] = (lo_GCR & 1); // 01010
+        if (i < 5) //01234
+        {       //i = 0 op 
+            output[4-i] = (lo_GCR & 1); //01010

-            // 01010 -> & 00001 -> 00000 output[4] = 0
-            // 00101 -> & 00001 -> 00001 output[3] = 1
-            // 00010 -> & 00001 -> 00000 output[2] = 0
-            // 00001 -> & 00001 -> 00001 output[1] = 1
-            // 00000 -> & 00001 -> 00000 output[0] = 0
+            //01010 -> & 00001 -> 00000 output[4] = 0
+            //00101 -> & 00001 -> 00001 output[3] = 1
+            //00010 -> & 00001 -> 00000 output[2] = 0
+            //00001 -> & 00001 -> 00001 output[1] = 1
+            //00000 -> & 00001 -> 00000 output[0] = 0
            lo_GCR >>= 1;
-        }
-        else
+        } else  
        {
-            output[i + b] = (hi_GCR & 1); // 01001
-            // 01001 -> & 00001 -> 00001 output[9] = 1
-            // 00100 -> & 00001 -> 00000 output[8] = 0
-            // 00010 -> & 00001 -> 00000 output[7] = 0
-            // 00001 -> & 00001 -> 00001 output[6] = 1
-            // 00000 -> & 00001 -> 00000 output[5] = 0
+            output[i+b] = (hi_GCR & 1); //01001
+            //01001 -> & 00001 -> 00001 output[9] = 1
+            //00100 -> & 00001 -> 00000 output[8] = 0
+            //00010 -> & 00001 -> 00000 output[7] = 0
+            //00001 -> & 00001 -> 00001 output[6] = 1
+            //00000 -> & 00001 -> 00000 output[5] = 0
            hi_GCR >>= 1;
-            b = b - 2;
+            b = b-2;
        }
    }
    return output;
 }

-class Commodore64Encoder : public Encoder
+void Commodore64Encoder::writeSector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector) const
 {
-public:
-    Commodore64Encoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.c64())
+    /* Source: http://www.unusedino.de/ec64/technical/formats/g64.html 
+     * 1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
+     * 2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
+     * 3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
+     * 4. Data sync         FF FF FF FF FF (40 'on' bits, not GCR)
+     * 5. Data block        55...4A (325 GCR bytes)
+     * 6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
+     * 1. Header sync       (SYNC for the next sector)
+    */
+    if ((sector->status == Sector::OK) or (sector->status == Sector::BAD_CHECKSUM))
    {
-    }
+        // There is data to encode to disk.
+        if ((sector->data.size() != C64_SECTOR_LENGTH))
+            Error() << fmt::format("unsupported sector size {} --- you must pick 256", sector->data.size());    

-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        /* The format ID Character # 1 and # 2 are in the .d64 image only
-         * present in track 18 sector zero which contains the BAM info in byte
-         * 162 and 163. it is written in every header of every sector and track.
-         * headers are not stored in a d64 disk image so we have to get it from
-         * track 18 which contains the BAM.
+        // 1. Write header Sync (not GCR)
+        for (int i=0; i<6; i++)
+            write_bits(bits, cursor, C64_HEADER_DATA_SYNC, 1*8); /* sync */
+
+        // 2. Write Header info 10 GCR bytes
+        /*
+         * The 10 byte header info (#2) is GCR encoded and must be decoded  to
+         * it's normal 8 bytes to be understood. Once decoded, its breakdown is
+         * as follows:
+         * 
+         * Byte $00 - header block ID           ($08)
+         *   01 - header block checksum 16  (EOR of $02-$05)
+         *   02 - Sector
+         *   03 - Track
+         *   04 - Format ID byte #2
+         *   05 - Format ID byte #1
+         *   06-07 - $0F ("off" bytes)
+         */
+        uint8_t encodedTrack = ((sector->logicalTrack) + 1); // C64 track numbering starts with 1. Fluxengine with 0.
+        uint8_t encodedSector = sector->logicalSector;
+        // uint8_t formatByte1 = C64_FORMAT_ID_BYTE1;
+        // uint8_t formatByte2 = C64_FORMAT_ID_BYTE2;
+        uint8_t headerChecksum = (encodedTrack ^ encodedSector ^ _formatByte1 ^ _formatByte2);
+        write_bits(bits, cursor, encode_data(C64_HEADER_BLOCK_ID));
+        write_bits(bits, cursor, encode_data(headerChecksum));
+        write_bits(bits, cursor, encode_data(encodedSector));
+        write_bits(bits, cursor, encode_data(encodedTrack));
+        write_bits(bits, cursor, encode_data(_formatByte2));
+        write_bits(bits, cursor, encode_data(_formatByte1));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+
+        // 3. Write header GAP not GCR
+        for (int i=0; i<9; i++)
+            write_bits(bits, cursor, C64_HEADER_GAP, 1*8); /* header gap */
+
+        // 4. Write Data sync not GCR
+        for (int i=0; i<6; i++)
+            write_bits(bits, cursor, C64_HEADER_DATA_SYNC, 1*8); /* sync */
+
+        // 5. Write data block 325 GCR bytes
+        /*
+         * The 325 byte data block (#5) is GCR encoded and must be  decoded  to  its
+         * normal 260 bytes to be understood. The data block is made up of the following:
+         * 
+         * Byte    $00 - data block ID ($07)
+         *      01-100 - 256 bytes data
+         *      101 - data block checksum (EOR of $01-100)
+         *      102-103 - $00 ("off" bytes, to make the sector size a multiple of 5)
         */

-        const auto& sectorData = image.get(
-            C64_BAM_TRACK, 0, 0); // Read de BAM to get the DISK ID bytes
+        write_bits(bits, cursor, encode_data(C64_DATA_BLOCK_ID));
+        uint8_t dataChecksum = xorBytes(sector->data);
+        ByteReader br(sector->data);
+        int i = 0;
+        for (i = 0; i < C64_SECTOR_LENGTH; i++)
+        {
+            uint8_t val = br.read_8();
+            write_bits(bits, cursor, encode_data(val));     
+        }
+        write_bits(bits, cursor, encode_data(dataChecksum));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+
+        //6. Write inter-sector gap 9 - 12 bytes nor gcr
+        for (int i=0; i<9; i++)
+            write_bits(bits, cursor, C64_INTER_SECTOR_GAP, 1*8); /* sync */
+
+    }
+}
+
+std::unique_ptr<Fluxmap> Commodore64Encoder::encode(
+    int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+    /* The format ID Character # 1 and # 2 are in the .d64 image only present
+     * in track 18 sector zero which contains the BAM info in byte 162 and 163.
+     * it is written in every header of every sector and track. headers are not
+     * stored in a d64 disk image so we have to get it from track 18 which
+     * contains the BAM.
+    */
+
+    const auto& sectorData = allSectors.get(C64_BAM_TRACK*2, 0, 0); //Read de BAM to get the DISK ID bytes
+    if (sectorData)
+    {
+        ByteReader br(sectorData->data);
+        br.seek(162); //goto position of the first Disk ID Byte
+        _formatByte1 = br.read_8();
+        _formatByte2 = br.read_8();
+    }
+    else
+        _formatByte1 = _formatByte2 = 0;
+    
+    int logicalTrack = physicalTrack / 2;
+    double clockRateUs = clockRateUsForTrack(logicalTrack) * _config.clock_compensation_factor();
+
+    int bitsPerRevolution = 200000.0 / clockRateUs;
+
+    std::vector<bool> bits(bitsPerRevolution);
+    unsigned cursor = 0;
+
+    fillBitmapTo(bits, cursor, _config.post_index_gap_us() / clockRateUs, { true, false });
+    lastBit = false;
+
+    unsigned numSectors = sectorsForTrack(logicalTrack);
+    unsigned writtenSectors = 0;
+    for (int sectorId=0; sectorId<numSectors; sectorId++)
+    {
+        const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
        if (sectorData)
        {
-            ByteReader br(sectorData->data);
-            br.seek(162); // goto position of the first Disk ID Byte
-            _formatByte1 = br.read_8();
-            _formatByte2 = br.read_8();
-        }
-        else
-            _formatByte1 = _formatByte2 = 0;
-
-        double clockRateUs = clockPeriodForC64Track(trackInfo->logicalTrack);
-        int bitsPerRevolution = 200000.0 / clockRateUs;
-
-        std::vector<bool> bits(bitsPerRevolution);
-        unsigned cursor = 0;
-
-        fillBitmapTo(bits,
-            cursor,
-            _config.post_index_gap_us() / clockRateUs,
-            {true, false});
-        lastBit = false;
-
-        for (const auto& sector : sectors)
-            writeSector(bits, cursor, sector);
-
-        if (cursor >= bits.size())
-            error("track data overrun by {} bits", cursor - bits.size());
-        fillBitmapTo(bits, cursor, bits.size(), {true, false});
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(
-            bits, calculatePhysicalClockPeriod(clockRateUs * 1e3, 200e6));
-        return fluxmap;
-    }
-
-private:
-    void writeSector(std::vector<bool>& bits,
-        unsigned& cursor,
-        std::shared_ptr<const Sector> sector) const
-    {
-        /* Source: http://www.unusedino.de/ec64/technical/formats/g64.html
-         * 1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
-         * 2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
-         * 3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
-         * 4. Data sync         FF FF FF FF FF (40 'on' bits, not GCR)
-         * 5. Data block        55...4A (325 GCR bytes)
-         * 6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
-         * 1. Header sync       (SYNC for the next sector)
-         */
-        if ((sector->status == Sector::OK) or
-            (sector->status == Sector::BAD_CHECKSUM))
-        {
-            // There is data to encode to disk.
-            if ((sector->data.size() != C64_SECTOR_LENGTH))
-                error("unsupported sector size {} --- you must pick 256",
-                    sector->data.size());
-
-            // 1. Write header Sync (not GCR)
-            for (int i = 0; i < 6; i++)
-                write_bits(
-                    bits, cursor, C64_HEADER_DATA_SYNC, 1 * 8); /* sync */
-
-            // 2. Write Header info 10 GCR bytes
-            /*
-             * The 10 byte header info (#2) is GCR encoded and must be decoded
-             * to it's normal 8 bytes to be understood. Once decoded, its
-             * breakdown is as follows:
-             *
-             * Byte $00 - header block ID           ($08)
-             *   01 - header block checksum 16  (EOR of $02-$05)
-             *   02 - Sector
-             *   03 - Track
-             *   04 - Format ID byte #2
-             *   05 - Format ID byte #1
-             *   06-07 - $0F ("off" bytes)
-             */
-            uint8_t encodedTrack =
-                ((sector->logicalTrack) +
-                    1); // C64 track numbering starts with 1. Fluxengine with 0.
-            uint8_t encodedSector = sector->logicalSector;
-            // uint8_t formatByte1 = C64_FORMAT_ID_BYTE1;
-            // uint8_t formatByte2 = C64_FORMAT_ID_BYTE2;
-            uint8_t headerChecksum =
-                (encodedTrack ^ encodedSector ^ _formatByte1 ^ _formatByte2);
-            write_bits(bits, cursor, encode_data(C64_HEADER_BLOCK_ID));
-            write_bits(bits, cursor, encode_data(headerChecksum));
-            write_bits(bits, cursor, encode_data(encodedSector));
-            write_bits(bits, cursor, encode_data(encodedTrack));
-            write_bits(bits, cursor, encode_data(_formatByte2));
-            write_bits(bits, cursor, encode_data(_formatByte1));
-            write_bits(bits, cursor, encode_data(C64_PADDING));
-            write_bits(bits, cursor, encode_data(C64_PADDING));
-
-            // 3. Write header GAP not GCR
-            for (int i = 0; i < 9; i++)
-                write_bits(
-                    bits, cursor, C64_HEADER_GAP, 1 * 8); /* header gap */
-
-            // 4. Write Data sync not GCR
-            for (int i = 0; i < 6; i++)
-                write_bits(
-                    bits, cursor, C64_HEADER_DATA_SYNC, 1 * 8); /* sync */
-
-            // 5. Write data block 325 GCR bytes
-            /*
-             * The 325 byte data block (#5) is GCR encoded and must be  decoded
-             * to  its normal 260 bytes to be understood. The data block is made
-             * up of the following:
-             *
-             * Byte    $00 - data block ID ($07)
-             *      01-100 - 256 bytes data
-             *      101 - data block checksum (EOR of $01-100)
-             *      102-103 - $00 ("off" bytes, to make the sector size a
-             * multiple of 5)
-             */
-
-            write_bits(bits, cursor, encode_data(C64_DATA_BLOCK_ID));
-            uint8_t dataChecksum = xorBytes(sector->data);
-            ByteReader br(sector->data);
-            int i = 0;
-            for (i = 0; i < C64_SECTOR_LENGTH; i++)
-            {
-                uint8_t val = br.read_8();
-                write_bits(bits, cursor, encode_data(val));
-            }
-            write_bits(bits, cursor, encode_data(dataChecksum));
-            write_bits(bits, cursor, encode_data(C64_PADDING));
-            write_bits(bits, cursor, encode_data(C64_PADDING));
-
-            // 6. Write inter-sector gap 9 - 12 bytes nor gcr
-            for (int i = 0; i < 9; i++)
-                write_bits(
-                    bits, cursor, C64_INTER_SECTOR_GAP, 1 * 8); /* sync */
+            writeSector(bits, cursor, sectorData);
+            writtenSectors++;
        }
    }
+    if (writtenSectors == 0)
+        return std::unique_ptr<Fluxmap>();

-private:
-    const Commodore64EncoderProto& _config;
-    uint8_t _formatByte1;
-    uint8_t _formatByte2;
-};
+    if (cursor >= bits.size())
+        Error() << fmt::format("track data overrun by {} bits", cursor - bits.size());
+    fillBitmapTo(bits, cursor, bits.size(), { true, false });

-std::unique_ptr<Encoder> createCommodore64Encoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new Commodore64Encoder(config));
+    std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+    fluxmap->appendBits(bits, clockRateUs*1e3);
+    return fluxmap;
 }

 // vim: sw=4 ts=4 et
+
--- a/arch/f85/decoder.cc
+++ b/arch/f85/decoder.cc
@@ -1,34 +1,32 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "f85.h"
-#include "lib/core/crc.h"
-#include "lib/core/bytes.h"
+#include "crc.h"
+#include "bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 const FluxPattern SECTOR_RECORD_PATTERN(24, F85_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(24, F85_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

 static int decode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

 static Bytes decode(const std::vector<bool>& bits)
 {
@@ -40,11 +38,11 @@ static Bytes decode(const std::vector<bool>& bits)
    while (ii != bits.end())
    {
        uint8_t inputfifo = 0;
-        for (size_t i = 0; i < 5; i++)
+        for (size_t i=0; i<5; i++)
        {
            if (ii == bits.end())
                break;
-            inputfifo = (inputfifo << 1) | *ii++;
+            inputfifo = (inputfifo<<1) | *ii++;
        }

        bitw.push(decode_data_gcr(inputfifo), 4);
@@ -54,58 +52,49 @@ static Bytes decode(const std::vector<bool>& bits)
    return output;
 }

-class DurangoF85Decoder : public Decoder
+AbstractDecoder::RecordType DurangoF85Decoder::advanceToNextRecord()
 {
-public:
-    DurangoF85Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        /* Skip sync bits and ID byte. */
-
-        if (readRaw24() != F85_SECTOR_RECORD)
-            return;
-
-        /* Read header. */
-
-        const auto& bytes = decode(readRawBits(6 * 10));
-
-        _sector->logicalSector = bytes[2];
-        _sector->logicalSide = 0;
-        _sector->logicalTrack = bytes[0];
-
-        uint16_t wantChecksum = bytes.reader().seek(4).read_be16();
-        uint16_t gotChecksum = crc16(CCITT_POLY, 0xef21, bytes.slice(0, 4));
-        if (wantChecksum == gotChecksum)
-            _sector->status =
-                Sector::DATA_MISSING; /* unintuitive but correct */
-    }
-
-    void decodeDataRecord() override
-    {
-        /* Skip sync bits ID byte. */
-
-        if (readRaw24() != F85_DATA_RECORD)
-            return;
-
-        const auto& bytes = decode(readRawBits((F85_SECTOR_LENGTH + 3) * 10))
-                                .slice(0, F85_SECTOR_LENGTH + 3);
-        ByteReader br(bytes);
-
-        _sector->data = br.read(F85_SECTOR_LENGTH);
-        uint16_t wantChecksum = br.read_be16();
-        uint16_t gotChecksum = crc16(CCITT_POLY, 0xbf84, _sector->data);
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createDurangoF85Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new DurangoF85Decoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return RecordType::SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return RecordType::DATA_RECORD;
+	return RecordType::UNKNOWN_RECORD;
+}
+
+void DurangoF85Decoder::decodeSectorRecord()
+{
+    /* Skip sync bits and ID byte. */
+
+    readRawBits(24);
+
+    /* Read header. */
+
+    const auto& bytes = decode(readRawBits(6*10));
+
+    _sector->logicalSector = bytes[2];
+    _sector->logicalSide = 0;
+    _sector->logicalTrack = bytes[0];
+
+    uint16_t wantChecksum = bytes.reader().seek(4).read_be16();
+    uint16_t gotChecksum = crc16(CCITT_POLY, 0xef21, bytes.slice(0, 4));
+    if (wantChecksum == gotChecksum)
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+}
+
+void DurangoF85Decoder::decodeDataRecord()
+{
+    /* Skip sync bits ID byte. */
+
+    readRawBits(24);
+
+    const auto& bytes = decode(readRawBits((F85_SECTOR_LENGTH+3)*10))
+        .slice(0, F85_SECTOR_LENGTH+3);
+    ByteReader br(bytes);
+
+    _sector->data = br.read(F85_SECTOR_LENGTH);
+    uint16_t wantChecksum = br.read_be16();
+    uint16_t gotChecksum = crc16(CCITT_POLY, 0xbf84, _sector->data);
+    _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/f85/f85.h
+++ b/arch/f85/f85.h
@@ -2,10 +2,22 @@
 #define F85_H

 #define F85_SECTOR_RECORD 0xffffce /* 1111 1111 1111 1111 1100 1110 */
-#define F85_DATA_RECORD 0xffffcb   /* 1111 1111 1111 1111 1100 1101 */
-#define F85_SECTOR_LENGTH 512
+#define F85_DATA_RECORD 0xffffcb /* 1111 1111 1111 1111 1100 1101 */
+#define F85_SECTOR_LENGTH    512

-extern std::unique_ptr<Decoder> createDurangoF85Decoder(
-    const DecoderProto& config);
+class Sector;
+class Fluxmap;
+class F85DecoderProto;
+
+class DurangoF85Decoder : public AbstractDecoder
+{
+public:
+	DurangoF85Decoder(const F85DecoderProto&) {}
+    virtual ~DurangoF85Decoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+};

 #endif
--- a/arch/fb100/decoder.cc
+++ b/arch/fb100/decoder.cc
@@ -1,24 +1,25 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "fb100.h"
-#include "lib/core/crc.h"
-#include "lib/core/bytes.h"
-#include "lib/decoders/rawbits.h"
+#include "crc.h"
+#include "bytes.h"
+#include "decoders/rawbits.h"
+#include "track.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 const FluxPattern SECTOR_ID_PATTERN(16, 0xabaa);

-/*
+/* 
 * Reverse engineered from a dump of the floppy drive's ROM. I have no idea how
 * it works.
- *
+ * 
 * LF8BA:
 *         clra
 *         staa    X00B0
@@ -98,46 +99,37 @@ static uint16_t checksum(const Bytes& bytes)
    return (crchi << 8) | crclo;
 }

-class Fb100Decoder : public Decoder
+AbstractDecoder::RecordType Fb100Decoder::advanceToNextRecord()
 {
-public:
-    Fb100Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(SECTOR_ID_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        auto rawbits = readRawBits(FB100_RECORD_SIZE * 16);
-
-        const Bytes bytes = decodeFmMfm(rawbits).slice(0, FB100_RECORD_SIZE);
-        ByteReader br(bytes);
-        br.seek(1);
-        const Bytes id = br.read(FB100_ID_SIZE);
-        uint16_t wantIdCrc = br.read_be16();
-        uint16_t gotIdCrc = checksum(id);
-        const Bytes payload = br.read(FB100_PAYLOAD_SIZE);
-        uint16_t wantPayloadCrc = br.read_be16();
-        uint16_t gotPayloadCrc = checksum(payload);
-
-        if (wantIdCrc != gotIdCrc)
-            return;
-
-        uint8_t abssector = id[2];
-        _sector->logicalTrack = abssector >> 1;
-        _sector->logicalSide = 0;
-        _sector->logicalSector = abssector & 1;
-        _sector->data.writer().append(id.slice(5, 12)).append(payload);
-
-        _sector->status = (wantPayloadCrc == gotPayloadCrc)
-                              ? Sector::OK
-                              : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Fb100Decoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(SECTOR_ID_PATTERN, matcher);
+    if (matcher == &SECTOR_ID_PATTERN)
+		return RecordType::SECTOR_RECORD;
+	return RecordType::UNKNOWN_RECORD;
 }
+
+void Fb100Decoder::decodeSectorRecord()
+{
+    auto rawbits = readRawBits(FB100_RECORD_SIZE*16);
+
+    const Bytes bytes = decodeFmMfm(rawbits).slice(0, FB100_RECORD_SIZE);
+    ByteReader br(bytes);
+    br.seek(1);
+    const Bytes id = br.read(FB100_ID_SIZE);
+    uint16_t wantIdCrc = br.read_be16();
+    uint16_t gotIdCrc = checksum(id);
+    const Bytes payload = br.read(FB100_PAYLOAD_SIZE);
+    uint16_t wantPayloadCrc = br.read_be16();
+    uint16_t gotPayloadCrc = checksum(payload);
+
+    if (wantIdCrc != gotIdCrc)
+        return;
+
+    uint8_t abssector = id[2];
+    _sector->logicalTrack = abssector >> 1;
+    _sector->logicalSide = 0;
+    _sector->logicalSector = abssector & 1;
+    _sector->data.writer().append(id.slice(5, 12)).append(payload);
+
+    _sector->status = (wantPayloadCrc == gotPayloadCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
+}
--- a/arch/fb100/fb100.h
+++ b/arch/fb100/fb100.h
@@ -5,6 +5,20 @@
 #define FB100_ID_SIZE 17
 #define FB100_PAYLOAD_SIZE 0x500

-extern std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config);
+class Sector;
+class Fluxmap;
+class Track;
+class Fb100DecoderProto;
+
+class Fb100Decoder : public AbstractDecoder
+{
+public:
+	Fb100Decoder(const Fb100DecoderProto&) {}
+    virtual ~Fb100Decoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+};

 #endif
+
--- a/arch/ibm/decoder.cc
+++ b/arch/ibm/decoder.cc
@@ -1,32 +1,31 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
+#include "globals.h"
+#include "decoders/decoders.h"
 #include "ibm.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
+#include "crc.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "sector.h"
+#include "record.h"
 #include "arch/ibm/ibm.pb.h"
-#include "lib/config/proto.h"
-#include "lib/data/layout.h"
+#include "proto.h"
 #include <string.h>

 static_assert(std::is_trivially_copyable<IbmIdam>::value,
-    "IbmIdam is not trivially copyable");
+		"IbmIdam is not trivially copyable");

 /*
 * The markers at the beginning of records are special, and have
 * missing clock pulses, allowing them to be found by the logic.
- *
+ * 
 * IAM record:
 * flux:   XXXX-XXX-XXXX-X- = 0xf77a
 * clock:  X X - X - X X X  = 0xd7
 * data:    X X X X X X - - = 0xfc
- *
+ * 
 * (We just ignore this one --- it's useless and optional.)
 */

-/*
+/* 
 * IDAM record:
 * flux:   XXXX-X-X-XXXXXX- = 0xf57e
 * clock:  X X - - - X X X  = 0xc7
@@ -34,7 +33,7 @@ static_assert(std::is_trivially_copyable<IbmIdam>::value,
 */
 const FluxPattern FM_IDAM_PATTERN(16, 0xf57e);

-/*
+/* 
 * DAM1 record:
 * flux:   XXXX-X-X-XX-X-X- = 0xf56a
 * clock:  X X - - - X X X  = 0xc7
@@ -42,7 +41,7 @@ const FluxPattern FM_IDAM_PATTERN(16, 0xf57e);
 */
 const FluxPattern FM_DAM1_PATTERN(16, 0xf56a);

-/*
+/* 
 * DAM2 record:
 * flux:   XXXX-X-X-XX-XXXX = 0xf56f
 * clock:  X X - - - X X X  = 0xc7
@@ -50,7 +49,7 @@ const FluxPattern FM_DAM1_PATTERN(16, 0xf56a);
 */
 const FluxPattern FM_DAM2_PATTERN(16, 0xf56f);

-/*
+/* 
 * TRS80DAM1 record:
 * flux:   XXXX-X-X-XX-X-XX = 0xf56b
 * clock:  X X - - - X X X  = 0xc7
@@ -58,7 +57,7 @@ const FluxPattern FM_DAM2_PATTERN(16, 0xf56f);
 */
 const FluxPattern FM_TRS80DAM1_PATTERN(16, 0xf56b);

-/*
+/* 
 * TRS80DAM2 record:
 * flux:   XXXX-X-X-XX-XXX- = 0xf56e
 * clock:  X X - - - X X X  = 0xc7
@@ -74,178 +73,94 @@ const FluxPattern FM_TRS80DAM2_PATTERN(16, 0xf56e);
 *                       ^^^^^
 * When shifted out of phase, the special 0xa1 byte becomes an illegal
 * encoding (you can't do 10 00). So this can't be spoofed by user data.
- *
+ * 
 * shifted: 10 00 10 01 00 01 00 1
- *
+ * 
 * It's repeated three times.
 */
 const FluxPattern MFM_PATTERN(48, 0x448944894489LL);

-const FluxMatchers ANY_RECORD_PATTERN({
-    &MFM_PATTERN,
-    &FM_IDAM_PATTERN,
-    &FM_DAM1_PATTERN,
-    &FM_DAM2_PATTERN,
-    &FM_TRS80DAM1_PATTERN,
-    &FM_TRS80DAM2_PATTERN,
-});
+const FluxMatchers ANY_RECORD_PATTERN(
+    {
+        &MFM_PATTERN,
+        &FM_IDAM_PATTERN,
+        &FM_DAM1_PATTERN,
+        &FM_DAM2_PATTERN,
+        &FM_TRS80DAM1_PATTERN,
+        &FM_TRS80DAM2_PATTERN,
+    }
+);

-class IbmDecoder : public Decoder
+std::set<unsigned> IbmDecoder::requiredSectors(Track& track) const
 {
-public:
-    IbmDecoder(const DecoderProto& config):
-        Decoder(config),
-        _config(config.ibm())
-    {
-    }
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        /* This is really annoying because the IBM record scheme has a
-         * variable-sized header _and_ the checksum covers this header too. So
-         * we have to read and decode a byte at a time until we know where the
-         * record itself starts, saving the bytes for the checksumming later.
-         */
-
-        Bytes bytes;
-        ByteWriter bw(bytes);
-
-        auto readByte = [&]()
-        {
-            auto bits = readRawBits(16);
-            auto bytes = decodeFmMfm(bits).slice(0, 1);
-            uint8_t byte = bytes[0];
-            bw.write_8(byte);
-            return byte;
-        };
-
-        uint8_t id = readByte();
-        if (id == 0xa1)
-        {
-            readByte();
-            readByte();
-            id = readByte();
-        }
-        if (id != IBM_IDAM)
-            return;
-
-        ByteReader br(bytes);
-        br.seek(bw.pos);
-
-        auto bits = readRawBits(IBM_IDAM_LEN * 16);
-        bw += decodeFmMfm(bits).slice(0, IBM_IDAM_LEN);
-
-        IbmDecoderProto::TrackdataProto trackdata;
-        getTrackFormat(
-            trackdata, _sector->physicalTrack, _sector->physicalSide);
-
-        _sector->logicalTrack = br.read_8();
-        _sector->logicalSide = br.read_8();
-        _sector->logicalSector = br.read_8();
-        _currentSectorSize = 1 << (br.read_8() + 7);
-
-        uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, br.pos));
-        uint16_t wantCrc = br.read_be16();
-        if (wantCrc == gotCrc)
-            _sector->status =
-                Sector::DATA_MISSING; /* correct but unintuitive */
-
-        if (trackdata.ignore_side_byte())
-            _sector->logicalSide =
-                Layout::remapSidePhysicalToLogical(_sector->physicalSide);
-        _sector->logicalSide ^= trackdata.invert_side_byte();
-        if (trackdata.ignore_track_byte())
-            _sector->logicalTrack = _sector->physicalTrack;
-
-        for (int sector : trackdata.ignore_sector())
-            if (_sector->logicalSector == sector)
-            {
-                _sector->status = Sector::MISSING;
-                break;
-            }
-    }
-
-    void decodeDataRecord() override
-    {
-        /* This is the same deal as the sector record. */
-
-        Bytes bytes;
-        ByteWriter bw(bytes);
-
-        auto readByte = [&]()
-        {
-            auto bits = readRawBits(16);
-            auto bytes = decodeFmMfm(bits).slice(0, 1);
-            uint8_t byte = bytes[0];
-            bw.write_8(byte);
-            return byte;
-        };
-
-        uint8_t id = readByte();
-        if (id == 0xa1)
-        {
-            readByte();
-            readByte();
-            id = readByte();
-        }
-        if ((id != IBM_DAM1) && (id != IBM_DAM2) && (id != IBM_TRS80DAM1) &&
-            (id != IBM_TRS80DAM2))
-            return;
-
-        ByteReader br(bytes);
-        br.seek(bw.pos);
-
-        auto bits = readRawBits((_currentSectorSize + 2) * 16);
-        bw += decodeFmMfm(bits).slice(0, _currentSectorSize + 2);
-
-        _sector->data = br.read(_currentSectorSize);
-        uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, br.pos));
-        uint16_t wantCrc = br.read_be16();
-        _sector->status =
-            (wantCrc == gotCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
-
-        auto layout = Layout::getLayoutOfTrack(
-            _sector->logicalTrack, _sector->logicalSide);
-        if (_currentSectorSize != layout->sectorSize)
-            std::cerr << fmt::format(
-                "Warning: configured sector size for t{}.h{}.s{} is {} bytes "
-                "but that seen on disk is {} bytes\n",
-                _sector->logicalTrack,
-                _sector->logicalSide,
-                _sector->logicalSector,
-                layout->sectorSize,
-                _currentSectorSize);
-    }
-
-private:
-    void getTrackFormat(IbmDecoderProto::TrackdataProto& trackdata,
-        unsigned track,
-        unsigned head) const
-    {
-        trackdata.Clear();
-        for (const auto& f : _config.trackdata())
-        {
-            if (f.has_track() && (f.track() != track))
-                continue;
-            if (f.has_head() && (f.head() != head))
-                continue;
-
-            trackdata.MergeFrom(f);
-        }
-    }
-
-private:
-    const IbmDecoderProto& _config;
-    unsigned _currentSectorSize;
-    unsigned _currentHeaderLength;
-};
-
-std::unique_ptr<Decoder> createIbmDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new IbmDecoder(config));
+	return iterate(_config.required_sectors());
+}
+
+AbstractDecoder::RecordType IbmDecoder::advanceToNextRecord()
+{
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+
+    /* If this is the MFM prefix byte, the the decoder is going to expect three
+     * extra bytes on the front of the header. */
+    _currentHeaderLength = (matcher == &MFM_PATTERN) ? 3 : 0;
+
+    Fluxmap::Position here = tell();
+    if (_currentHeaderLength > 0)
+        readRawBits(_currentHeaderLength*16);
+    auto idbits = readRawBits(16);
+    const Bytes idbytes = decodeFmMfm(idbits);
+    uint8_t id = idbytes.slice(0, 1)[0];
+    seek(here);
+    
+    switch (id)
+    {
+        case IBM_IDAM:
+            return RecordType::SECTOR_RECORD;
+
+        case IBM_DAM1:
+        case IBM_DAM2:
+        case IBM_TRS80DAM1:
+        case IBM_TRS80DAM2:
+            return RecordType::DATA_RECORD;
+    }
+    return RecordType::UNKNOWN_RECORD;
+}
+
+void IbmDecoder::decodeSectorRecord()
+{
+    unsigned recordSize = _currentHeaderLength + IBM_IDAM_LEN;
+    auto bits = readRawBits(recordSize*16);
+    auto bytes = decodeFmMfm(bits).slice(0, recordSize);
+
+    ByteReader br(bytes);
+    br.seek(_currentHeaderLength);
+    br.read_8(); /* skip ID byte */
+    _sector->logicalTrack = br.read_8();
+    _sector->logicalSide = br.read_8();
+    _sector->logicalSector = br.read_8() - _config.sector_id_base();
+    _currentSectorSize = 1 << (br.read_8() + 7);
+    uint16_t wantCrc = br.read_be16();
+    uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, _currentHeaderLength + 5));
+    if (wantCrc == gotCrc)
+        _sector->status = Sector::DATA_MISSING; /* correct but unintuitive */
+
+    if (_config.ignore_side_byte())
+        _sector->logicalSide = _sector->physicalSide;
+}
+
+void IbmDecoder::decodeDataRecord()
+{
+    unsigned recordLength = _currentHeaderLength + _currentSectorSize + 3;
+    auto bits = readRawBits(recordLength*16);
+    auto bytes = decodeFmMfm(bits).slice(0, recordLength);
+
+    ByteReader br(bytes);
+    br.seek(_currentHeaderLength);
+    br.read_8(); /* skip ID byte */
+
+    _sector->data = br.read(_currentSectorSize);
+    uint16_t wantCrc = br.read_be16();
+    uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, recordLength-2));
+    _sector->status = (wantCrc == gotCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/ibm/encoder.cc
+++ b/arch/ibm/encoder.cc
@@ -1,15 +1,13 @@
-#include "lib/core/globals.h"
-#include "lib/config/config.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 #include "ibm.h"
-#include "lib/core/crc.h"
-#include "lib/data/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
 #include "arch/ibm/ibm.pb.h"
-#include "lib/encoders/encoders.pb.h"
 #include "fmt/format.h"
-#include "lib/config/proto.h"
-#include "lib/data/layout.h"
 #include <ctype.h>

 /* IAM record separator:
@@ -41,9 +39,9 @@
 *                       ^^^^^
 * When shifted out of phase, the special 0xa1 byte becomes an illegal
 * encoding (you can't do 10 00). So this can't be spoofed by user data.
- *
+ * 
 * shifted: 10 00 10 01 00 01 00 1
- *
+ * 
 * It's repeated three times.
 */
 #define MFM_RECORD_SEPARATOR 0x4489
@@ -59,224 +57,202 @@
 * mfm:     01 01 01 01 01 00 01 01 = 0x5545
 */

+static int charToInt(char c)
+{
+	if (isdigit(c))
+		return c - '0';
+	return 10 + tolower(c) - 'a';
+}
+
+void IbmEncoder::writeRawBits(uint32_t data, int width)
+{
+	_cursor += width;
+	_lastBit = data & 1;
+	for (int i=0; i<width; i++)
+	{
+		unsigned pos = _cursor - i - 1;
+		if (pos < _bits.size())
+			_bits[pos] = data & 1;
+		data >>= 1;
+	}
+}
+
 static uint8_t decodeUint16(uint16_t raw)
 {
-    Bytes b;
-    ByteWriter bw(b);
-    bw.write_be16(raw);
-    return decodeFmMfm(b.toBits())[0];
+	Bytes b;
+	ByteWriter bw(b);
+	bw.write_be16(raw);
+	return decodeFmMfm(b.toBits())[0];
 }

-class IbmEncoder : public Encoder
+void IbmEncoder::getTrackFormat(IbmEncoderProto::TrackdataProto& trackdata, unsigned cylinder, unsigned head)
 {
-public:
-    IbmEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.ibm())
-    {
-    }
+	trackdata.Clear();
+	for (const auto& f : _config.trackdata())
+	{
+		if (f.has_cylinder() && (f.cylinder() != cylinder))
+			continue;
+		if (f.has_head() && (f.head() != head))
+			continue;

-private:
-    void writeRawBits(uint32_t data, int width)
-    {
-        _cursor += width;
-        _lastBit = data & 1;
-        for (int i = 0; i < width; i++)
-        {
-            unsigned pos = _cursor - i - 1;
-            if (pos < _bits.size())
-                _bits[pos] = data & 1;
-            data >>= 1;
-        }
-    }
-
-    void getEncoderTrackData(IbmEncoderProto::TrackdataProto& trackdata,
-        unsigned track,
-        unsigned head)
-    {
-        trackdata.Clear();
-        for (const auto& f : _config.trackdata())
-        {
-            if (f.has_track() && (f.track() != track))
-                continue;
-            if (f.has_head() && (f.head() != head))
-                continue;
-
-            trackdata.MergeFrom(f);
-        }
-    }
-
-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        IbmEncoderProto::TrackdataProto trackdata;
-        getEncoderTrackData(
-            trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
-
-        auto trackLayout = Layout::getLayoutOfTrack(
-            trackInfo->logicalTrack, trackInfo->logicalSide);
-
-        auto writeBytes = [&](const Bytes& bytes)
-        {
-            if (trackdata.use_fm())
-                encodeFm(_bits, _cursor, bytes);
-            else
-                encodeMfm(_bits, _cursor, bytes, _lastBit);
-        };
-
-        auto writeFillerRawBytes = [&](int count, uint16_t byte)
-        {
-            for (int i = 0; i < count; i++)
-                writeRawBits(byte, 16);
-        };
-
-        auto writeFillerBytes = [&](int count, uint8_t byte)
-        {
-            Bytes b{byte};
-            for (int i = 0; i < count; i++)
-                writeBytes(b);
-        };
-
-        double clockRateUs = trackdata.target_clock_period_us();
-        if (!trackdata.use_fm())
-            clockRateUs /= 2.0;
-        int bitsPerRevolution =
-            (trackdata.target_rotational_period_ms() * 1000.0) / clockRateUs;
-        _bits.resize(bitsPerRevolution);
-        _cursor = 0;
-
-        uint8_t idamUnencoded = decodeUint16(trackdata.idam_byte());
-        uint8_t damUnencoded = decodeUint16(trackdata.dam_byte());
-
-        uint8_t sectorSize = 0;
-        {
-            int s = trackLayout->sectorSize >> 7;
-            while (s > 1)
-            {
-                s >>= 1;
-                sectorSize += 1;
-            }
-        }
-
-        uint16_t gapFill = trackdata.gap_fill_byte();
-
-        writeFillerRawBytes(trackdata.gap0(), gapFill);
-        if (trackdata.emit_iam())
-        {
-            writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
-            if (!trackdata.use_fm())
-            {
-                for (int i = 0; i < 3; i++)
-                    writeRawBits(MFM_IAM_SEPARATOR, 16);
-            }
-            writeRawBits(
-                trackdata.use_fm() ? FM_IAM_RECORD : MFM_IAM_RECORD, 16);
-            writeFillerRawBytes(trackdata.gap1(), gapFill);
-        }
-
-        bool first = true;
-        for (const auto& sectorData : sectors)
-        {
-            if (!first)
-                writeFillerRawBytes(trackdata.gap3(), gapFill);
-            first = false;
-
-            /* Writing the sector and data records are fantastically annoying.
-             * The CRC is calculated from the *very start* of the record, and
-             * include the malformed marker bytes. Our encoder doesn't know
-             * about this, of course, with the result that we have to construct
-             * the unencoded header, calculate the checksum, and then use the
-             * same logic to emit the bytes which require special encoding
-             * before encoding the rest of the header normally. */
-
-            {
-                Bytes header;
-                ByteWriter bw(header);
-
-                writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
-                if (!trackdata.use_fm())
-                {
-                    for (int i = 0; i < 3; i++)
-                        bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
-                }
-                bw.write_8(idamUnencoded);
-                bw.write_8(sectorData->logicalTrack);
-                bw.write_8(
-                    sectorData->logicalSide ^ trackdata.invert_side_byte());
-                bw.write_8(sectorData->logicalSector);
-                bw.write_8(sectorSize);
-                uint16_t crc = crc16(CCITT_POLY, header);
-                bw.write_be16(crc);
-
-                int conventionalHeaderStart = 0;
-                if (!trackdata.use_fm())
-                {
-                    for (int i = 0; i < 3; i++)
-                        writeRawBits(MFM_RECORD_SEPARATOR, 16);
-                    conventionalHeaderStart += 3;
-                }
-                writeRawBits(trackdata.idam_byte(), 16);
-                conventionalHeaderStart += 1;
-
-                writeBytes(header.slice(conventionalHeaderStart));
-            }
-
-            writeFillerRawBytes(trackdata.gap2(), gapFill);
-
-            {
-                Bytes data;
-                ByteWriter bw(data);
-
-                writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
-                if (!trackdata.use_fm())
-                {
-                    for (int i = 0; i < 3; i++)
-                        bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
-                }
-                bw.write_8(damUnencoded);
-
-                Bytes truncatedData =
-                    sectorData->data.slice(0, trackLayout->sectorSize);
-                bw += truncatedData;
-                uint16_t crc = crc16(CCITT_POLY, data);
-                bw.write_be16(crc);
-
-                int conventionalHeaderStart = 0;
-                if (!trackdata.use_fm())
-                {
-                    for (int i = 0; i < 3; i++)
-                        writeRawBits(MFM_RECORD_SEPARATOR, 16);
-                    conventionalHeaderStart += 3;
-                }
-                writeRawBits(trackdata.dam_byte(), 16);
-                conventionalHeaderStart += 1;
-
-                writeBytes(data.slice(conventionalHeaderStart));
-            }
-        }
-
-        if (_cursor >= _bits.size())
-            error("track data overrun");
-        while (_cursor < _bits.size())
-            writeFillerRawBytes(1, gapFill);
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(_bits,
-            calculatePhysicalClockPeriod(clockRateUs * 1e3,
-                trackdata.target_rotational_period_ms() * 1e6));
-        return fluxmap;
-    }
-
-private:
-    const IbmEncoderProto& _config;
-    std::vector<bool> _bits;
-    unsigned _cursor;
-    bool _lastBit;
-};
-
-std::unique_ptr<Encoder> createIbmEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new IbmEncoder(config));
+		trackdata.MergeFrom(f);
+	}
 }
+
+std::unique_ptr<Fluxmap> IbmEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+	IbmEncoderProto::TrackdataProto trackdata;
+	getTrackFormat(trackdata, physicalTrack, physicalSide);
+
+	auto writeBytes = [&](const Bytes& bytes)
+	{
+		if (trackdata.use_fm())
+			encodeFm(_bits, _cursor, bytes);
+		else
+			encodeMfm(_bits, _cursor, bytes, _lastBit);
+	};
+
+	auto writeFillerBytes = [&](int count, uint8_t byte)
+	{
+		Bytes bytes = { byte };
+		for (int i=0; i<count; i++)
+			writeBytes(bytes);
+	};
+
+	if (trackdata.swap_sides())
+		physicalSide = 1 - physicalSide;
+	double clockRateUs = 1e3 / trackdata.clock_rate_khz();
+	if (!trackdata.use_fm())
+		clockRateUs /= 2.0;
+	int bitsPerRevolution = (trackdata.track_length_ms() * 1000.0) / clockRateUs;
+	_bits.resize(bitsPerRevolution);
+	_cursor = 0;
+
+	uint8_t idamUnencoded = decodeUint16(trackdata.idam_byte());
+	uint8_t damUnencoded = decodeUint16(trackdata.dam_byte());
+
+	uint8_t sectorSize = 0;
+	{
+		int s = trackdata.sector_size() >> 7;
+		while (s > 1)
+		{
+			s >>= 1;
+			sectorSize += 1;
+		}
+	}
+
+	uint8_t gapFill = trackdata.use_fm() ? 0x00 : 0x4e;
+
+	writeFillerBytes(trackdata.gap0(), gapFill);
+	if (trackdata.emit_iam())
+	{
+		writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+		if (!trackdata.use_fm())
+		{
+			for (int i=0; i<3; i++)
+				writeRawBits(MFM_IAM_SEPARATOR, 16);
+		}
+		writeRawBits(trackdata.use_fm() ? FM_IAM_RECORD : MFM_IAM_RECORD, 16);
+		writeFillerBytes(trackdata.gap1(), gapFill);
+	}
+
+	bool first = true;
+	for (char sectorChar : trackdata.sector_skew())
+	{
+		int sectorId = charToInt(sectorChar);
+		if (!first)
+			writeFillerBytes(trackdata.gap3(), gapFill);
+		first = false;
+
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		if (!sectorData)
+		{
+			/* If there are any missing sectors, this is an empty track. */
+			return std::unique_ptr<Fluxmap>();
+		}
+
+		/* Writing the sector and data records are fantastically annoying.
+		 * The CRC is calculated from the *very start* of the record, and
+		 * include the malformed marker bytes. Our encoder doesn't know
+		 * about this, of course, with the result that we have to construct
+		 * the unencoded header, calculate the checksum, and then use the
+		 * same logic to emit the bytes which require special encoding
+		 * before encoding the rest of the header normally. */
+
+		{
+			Bytes header;
+			ByteWriter bw(header);
+
+			writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+			if (!trackdata.use_fm())
+			{
+				for (int i=0; i<3; i++)
+					bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
+			}
+			bw.write_8(idamUnencoded);
+			bw.write_8(sectorData->logicalTrack);
+			bw.write_8(sectorData->logicalSide);
+			bw.write_8(sectorData->logicalSector + trackdata.start_sector_id());
+			bw.write_8(sectorSize);
+			uint16_t crc = crc16(CCITT_POLY, header);
+			bw.write_be16(crc);
+
+			int conventionalHeaderStart = 0;
+			if (!trackdata.use_fm())
+			{
+				for (int i=0; i<3; i++)
+					writeRawBits(MFM_RECORD_SEPARATOR, 16);
+				conventionalHeaderStart += 3;
+
+			}
+			writeRawBits(trackdata.idam_byte(), 16);
+			conventionalHeaderStart += 1;
+
+			writeBytes(header.slice(conventionalHeaderStart));
+		}
+
+		writeFillerBytes(trackdata.gap2(), gapFill);
+
+		{
+			Bytes data;
+			ByteWriter bw(data);
+
+			writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+			if (!trackdata.use_fm())
+			{
+				for (int i=0; i<3; i++)
+					bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
+			}
+			bw.write_8(damUnencoded);
+
+			Bytes truncatedData = sectorData->data.slice(0, trackdata.sector_size());
+			bw += truncatedData;
+			uint16_t crc = crc16(CCITT_POLY, data);
+			bw.write_be16(crc);
+
+			int conventionalHeaderStart = 0;
+			if (!trackdata.use_fm())
+			{
+				for (int i=0; i<3; i++)
+					writeRawBits(MFM_RECORD_SEPARATOR, 16);
+				conventionalHeaderStart += 3;
+
+			}
+			writeRawBits(trackdata.dam_byte(), 16);
+			conventionalHeaderStart += 1;
+
+			writeBytes(data.slice(conventionalHeaderStart));
+		}
+    }
+
+	if (_cursor >= _bits.size())
+		Error() << "track data overrun";
+	while (_cursor < _bits.size())
+		writeFillerBytes(1, gapFill);
+
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(_bits, clockRateUs*1e3);
+	return fluxmap;
+}
+
--- a/arch/ibm/ibm.h
+++ b/arch/ibm/ibm.h
@@ -1,37 +1,77 @@
 #ifndef IBM_H
 #define IBM_H

+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "arch/ibm/ibm.pb.h"
+
 /* IBM format (i.e. ordinary PC floppies). */

-#define IBM_MFM_SYNC 0xA1  /* sync byte for MFM */
-#define IBM_IAM 0xFC       /* start-of-track record */
-#define IBM_IAM_LEN 1      /* plus prologue */
-#define IBM_IDAM 0xFE      /* sector header */
-#define IBM_IDAM_LEN 7     /* plus prologue */
-#define IBM_DAM1 0xF8      /* sector data (type 1) */
-#define IBM_DAM2 0xFB      /* sector data (type 2) */
-#define IBM_TRS80DAM1 0xF9 /* sector data (TRS-80 directory) */
-#define IBM_TRS80DAM2 0xFA /* sector data (TRS-80 directory) */
-#define IBM_DAM_LEN 1      /* plus prologue and user data */
+#define IBM_MFM_SYNC   0xA1   /* sync byte for MFM */
+#define IBM_IAM        0xFC   /* start-of-track record */
+#define IBM_IAM_LEN    1      /* plus prologue */
+#define IBM_IDAM       0xFE   /* sector header */
+#define IBM_IDAM_LEN   7      /* plus prologue */
+#define IBM_DAM1       0xF8   /* sector data (type 1) */
+#define IBM_DAM2       0xFB   /* sector data (type 2) */
+#define IBM_TRS80DAM1  0xF9   /* sector data (TRS-80 directory) */
+#define IBM_TRS80DAM2  0xFA   /* sector data (TRS-80 directory) */
+#define IBM_DAM_LEN    1      /* plus prologue and user data */

 /* Length of a DAM record is determined by the previous sector header. */

 struct IbmIdam
 {
    uint8_t id;
-    uint8_t track;
+    uint8_t cylinder;
    uint8_t side;
    uint8_t sector;
    uint8_t sectorSize;
    uint8_t crc[2];
 };

-class Encoder;
-class Decoder;
-class DecoderProto;
-class EncoderProto;
+class IbmDecoder : public AbstractDecoder
+{
+public:
+    IbmDecoder(const IbmDecoderProto& config):
+		_config(config)
+    {}

-extern std::unique_ptr<Decoder> createIbmDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createIbmEncoder(const EncoderProto& config);
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+
+	std::set<unsigned> requiredSectors(Track& track) const;
+
+private:
+	const IbmDecoderProto& _config;
+    unsigned _currentSectorSize;
+    unsigned _currentHeaderLength;
+};
+
+class IbmEncoder : public AbstractEncoder
+{
+public:
+	IbmEncoder(const IbmEncoderProto& config):
+		_config(config)
+	{}
+
+	virtual ~IbmEncoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	void writeRawBits(uint32_t data, int width);
+	void writeSync();
+	
+	void getTrackFormat(IbmEncoderProto::TrackdataProto& format, unsigned track, unsigned side);
+
+private:
+	const IbmEncoderProto& _config;
+	std::vector<bool> _bits;
+	unsigned _cursor;
+	bool _lastBit;
+};

 #endif
--- a/arch/ibm/ibm.proto
+++ b/arch/ibm/ibm.proto
@@ -1,31 +1,23 @@
 syntax = "proto2";

-import "lib/config/common.proto";
+import "lib/common.proto";

 message IbmDecoderProto {
-	// Next: 11
-	message TrackdataProto {
-		optional int32 track = 7              [(help) = "if set, the format applies only to this track"];
-		optional int32 head = 8                  [(help) = "if set, the format applies only to this head"];
-
-		optional bool ignore_side_byte = 2       [default = false, (help) = "ignore side byte in sector header"];
-		optional bool ignore_track_byte = 6      [default = false, (help) = "ignore track byte in sector header"];
-		optional bool invert_side_byte = 4       [default = false, (help) = "invert the side byte in the sector header"];
-
-		repeated int32 ignore_sector = 10        [(help) = "sectors with these IDs will not be read"];
-	}
-
-	repeated TrackdataProto trackdata = 1;
+	optional int32 sector_id_base = 1        [default = 1, (help) = "ID of first sector"];
+	optional bool ignore_side_byte = 2       [default = false, (help) = "ignore side byte in sector header"];
+	optional RangeProto required_sectors = 3 [(help) = "require these sectors to exist for a good read"];
 }

 message IbmEncoderProto {
-	// Next: 20
 	message TrackdataProto {
-		optional int32 track = 15        [(help) = "if set, the format applies only to this track"];
+		optional int32 cylinder = 15        [(help) = "if set, the format applies only to this track"];
 		optional int32 head = 16            [(help) = "if set, the format applies only to this head"];

+		optional double track_length_ms = 1 [(help) = "length of track"];
+		optional int32 sector_size = 2      [default=512, (help) = "number of bytes per sector"];
 		optional bool emit_iam = 3          [default=true, (help) = "whether to emit an IAM record"];
-		optional double target_clock_period_us = 5  [default=4, (help) = "data clock rate on target disk"];
+		optional int32 start_sector_id = 4  [default=1, (help) = "ID of first sector"];
+		optional double clock_rate_khz = 5  [(help) = "data clock rate"];
 		optional bool use_fm = 6            [default=false, (help) = "whether to use FM encoding rather than MFM"];
 		optional int32 idam_byte = 7        [default=0x5554, (help) = "16-bit raw bit pattern of IDAM byte"];
 		optional int32 dam_byte = 8         [default=0x5545, (help) = "16-bit raw bit pattern of DAM byte"];
@@ -33,9 +25,8 @@ message IbmEncoderProto {
 		optional int32 gap1 = 10            [default=50, (help) = "size of gap 2 (the post-ID gap)"];
 		optional int32 gap2 = 11            [default=22, (help) = "size of gap 3 (the pre-data gap)"];
 		optional int32 gap3 = 12            [default=80, (help) = "size of gap 4 (the post-data or format gap)"];
-		optional bool invert_side_byte = 19 [default=false, (help) = "invert the side byte before writing"];
-		optional int32 gap_fill_byte = 18   [default=0x9254, (help) = "16-bit raw bit pattern of gap fill byte"];
-		optional double target_rotational_period_ms = 1 [default=200, (help) = "rotational period of target disk"];
+		optional string sector_skew = 13    [(help) = "order to emit sectors"];
+		optional bool swap_sides = 14       [default=false, (help) = "swap side bytes when writing"];
 	}

 	repeated TrackdataProto trackdata = 1;
--- a/arch/macintosh/decoder.cc
+++ b/arch/macintosh/decoder.cc
@@ -1,37 +1,35 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
+#include "track.h"
 #include "macintosh.h"
-#include "lib/core/bytes.h"
+#include "bytes.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 const FluxPattern SECTOR_RECORD_PATTERN(24, MAC_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(24, MAC_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

 static int decode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

-/* This is extremely inspired by the MESS implementation, written by Nathan
- * Woods and R. Belmont:
- * https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
+/* This is extremely inspired by the MESS implementation, written by Nathan Woods
+ * and R. Belmont: https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
 */
 static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
 {
@@ -45,7 +43,7 @@ static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
    uint8_t b2[LOOKUP_LEN + 1];
    uint8_t b3[LOOKUP_LEN + 1];

-    for (int i = 0; i <= LOOKUP_LEN; i++)
+    for (int i=0; i<=LOOKUP_LEN; i++)
    {
        uint8_t w4 = br.read_8();
        uint8_t w1 = br.read_8();
@@ -126,71 +124,85 @@ uint8_t decode_side(uint8_t side)
    return !!(side & 0x20);
 }

-class MacintoshDecoder : public Decoder
+AbstractDecoder::RecordType MacintoshDecoder::advanceToNextRecord()
 {
-public:
-    MacintoshDecoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw24() != MAC_SECTOR_RECORD)
-            return;
-
-        /* Read header. */
-
-        auto header = toBytes(readRawBits(7 * 8)).slice(0, 7);
-
-        uint8_t encodedTrack = decode_data_gcr(header[0]);
-        if (encodedTrack != (_sector->physicalTrack & 0x3f))
-            return;
-
-        uint8_t encodedSector = decode_data_gcr(header[1]);
-        uint8_t encodedSide = decode_data_gcr(header[2]);
-        uint8_t formatByte = decode_data_gcr(header[3]);
-        uint8_t wantedsum = decode_data_gcr(header[4]);
-
-        if (encodedSector > 11)
-            return;
-
-        _sector->logicalTrack = _sector->physicalTrack;
-        _sector->logicalSide = decode_side(encodedSide);
-        _sector->logicalSector = encodedSector;
-        uint8_t gotsum =
-            (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
-        if (wantedsum == gotsum)
-            _sector->status =
-                Sector::DATA_MISSING; /* unintuitive but correct */
-    }
-
-    void decodeDataRecord() override
-    {
-        if (readRaw24() != MAC_DATA_RECORD)
-            return;
-
-        /* Read data. */
-
-        readRawBits(8); /* skip spare byte */
-        auto inputbuffer = toBytes(readRawBits(MAC_ENCODED_SECTOR_LENGTH * 8))
-                               .slice(0, MAC_ENCODED_SECTOR_LENGTH);
-
-        for (unsigned i = 0; i < inputbuffer.size(); i++)
-            inputbuffer[i] = decode_data_gcr(inputbuffer[i]);
-
-        _sector->status = Sector::BAD_CHECKSUM;
-        Bytes userData = decode_crazy_data(inputbuffer, _sector->status);
-        _sector->data.clear();
-        _sector->data.writer()
-            .append(userData.slice(12, 512))
-            .append(userData.slice(0, 12));
-    }
-};
-
-std::unique_ptr<Decoder> createMacintoshDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new MacintoshDecoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return DATA_RECORD;
+	return UNKNOWN_RECORD;
 }
+
+void MacintoshDecoder::decodeSectorRecord()
+{
+    /* Skip ID (as we know it's a MAC_SECTOR_RECORD). */
+    readRawBits(24);
+
+    /* Read header. */
+
+    auto header = toBytes(readRawBits(7*8)).slice(0, 7);
+                
+    uint8_t encodedTrack = decode_data_gcr(header[0]);
+    if (encodedTrack != (_track->physicalTrack & 0x3f))
+        return;
+                
+    uint8_t encodedSector = decode_data_gcr(header[1]);
+    uint8_t encodedSide = decode_data_gcr(header[2]);
+    uint8_t formatByte = decode_data_gcr(header[3]);
+    uint8_t wantedsum = decode_data_gcr(header[4]);
+
+    if (encodedSector > 11)
+        return;
+
+    _sector->logicalTrack = _track->physicalTrack;
+    _sector->logicalSide = decode_side(encodedSide);
+    _sector->logicalSector = encodedSector;
+    uint8_t gotsum = (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
+    if (wantedsum == gotsum)
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+}
+
+void MacintoshDecoder::decodeDataRecord()
+{
+    auto id = toBytes(readRawBits(24)).reader().read_be24();
+    if (id != MAC_DATA_RECORD)
+        return;
+
+    /* Read data. */
+
+    readRawBits(8); /* skip spare byte */
+    auto inputbuffer = toBytes(readRawBits(MAC_ENCODED_SECTOR_LENGTH*8))
+        .slice(0, MAC_ENCODED_SECTOR_LENGTH);
+
+    for (unsigned i=0; i<inputbuffer.size(); i++)
+        inputbuffer[i] = decode_data_gcr(inputbuffer[i]);
+        
+    _sector->status = Sector::BAD_CHECKSUM;
+    Bytes userData = decode_crazy_data(inputbuffer, _sector->status);
+    _sector->data.clear();
+    _sector->data.writer().append(userData.slice(12, 512)).append(userData.slice(0, 12));
+}
+
+std::set<unsigned> MacintoshDecoder::requiredSectors(Track& track) const
+{
+	int count;
+	if (track.physicalTrack < 16)
+		count = 12;
+	else if (track.physicalTrack < 32)
+		count = 11;
+	else if (track.physicalTrack < 48)
+		count = 10;
+	else if (track.physicalTrack < 64)
+		count = 9;
+	else
+		count = 8;
+
+	std::set<unsigned> sectors;
+	while (count--)
+		sectors.insert(count);
+	return sectors;
+}
+
+
--- a/arch/macintosh/encoder.cc
+++ b/arch/macintosh/encoder.cc
@@ -1,60 +1,68 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 #include "macintosh.h"
-#include "lib/core/crc.h"
-#include "lib/data/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
 #include "fmt/format.h"
-#include "lib/encoders/encoders.pb.h"
-#include "lib/data/layout.h"
-#include "arch/macintosh/macintosh.pb.h"
 #include <ctype.h>

+FlagGroup macintoshEncoderFlags;
+
+static DoubleFlag postIndexGapUs(
+	{ "--post-index-gap-us" },
+	"Post-index gap before first sector header (microseconds).",
+	0);
+
+static DoubleFlag clockCompensation(
+	{ "--clock-compensation-factor" },
+	"Scale the output clock by this much.",
+	1.0);
+
 static bool lastBit;

 static double clockRateUsForTrack(unsigned track)
 {
-    if (track < 16)
-        return 2.63;
-    if (track < 32)
-        return 2.89;
-    if (track < 48)
-        return 3.20;
-    if (track < 64)
-        return 3.57;
-    return 3.98;
+	if (track < 16)
+		return 2.623;
+	if (track < 32)
+		return 2.861;
+	if (track < 48)
+		return 3.148;
+	if (track < 64)
+		return 3.497;
+	return 3.934;
 }

 static unsigned sectorsForTrack(unsigned track)
 {
-    if (track < 16)
-        return 12;
-    if (track < 32)
-        return 11;
-    if (track < 48)
-        return 10;
-    if (track < 64)
-        return 9;
-    return 8;
+	if (track < 16)
+		return 12;
+	if (track < 32)
+		return 11;
+	if (track < 48)
+		return 10;
+	if (track < 64)
+		return 9;
+	return 8;
 }

 static int encode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case data:               \
-        return gcr;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case data: return gcr;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

-/* This is extremely inspired by the MESS implementation, written by Nathan
- * Woods and R. Belmont:
- * https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
+/* This is extremely inspired by the MESS implementation, written by Nathan Woods
+ * and R. Belmont: https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
 */
 static Bytes encode_crazy_data(const Bytes& input)
 {
@@ -62,7 +70,7 @@ static Bytes encode_crazy_data(const Bytes& input)
    ByteWriter bw(output);
    ByteReader br(input);

-    uint8_t w1, w2, w3, w4;
+	uint8_t w1, w2, w3, w4;

    static const int LOOKUP_LEN = MAC_SECTOR_LENGTH / 3;

@@ -70,94 +78,92 @@ static Bytes encode_crazy_data(const Bytes& input)
    uint8_t b2[LOOKUP_LEN + 1];
    uint8_t b3[LOOKUP_LEN + 1];

-    uint32_t c1 = 0;
-    uint32_t c2 = 0;
-    uint32_t c3 = 0;
-    for (int j = 0;; j++)
-    {
-        c1 = (c1 & 0xff) << 1;
-        if (c1 & 0x0100)
-            c1++;
+	uint32_t c1 = 0;
+	uint32_t c2 = 0;
+	uint32_t c3 = 0;
+	for (int j=0;; j++)
+	{
+		c1 = (c1 & 0xff) << 1;
+		if (c1 & 0x0100)
+			c1++;

-        uint8_t val = br.read_8();
-        c3 += val;
-        if (c1 & 0x0100)
-        {
-            c3++;
-            c1 &= 0xff;
-        }
-        b1[j] = (val ^ c1) & 0xff;
+		uint8_t val = br.read_8();
+		c3 += val;
+		if (c1 & 0x0100)
+		{
+			c3++;
+			c1 &= 0xff;
+		}
+		b1[j] = (val ^ c1) & 0xff;

-        val = br.read_8();
-        c2 += val;
-        if (c3 > 0xff)
-        {
-            c2++;
-            c3 &= 0xff;
-        }
-        b2[j] = (val ^ c3) & 0xff;
+		val = br.read_8();
+		c2 += val;
+		if (c3 > 0xff)
+		{
+			c2++;
+			c3 &= 0xff;
+		}
+		b2[j] = (val ^ c3) & 0xff;

-        if (br.pos == 524)
-            break;
+		if (br.pos == 524)
+			break;

-        val = br.read_8();
-        c1 += val;
-        if (c2 > 0xff)
-        {
-            c1++;
-            c2 &= 0xff;
-        }
-        b3[j] = (val ^ c2) & 0xff;
-    }
-    uint32_t c4 = ((c1 & 0xc0) >> 6) | ((c2 & 0xc0) >> 4) | ((c3 & 0xc0) >> 2);
-    b3[LOOKUP_LEN] = 0;
+		val = br.read_8();
+		c1 += val;
+		if (c2 > 0xff)
+		{
+			c1++;
+			c2 &= 0xff;
+		}
+		b3[j] = (val ^ c2) & 0xff;
+	}
+	uint32_t c4 = ((c1 & 0xc0) >> 6) | ((c2 & 0xc0) >> 4) | ((c3 & 0xc0) >> 2);
+	b3[LOOKUP_LEN] = 0;

-    for (int i = 0; i <= LOOKUP_LEN; i++)
-    {
-        w1 = b1[i] & 0x3f;
-        w2 = b2[i] & 0x3f;
-        w3 = b3[i] & 0x3f;
-        w4 = ((b1[i] & 0xc0) >> 2);
-        w4 |= ((b2[i] & 0xc0) >> 4);
-        w4 |= ((b3[i] & 0xc0) >> 6);
+	for (int i = 0; i <= LOOKUP_LEN; i++)
+	{
+		w1 = b1[i] & 0x3f;
+		w2 = b2[i] & 0x3f;
+		w3 = b3[i] & 0x3f;
+		w4 =  ((b1[i] & 0xc0) >> 2);
+		w4 |= ((b2[i] & 0xc0) >> 4);
+		w4 |= ((b3[i] & 0xc0) >> 6);

-        bw.write_8(w4);
-        bw.write_8(w1);
-        bw.write_8(w2);
+		bw.write_8(w4);
+		bw.write_8(w1);
+		bw.write_8(w2);

-        if (i != LOOKUP_LEN)
-            bw.write_8(w3);
-    }
+		if (i != LOOKUP_LEN)
+			bw.write_8(w3);
+	}

-    bw.write_8(c4 & 0x3f);
-    bw.write_8(c3 & 0x3f);
-    bw.write_8(c2 & 0x3f);
-    bw.write_8(c1 & 0x3f);
+	bw.write_8(c4 & 0x3f);
+	bw.write_8(c3 & 0x3f);
+	bw.write_8(c2 & 0x3f);
+	bw.write_8(c1 & 0x3f);

-    return output;
+	return output;
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
 {
-    for (bool bit : src)
-    {
-        if (cursor < bits.size())
-            bits[cursor++] = bit;
-    }
+	for (bool bit : src)
+	{
+		if (cursor < bits.size())
+			bits[cursor++] = bit;
+	}
 }

-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
 {
-    cursor += width;
-    for (int i = 0; i < width; i++)
-    {
-        unsigned pos = cursor - i - 1;
-        if (pos < bits.size())
-            bits[pos] = data & 1;
-        data >>= 1;
-    }
+	cursor += width;
+	for (int i=0; i<width; i++)
+	{
+		unsigned pos = cursor - i - 1;
+		if (pos < bits.size())
+			bits[pos] = data & 1;
+		data >>= 1;
+	}
 }

 static uint8_t encode_side(uint8_t track, uint8_t side)
@@ -166,93 +172,71 @@ static uint8_t encode_side(uint8_t track, uint8_t side)
     * bit 5) and also whether we're above track 0x3f (in bit 0).
     */

-    return (side ? 0x20 : 0x00) | ((track > 0x3f) ? 0x01 : 0x00);
+	return (side ? 0x20 : 0x00) | ((track>0x3f) ? 0x01 : 0x00);
 }

-static void write_sector(std::vector<bool>& bits,
-    unsigned& cursor,
-    const std::shared_ptr<const Sector>& sector)
+static void write_sector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector)
 {
-    if ((sector->data.size() != 512) && (sector->data.size() != 524))
-        error("unsupported sector size --- you must pick 512 or 524");
+	if ((sector->data.size() != 512) && (sector->data.size() != 524))
+		Error() << "unsupported sector size --- you must pick 512 or 524";

-    write_bits(bits, cursor, 0xff, 1 * 8); /* pad byte */
-    for (int i = 0; i < 7; i++)
-        write_bits(bits, cursor, 0xff3fcff3fcffLL, 6 * 8); /* sync */
-    write_bits(bits, cursor, MAC_SECTOR_RECORD, 3 * 8);
+	write_bits(bits, cursor, 0xff, 1*8); /* pad byte */
+	for (int i=0; i<7; i++)
+		write_bits(bits, cursor, 0xff3fcff3fcffLL, 6*8); /* sync */
+	write_bits(bits, cursor, MAC_SECTOR_RECORD, 3*8);

-    uint8_t encodedTrack = sector->logicalTrack & 0x3f;
-    uint8_t encodedSector = sector->logicalSector;
-    uint8_t encodedSide =
-        encode_side(sector->logicalTrack, sector->logicalSide);
-    uint8_t formatByte = MAC_FORMAT_BYTE;
-    uint8_t headerChecksum =
-        (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
+    uint8_t encodedTrack = sector->physicalTrack & 0x3f;
+	uint8_t encodedSector = sector->logicalSector;
+	uint8_t encodedSide = encode_side(sector->physicalTrack, sector->logicalSide);
+	uint8_t formatByte = MAC_FORMAT_BYTE;
+	uint8_t headerChecksum = (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;

-    write_bits(bits, cursor, encode_data_gcr(encodedTrack), 1 * 8);
-    write_bits(bits, cursor, encode_data_gcr(encodedSector), 1 * 8);
-    write_bits(bits, cursor, encode_data_gcr(encodedSide), 1 * 8);
-    write_bits(bits, cursor, encode_data_gcr(formatByte), 1 * 8);
-    write_bits(bits, cursor, encode_data_gcr(headerChecksum), 1 * 8);
+	write_bits(bits, cursor, encode_data_gcr(encodedTrack), 1*8);
+	write_bits(bits, cursor, encode_data_gcr(encodedSector), 1*8);
+	write_bits(bits, cursor, encode_data_gcr(encodedSide), 1*8);
+	write_bits(bits, cursor, encode_data_gcr(formatByte), 1*8);
+	write_bits(bits, cursor, encode_data_gcr(headerChecksum), 1*8);

-    write_bits(bits, cursor, 0xdeaaff, 3 * 8);
-    write_bits(bits, cursor, 0xff3fcff3fcffLL, 6 * 8); /* sync */
-    write_bits(bits, cursor, MAC_DATA_RECORD, 3 * 8);
-    write_bits(bits, cursor, encode_data_gcr(sector->logicalSector), 1 * 8);
+	write_bits(bits, cursor, 0xdeaaff, 3*8);
+	write_bits(bits, cursor, 0xff3fcff3fcffLL, 6*8); /* sync */
+	write_bits(bits, cursor, MAC_DATA_RECORD, 3*8);
+	write_bits(bits, cursor, encode_data_gcr(sector->logicalSector), 1*8);

-    Bytes wireData;
-    wireData.writer()
-        .append(sector->data.slice(512, 12))
-        .append(sector->data.slice(0, 512));
-    for (uint8_t b : encode_crazy_data(wireData))
-        write_bits(bits, cursor, encode_data_gcr(b), 1 * 8);
+	Bytes wireData;
+	wireData.writer().append(sector->data.slice(512, 12)).append(sector->data.slice(0, 512));
+	for (uint8_t b : encode_crazy_data(wireData))
+		write_bits(bits, cursor, encode_data_gcr(b), 1*8);

-    write_bits(bits, cursor, 0xdeaaff, 3 * 8);
+	write_bits(bits, cursor, 0xdeaaff, 3*8);
 }

-class MacintoshEncoder : public Encoder
+std::unique_ptr<Fluxmap> MacintoshEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
 {
-public:
-    MacintoshEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.macintosh())
-    {
+	if ((physicalTrack < 0) || (physicalTrack >= MAC_TRACKS_PER_DISK))
+		return std::unique_ptr<Fluxmap>();
+
+	double clockRateUs = clockRateUsForTrack(physicalTrack) * clockCompensation;
+	int bitsPerRevolution = 200000.0 / clockRateUs;
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;
+
+    fillBitmapTo(bits, cursor, postIndexGapUs / clockRateUs, { true, false });
+	lastBit = false;
+
+	unsigned numSectors = sectorsForTrack(physicalTrack);
+	for (int sectorId=0; sectorId<numSectors; sectorId++)
+	{
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		write_sector(bits, cursor, sectorData);
    }

-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        double clockRateUs = clockRateUsForTrack(trackInfo->logicalTrack);
-        int bitsPerRevolution = 200000.0 / clockRateUs;
-        std::vector<bool> bits(bitsPerRevolution);
-        unsigned cursor = 0;
+	if (cursor >= bits.size())
+		Error() << fmt::format("track data overrun by {} bits", cursor - bits.size());
+	fillBitmapTo(bits, cursor, bits.size(), { true, false });

-        fillBitmapTo(bits,
-            cursor,
-            _config.post_index_gap_us() / clockRateUs,
-            {true, false});
-        lastBit = false;
-
-        for (const auto& sector : sectors)
-            write_sector(bits, cursor, sector);
-
-        if (cursor >= bits.size())
-            error("track data overrun by {} bits", cursor - bits.size());
-        fillBitmapTo(bits, cursor, bits.size(), {true, false});
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(
-            bits, calculatePhysicalClockPeriod(clockRateUs * 1e3, 200e6));
-        return fluxmap;
-    }
-
-private:
-    const MacintoshEncoderProto& _config;
-};
-
-std::unique_ptr<Encoder> createMacintoshEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new MacintoshEncoder(config));
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(bits, clockRateUs*1e3);
+	return fluxmap;
 }
+
--- a/arch/macintosh/macintosh.h
+++ b/arch/macintosh/macintosh.h
@@ -1,23 +1,48 @@
 #ifndef MACINTOSH_H
 #define MACINTOSH_H

-#define MAC_SECTOR_RECORD 0xd5aa96 /* 1101 0101 1010 1010 1001 0110 */
-#define MAC_DATA_RECORD 0xd5aaad   /* 1101 0101 1010 1010 1010 1101 */
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"

-#define MAC_SECTOR_LENGTH 524 /* yes, really */
+#define MAC_SECTOR_RECORD   0xd5aa96 /* 1101 0101 1010 1010 1001 0110 */
+#define MAC_DATA_RECORD     0xd5aaad /* 1101 0101 1010 1010 1010 1101 */
+
+#define MAC_SECTOR_LENGTH   524 /* yes, really */
 #define MAC_ENCODED_SECTOR_LENGTH 703
-#define MAC_FORMAT_BYTE 0x22
+#define MAC_FORMAT_BYTE     0x22

 #define MAC_TRACKS_PER_DISK 80

-class Encoder;
-class Decoder;
-class DecoderProto;
-class EncoderProto;
+class Sector;
+class Fluxmap;
+class MacintoshDecoderProto;
+class MacintoshEncoderProto;
+
+class MacintoshDecoder : public AbstractDecoder
+{
+public:
+	MacintoshDecoder(const MacintoshDecoderProto&) {}
+    virtual ~MacintoshDecoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+
+	std::set<unsigned> requiredSectors(Track& track) const;
+};
+
+class MacintoshEncoder : public AbstractEncoder
+{
+public:
+	MacintoshEncoder(const MacintoshEncoderProto&) {}
+	virtual ~MacintoshEncoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+};
+
+extern FlagGroup macintoshEncoderFlags;

-extern std::unique_ptr<Decoder> createMacintoshDecoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createMacintoshEncoder(
-    const EncoderProto& config);

 #endif
+
--- a/arch/macintosh/macintosh.proto
+++ b/arch/macintosh/macintosh.proto
@@ -1,11 +1,5 @@
 syntax = "proto2";

-import "lib/config/common.proto";
-
 message MacintoshDecoderProto {}
-
-message MacintoshEncoderProto {
-	optional double post_index_gap_us = 1 [default = 0.0,
-		(help) = "post-index gap before first sector header (microseconds)."];
-}
+message MacintoshEncoderProto {}

--- a/arch/micropolis/decoder.cc
+++ b/arch/micropolis/decoder.cc
@@ -1,295 +1,61 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "micropolis.h"
-#include "lib/core/bytes.h"
+#include "bytes.h"
 #include "fmt/format.h"
-#include "lib/decoders/decoders.pb.h"

-/* The sector has a preamble of MFM 0x00s and uses 0xFF as a sync pattern.
- *
- * 00        00        00        F         F
- * 0000 0000 0000 0000 0000 0000 0101 0101 0101 0101
- * A    A    A    A    A    A    5    5    5    5
- */
-static const FluxPattern SECTOR_SYNC_PATTERN(64, 0xAAAAAAAAAAAA5555LL);
+/* The sector has a preamble of MFM 0x00s and uses 0xFF as a sync pattern. */
+static const FluxPattern SECTOR_SYNC_PATTERN(32, 0xaaaa5555);

-/* Pattern to skip past current SYNC. */
-static const FluxPattern SECTOR_ADVANCE_PATTERN(64, 0xAAAAAAAAAAAAAAAALL);
-
-/* Standard Micropolis checksum.  Adds all bytes, with carry. */
-uint8_t micropolisChecksum(const Bytes& bytes)
+AbstractDecoder::RecordType MicropolisDecoder::advanceToNextRecord()
 {
-    ByteReader br(bytes);
-    uint16_t sum = 0;
-    while (!br.eof())
-    {
-        if (sum > 0xFF)
-        {
-            sum -= 0x100 - 1;
-        }
-        sum += br.read_8();
-    }
-    /* The last carry is ignored */
-    return sum & 0xFF;
+	_fmr->seekToIndexMark();
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(SECTOR_SYNC_PATTERN, matcher);
+	if (matcher == &SECTOR_SYNC_PATTERN) {
+		readRawBits(16);
+		return SECTOR_RECORD;
+	}
+	return UNKNOWN_RECORD;
 }

-/* Vector MZOS does not use the standard Micropolis checksum.
- * The checksum is initially 0.
- * For each data byte in the 256-byte payload, rotate left,
- * carrying bit 7 to bit 0.  XOR with the current checksum.
- *
- * Unlike the Micropolis checksum, this does not cover the 12-byte
- * header (track, sector, 10 OS-specific bytes.)
- */
-uint8_t mzosChecksum(const Bytes& bytes)
-{
-    ByteReader br(bytes);
-    uint8_t checksum = 0;
-    uint8_t databyte;
-
-    while (!br.eof())
-    {
-        databyte = br.read_8();
-        checksum ^= ((databyte << 1) | (databyte >> 7));
-    }
-
-    return checksum;
+/* Adds all bytes, with carry. */
+static uint8_t checksum(const Bytes& bytes) {
+	ByteReader br(bytes);
+	uint16_t sum = 0;
+	while (!br.eof()) {
+		if (sum > 0xFF) {
+			sum -= 0x100 - 1;
+		}
+		sum += br.read_8();
+	}
+	/* The last carry is ignored */
+	return sum & 0xFF;
 }

-static uint8_t b(uint32_t field, uint8_t pos)
+void MicropolisDecoder::decodeSectorRecord()
 {
-    return (field >> pos) & 1;
-}
-
-static uint8_t eccNextBit(uint32_t ecc, uint8_t data_bit)
-{
-    // This is 0x81932080 which is 0x0104C981 with reversed bits
-    return b(ecc, 7) ^ b(ecc, 13) ^ b(ecc, 16) ^ b(ecc, 17) ^ b(ecc, 20) ^
-           b(ecc, 23) ^ b(ecc, 24) ^ b(ecc, 31) ^ data_bit;
-}
-
-uint32_t vectorGraphicEcc(const Bytes& bytes)
-{
-    uint32_t e = 0;
-    Bytes payloadBytes = bytes.slice(0, bytes.size() - 4);
-    ByteReader payload(payloadBytes);
-    while (!payload.eof())
-    {
-        uint8_t byte = payload.read_8();
-        for (int i = 0; i < 8; i++)
-        {
-            e = (e << 1) | eccNextBit(e, byte >> 7);
-            byte <<= 1;
-        }
-    }
-    Bytes trailerBytes = bytes.slice(bytes.size() - 4);
-    ByteReader trailer(trailerBytes);
-    uint32_t res = e;
-    while (!trailer.eof())
-    {
-        uint8_t byte = trailer.read_8();
-        for (int i = 0; i < 8; i++)
-        {
-            res = (res << 1) | eccNextBit(e, byte >> 7);
-            e <<= 1;
-            byte <<= 1;
-        }
-    }
-    return res;
-}
-
-/* Fixes bytes when possible, returning true if changed. */
-static bool vectorGraphicEccFix(Bytes& bytes, uint32_t syndrome)
-{
-    uint32_t ecc = syndrome;
-    int pos = (MICROPOLIS_ENCODED_SECTOR_SIZE - 5) * 8 + 7;
-    bool aligned = false;
-    while ((ecc & 0xff000000) == 0)
-    {
-        pos += 8;
-        ecc <<= 8;
-    }
-    for (; pos >= 0; pos--)
-    {
-        bool bit = ecc & 1;
-        ecc >>= 1;
-        if (bit)
-            ecc ^= 0x808264c0;
-        if ((ecc & 0xff07ffff) == 0)
-            aligned = true;
-        if (aligned && pos % 8 == 0)
-            break;
-    }
-    if (pos < 0)
-        return false;
-    bytes[pos / 8] ^= ecc >> 16;
-    return true;
-}
-
-class MicropolisDecoder : public Decoder
-{
-public:
-    MicropolisDecoder(const DecoderProto& config):
-        Decoder(config),
-        _config(config.micropolis())
-    {
-        _checksumType = _config.checksum_type();
-    }
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        nanoseconds_t now = tell().ns();
-
-        /* For all but the first sector, seek to the next sector pulse.
-         * The first sector does not contain the sector pulse in the fluxmap.
-         */
-        if (now != 0)
-        {
-            seekToIndexMark();
-            now = tell().ns();
-        }
-
-        /* Discard a possible partial sector at the end of the track.
-         * This partial sector could be mistaken for a conflicted sector, if
-         * whatever data read happens to match the checksum of 0, which is
-         * rare, but has been observed on some disks. There's 570uS of slack in
-         * each sector, after accounting for preamble, data, and postamble.
-         */
-        if (now > (getFluxmapDuration() - 12.0e6))
-        {
-            seekToIndexMark();
-            return 0;
-        }
-
-        nanoseconds_t clock = seekToPattern(SECTOR_SYNC_PATTERN);
-
-        auto syncDelta = tell().ns() - now;
-        /* Due to the weak nature of the Micropolis SYNC patern,
-         * it's possible to detect a false SYNC during the gap
-         * between the sector pulse and the write gate.  If the SYNC
-         * is detected less than 100uS after the sector pulse, search
-         * for another valid SYNC.
-         *
-         * Reference: Vector Micropolis Disk Controller Board Technical
-         * Information Manual, pp. 1-16.
-         */
-        if ((syncDelta > 0) && (syncDelta < 100e3))
-        {
-            seekToPattern(SECTOR_ADVANCE_PATTERN);
-            clock = seekToPattern(SECTOR_SYNC_PATTERN);
-        }
-
-        _sector->headerStartTime = tell().ns();
-
-        /* seekToPattern() can skip past the index hole, if this happens
-         * too close to the end of the Fluxmap, discard the sector. The
-         * preamble was expected to be 640uS long.
-         */
-        if (_sector->headerStartTime > (getFluxmapDuration() - 11.3e6))
-        {
-            return 0;
-        }
-
-        return clock;
-    }
-
-    void decodeSectorRecord() override
-    {
-        readRawBits(48);
-        auto rawbits = readRawBits(MICROPOLIS_ENCODED_SECTOR_SIZE * 16);
-        auto bytes =
-            decodeFmMfm(rawbits).slice(0, MICROPOLIS_ENCODED_SECTOR_SIZE);
-
-        bool eccPresent = bytes[274] == 0xaa;
-        uint32_t ecc = 0;
-        if (_config.ecc_type() == MicropolisDecoderProto::VECTOR && eccPresent)
-        {
-            ecc = vectorGraphicEcc(bytes.slice(0, 274));
-            if (ecc != 0)
-            {
-                vectorGraphicEccFix(bytes, ecc);
-                ecc = vectorGraphicEcc(bytes.slice(0, 274));
-            }
-        }
-
-        ByteReader br(bytes);
-
-        int syncByte = br.read_8(); /* sync */
-        if (syncByte != 0xFF)
-            return;
-
-        _sector->logicalTrack = br.read_8();
-        _sector->logicalSide = _sector->physicalSide;
-        _sector->logicalSector = br.read_8();
-        if (_sector->logicalSector > 15)
-            return;
-        if (_sector->logicalTrack > 76)
-            return;
-        if (_sector->logicalTrack != _sector->physicalTrack)
-            return;
-
-        br.read(10); /* OS data or padding */
-        auto data = br.read(MICROPOLIS_PAYLOAD_SIZE);
-        uint8_t wantChecksum = br.read_8();
-
-        /* If not specified, automatically determine the checksum type.
-         * Once the checksum type is determined, it will be used for the
-         * entire disk.
-         */
-        if (_checksumType == MicropolisDecoderProto::AUTO)
-        {
-            /* Calculate both standard Micropolis (MDOS, CP/M, OASIS) and MZOS
-             * checksums */
-            if (wantChecksum == micropolisChecksum(bytes.slice(1, 2 + 266)))
-            {
-                _checksumType = MicropolisDecoderProto::MICROPOLIS;
-            }
-            else if (wantChecksum ==
-                     mzosChecksum(bytes.slice(
-                         MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE)))
-            {
-                _checksumType = MicropolisDecoderProto::MZOS;
-                std::cout << "Note: MZOS checksum detected." << std::endl;
-            }
-        }
-
-        uint8_t gotChecksum;
-
-        if (_checksumType == MicropolisDecoderProto::MZOS)
-        {
-            gotChecksum = mzosChecksum(
-                bytes.slice(MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE));
-        }
-        else
-        {
-            gotChecksum = micropolisChecksum(bytes.slice(1, 2 + 266));
-        }
-
-        br.read(5); /* 4 byte ECC and ECC-present flag */
-
-        if (_config.sector_output_size() == MICROPOLIS_PAYLOAD_SIZE)
-            _sector->data = data;
-        else if (_config.sector_output_size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
-            _sector->data = bytes;
-        else
-            error("Sector output size may only be 256 or 275");
-        if (wantChecksum == gotChecksum && (!eccPresent || ecc == 0))
-            _sector->status = Sector::OK;
-        else
-            _sector->status = Sector::BAD_CHECKSUM;
-    }
-
-private:
-    const MicropolisDecoderProto& _config;
-    MicropolisDecoderProto_ChecksumType
-        _checksumType; /* -1 = auto, 1 = Micropolis, 2=MZOS */
-};
-
-std::unique_ptr<Decoder> createMicropolisDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new MicropolisDecoder(config));
+	auto rawbits = readRawBits(MICROPOLIS_ENCODED_SECTOR_SIZE*16);
+	auto bytes = decodeFmMfm(rawbits).slice(0, MICROPOLIS_ENCODED_SECTOR_SIZE);
+	ByteReader br(bytes);
+
+	br.read_8();  /* sync */
+	_sector->logicalTrack = br.read_8();
+	_sector->logicalSide = _sector->physicalSide;
+	_sector->logicalSector = br.read_8();
+	if (_sector->logicalSector > 15)
+		return;
+	if (_sector->logicalTrack > 77)
+		return;
+
+	br.read(10);  /* OS data or padding */
+	_sector->data = br.read(256);
+	uint8_t wantChecksum = br.read_8();
+	uint8_t gotChecksum = checksum(bytes.slice(1, 2+266));
+	br.read(5);  /* 4 byte ECC and ECC-present flag */
+
+	_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/micropolis/encoder.cc
+++ b/arch/micropolis/encoder.cc
@@ -1,136 +0,0 @@
-#include "lib/core/globals.h"
-#include "micropolis.h"
-#include "lib/data/sector.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "lib/data/image.h"
-#include "lib/encoders/encoders.pb.h"
-
-static void write_sector(std::vector<bool>& bits,
-    unsigned& cursor,
-    const std::shared_ptr<const Sector>& sector,
-    MicropolisEncoderProto::EccType eccType)
-{
-    if ((sector->data.size() != 256) &&
-        (sector->data.size() != MICROPOLIS_ENCODED_SECTOR_SIZE))
-        error("unsupported sector size --- you must pick 256 or 275");
-
-    int fullSectorSize = 40 + MICROPOLIS_ENCODED_SECTOR_SIZE + 40 + 35;
-    auto fullSector = std::make_shared<std::vector<uint8_t>>();
-    fullSector->reserve(fullSectorSize);
-    /* sector preamble */
-    for (int i = 0; i < 40; i++)
-        fullSector->push_back(0);
-    Bytes sectorData;
-    if (sector->data.size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
-    {
-        if (sector->data[0] != 0xFF)
-            error(
-                "275 byte sector doesn't start with sync byte 0xFF. "
-                "Corrupted sector");
-        uint8_t wantChecksum = sector->data[1 + 2 + 266];
-        uint8_t gotChecksum =
-            micropolisChecksum(sector->data.slice(1, 2 + 266));
-        if (wantChecksum != gotChecksum)
-            std::cerr << "Warning: checksum incorrect. Sector: "
-                      << sector->logicalSector << std::endl;
-        sectorData = sector->data;
-    }
-    else
-    {
-        ByteWriter writer(sectorData);
-        writer.write_8(0xff); /* Sync */
-        writer.write_8(sector->logicalTrack);
-        writer.write_8(sector->logicalSector);
-        for (int i = 0; i < 10; i++)
-            writer.write_8(0); /* Padding */
-        writer += sector->data;
-        writer.write_8(micropolisChecksum(sectorData.slice(1)));
-
-        uint8_t eccPresent = 0;
-        uint32_t ecc = 0;
-        if (eccType == MicropolisEncoderProto::VECTOR)
-        {
-            eccPresent = 0xaa;
-            ecc = vectorGraphicEcc(sectorData + Bytes(4));
-        }
-        writer.write_be32(ecc);
-        writer.write_8(eccPresent);
-    }
-    for (uint8_t b : sectorData)
-        fullSector->push_back(b);
-    /* sector postamble */
-    for (int i = 0; i < 40; i++)
-        fullSector->push_back(0);
-    /* filler */
-    for (int i = 0; i < 35; i++)
-        fullSector->push_back(0);
-
-    if (fullSector->size() != fullSectorSize)
-        error("sector mismatched length");
-    bool lastBit = false;
-    encodeMfm(bits, cursor, fullSector, lastBit);
-    /* filler */
-    for (int i = 0; i < 5; i++)
-    {
-        bits[cursor++] = 1;
-        bits[cursor++] = 0;
-    }
-}
-
-class MicropolisEncoder : public Encoder
-{
-public:
-    MicropolisEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.micropolis())
-    {
-    }
-
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        int bitsPerRevolution =
-            (_config.rotational_period_ms() * 1e3) / _config.clock_period_us();
-
-        std::vector<bool> bits(bitsPerRevolution);
-        std::vector<unsigned> indexes;
-        unsigned prev_cursor = 0;
-        unsigned cursor = 0;
-
-        for (const auto& sectorData : sectors)
-        {
-            indexes.push_back(cursor);
-            prev_cursor = cursor;
-            write_sector(bits, cursor, sectorData, _config.ecc_type());
-        }
-        indexes.push_back(prev_cursor + (cursor - prev_cursor) / 2);
-        indexes.push_back(cursor);
-
-        if (cursor != bits.size())
-            error("track data mismatched length");
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        nanoseconds_t clockPeriod =
-            calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
-                _config.rotational_period_ms() * 1e6);
-        auto pos = bits.begin();
-        for (int i = 1; i < indexes.size(); i++)
-        {
-            auto end = bits.begin() + indexes[i];
-            fluxmap->appendBits(std::vector<bool>(pos, end), clockPeriod);
-            fluxmap->appendIndex();
-            pos = end;
-        }
-        return fluxmap;
-    }
-
-private:
-    const MicropolisEncoderProto& _config;
-};
-
-std::unique_ptr<Encoder> createMicropolisEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new MicropolisEncoder(config));
-}
--- a/arch/micropolis/micropolis.h
+++ b/arch/micropolis/micropolis.h
@@ -1,22 +1,20 @@
 #ifndef MICROPOLIS_H
 #define MICROPOLIS_H

-#define MICROPOLIS_PAYLOAD_SIZE (256)
-#define MICROPOLIS_HEADER_SIZE (1 + 2 + 10)
-#define MICROPOLIS_ENCODED_SECTOR_SIZE \
-    (MICROPOLIS_HEADER_SIZE + MICROPOLIS_PAYLOAD_SIZE + 6)
+#define MICROPOLIS_ENCODED_SECTOR_SIZE (1+2+266+6)

-class Decoder;
-class Encoder;
-class EncoderProto;
-class DecoderProto;
+class Sector;
+class Fluxmap;
+class MicropolisDecoderProto;

-extern std::unique_ptr<Decoder> createMicropolisDecoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createMicropolisEncoder(
-    const EncoderProto& config);
+class MicropolisDecoder : public AbstractDecoder
+{
+public:
+	MicropolisDecoder(const MicropolisDecoderProto&) {}
+	virtual ~MicropolisDecoder() {}

-extern uint8_t micropolisChecksum(const Bytes& bytes);
-extern uint32_t vectorGraphicEcc(const Bytes& bytes);
+	RecordType advanceToNextRecord();
+	void decodeSectorRecord();
+};

 #endif
--- a/arch/micropolis/micropolis.proto
+++ b/arch/micropolis/micropolis.proto
@@ -1,37 +1,4 @@
 syntax = "proto2";

-import "lib/config/common.proto";
-
-message MicropolisDecoderProto {
-	enum ChecksumType {
-		AUTO = 0;
-		MICROPOLIS = 1;
-		MZOS = 2;
-	}
-	enum EccType {
-		NONE = 0;
-		VECTOR = 1;
-	}
-
-	optional int32 sector_output_size = 1 [default = 256,
-		(help) = "How much of the raw sector should be saved. Must be 256 or 275"];
-	optional ChecksumType checksum_type = 2 [default = AUTO,
-		(help) = "Checksum type to use: AUTO, MICROPOLIS, MZOS"];
-	optional EccType ecc_type = 3 [default = NONE,
-		(help) = "ECC type to use: NONE, VECTOR"];
-}
-
-message MicropolisEncoderProto {
-    enum EccType {
-        NONE = 0;
-        VECTOR = 1;
-    }
-
-    optional double clock_period_us = 1
-        [ default = 2.0, (help) = "clock rate on the real device" ];
-    optional double rotational_period_ms = 2
-        [ default = 200.0, (help) = "rotational period on the real device" ];
-    optional EccType ecc_type = 3 [default = NONE,
-        (help) = "ECC type to use for IMG data: NONE, VECTOR"];
-}
+message MicropolisDecoderProto {}

--- a/arch/mx/decoder.cc
+++ b/arch/mx/decoder.cc
@@ -1,11 +1,12 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "arch/mx/mx.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "mx/mx.h"
+#include "crc.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "sector.h"
+#include "record.h"
+#include "track.h"
 #include <string.h>

 const int SECTOR_SIZE = 256;
@@ -17,68 +18,58 @@ const int SECTOR_SIZE = 256;
 */

 /* FM beginning of track marker:
- *         0         0         f         3 decoded nibbles
- *  0 0  0 0  0 0  0 0  1 1  1 1  0 0  1 1
 * 1010 1010 1010 1010 1111 1111 1010 1111
- *    a    a    a    a    f    f    a    f encoded nibbles
+ *    a    a    a    a    f    f    a    f
 */
 const FluxPattern ID_PATTERN(32, 0xaaaaffaf);

-class MxDecoder : public Decoder
+void MxDecoder::beginTrack()
 {
-public:
-    MxDecoder(const DecoderProto& config): Decoder(config) {}
-
-    void beginTrack() override
-    {
-        _clock = _sector->clock = seekToPattern(ID_PATTERN);
-        _currentSector = 0;
-    }
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        if (_currentSector == 11)
-        {
-            /* That was the last sector on the disk. */
-            return 0;
-        }
-        else
-            return _clock;
-    }
-
-    void decodeSectorRecord() override
-    {
-        /* Skip the ID pattern and track word, which is only present on the
-         * first sector. We don't trust the track word because some driver
-         * don't write it correctly. */
-
-        if (_currentSector == 0)
-            readRawBits(64);
-
-        auto bits = readRawBits((SECTOR_SIZE + 2) * 16);
-        auto bytes = decodeFmMfm(bits).slice(0, SECTOR_SIZE + 2);
-
-        uint16_t gotChecksum = 0;
-        ByteReader br(bytes);
-        for (int i = 0; i < (SECTOR_SIZE / 2); i++)
-            gotChecksum += br.read_be16();
-        uint16_t wantChecksum = br.read_be16();
-
-        _sector->logicalTrack = _sector->physicalTrack;
-        _sector->logicalSide = _sector->physicalSide;
-        _sector->logicalSector = _currentSector;
-        _sector->data = bytes.slice(0, SECTOR_SIZE).swab();
-        _sector->status =
-            (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-        _currentSector++;
-    }
-
-private:
-    nanoseconds_t _clock;
-    int _currentSector;
-};
-
-std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new MxDecoder(config));
+    _currentSector = -1;
+    _clock = 0;
+}
+
+AbstractDecoder::RecordType MxDecoder::advanceToNextRecord()
+{
+    if (_currentSector == -1)
+    {
+        /* First sector in the track: look for the sync marker. */
+        const FluxMatcher* matcher = nullptr;
+        _sector->clock = _clock = _fmr->seekToPattern(ID_PATTERN, matcher);
+        readRawBits(32); /* skip the ID mark */
+        _logicalTrack = decodeFmMfm(readRawBits(32)).slice(0, 32).reader().read_be16();
+    }
+    else if (_currentSector == 10)
+    {
+        /* That was the last sector on the disk. */
+        return UNKNOWN_RECORD;
+    }
+    else
+    {
+        /* Otherwise we assume the clock from the first sector is still valid.
+         * The decoder framwork will automatically stop when we hit the end of
+         * the track. */
+        _sector->clock = _clock;
+    }
+
+    _currentSector++;
+    return SECTOR_RECORD;
+}
+
+void MxDecoder::decodeSectorRecord()
+{
+    auto bits = readRawBits((SECTOR_SIZE+2)*16);
+    auto bytes = decodeFmMfm(bits).slice(0, SECTOR_SIZE+2).swab();
+
+    uint16_t gotChecksum = 0;
+    ByteReader br(bytes);
+    for (int i=0; i<(SECTOR_SIZE/2); i++)
+        gotChecksum += br.read_le16();
+    uint16_t wantChecksum = br.read_le16();
+
+    _sector->logicalTrack = _logicalTrack;
+    _sector->logicalSide = _track->physicalSide;
+    _sector->logicalSector = _currentSector;
+    _sector->data = bytes.slice(0, SECTOR_SIZE);
+    _sector->status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/mx/mx.h
+++ b/arch/mx/mx.h
@@ -1,8 +1,24 @@
 #ifndef MX_H
 #define MX_H

-#include "lib/decoders/decoders.h"
+#include "decoders/decoders.h"

-extern std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config);
+class MxDecoderProto;
+
+class MxDecoder : public AbstractDecoder
+{
+public:
+	MxDecoder(const MxDecoderProto&) {}
+    virtual ~MxDecoder() {}
+
+    void beginTrack();
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+
+private:
+    nanoseconds_t _clock;
+    int _currentSector;
+    int _logicalTrack;
+};

 #endif
--- a/arch/northstar/decoder.cc
+++ b/arch/northstar/decoder.cc
@@ -11,19 +11,15 @@
 * sure that the hardSectorId is correct.
 */

-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "northstar.h"
-#include "lib/core/bytes.h"
-#include "lib/decoders/decoders.pb.h"
+#include "bytes.h"
 #include "fmt/format.h"

-#define MFM_ID 0xaaaaaaaaaaaa5545LL
-#define FM_ID 0xaaaaaaaaaaaaffefLL
 /*
 * MFM sectors have 32 bytes of 00's followed by two sync characters,
 * specified in the North Star MDS manual as 0xFBFB.
@@ -36,152 +32,144 @@
 * 0000 0000 0000 0000 0000 0000 0101 0101 0100 0101
 * A    A    A    A    A    A    5    5    4    5
 */
-static const FluxPattern MFM_PATTERN(64, MFM_ID);
+static const FluxPattern MFM_PATTERN(64, 0xAAAAAAAAAAAA5545LL);

 /* FM sectors have 16 bytes of 00's followed by 0xFB.
 * 00        FB
 * 0000 0000 1111 1111 1110 1111
 * A    A    F    F    E    F
 */
-static const FluxPattern FM_PATTERN(64, FM_ID);
+static const FluxPattern FM_PATTERN(64, 0xAAAAAAAAAAAAFFEFLL);

-const FluxMatchers ANY_SECTOR_PATTERN({
-    &MFM_PATTERN,
-    &FM_PATTERN,
-});
+const FluxMatchers ANY_SECTOR_PATTERN(
+	{
+		&MFM_PATTERN,
+		&FM_PATTERN,
+	}
+);
+
+/* Search for FM or MFM sector record */
+AbstractDecoder::RecordType NorthstarDecoder::advanceToNextRecord()
+{
+	nanoseconds_t now = _fmr->tell().ns();
+
+	/* For all but the first sector, seek to the next sector pulse.
+	 * The first sector does not contain the sector pulse in the fluxmap.
+	 */
+	if (now != 0) {
+		_fmr->seekToIndexMark();
+		now = _fmr->tell().ns();
+	}
+
+	/* Discard a possible partial sector at the end of the track.
+	 * This partial sector could be mistaken for a conflicted sector, if
+	 * whatever data read happens to match the checksum of 0, which is
+	 * rare, but has been observed on some disks.
+	 */
+	if (now > (_fmr->getDuration() - 21e6)) {
+		_fmr->seekToIndexMark();
+		return(UNKNOWN_RECORD);
+	}
+
+	int msSinceIndex = std::round(now / 1e6);
+
+	const FluxMatcher* matcher = nullptr;
+
+	/* Note that the seekToPattern ignores the sector pulses, so if
+	 * a sector is not found for some reason, the seek will advance
+	 * past one or more sector pulses.  For this reason, calculate
+	 * _hardSectorId after the sector header is found.
+	 */
+	_sector->clock = _fmr->seekToPattern(ANY_SECTOR_PATTERN, matcher);
+
+	int sectorFoundTimeRaw = std::round((_fmr->tell().ns()) / 1e6);
+	int sectorFoundTime;
+
+	/* Round time to the nearest 20ms */
+	if ((sectorFoundTimeRaw % 20) < 10) {
+		sectorFoundTime = (sectorFoundTimeRaw / 20) * 20;
+	}
+	else {
+		sectorFoundTime = ((sectorFoundTimeRaw + 20) / 20) * 20;
+	}
+
+	/* Calculate the sector ID based on time since the index */
+	_hardSectorId = (sectorFoundTime / 20) % 10;
+
+//	std::cout << fmt::format(
+//		"Sector ID {}: hole at {}ms, sector start at {}ms",
+//		_hardSectorId, msSinceIndex, sectorFoundTimeRaw) << std::endl;
+
+	if (matcher == &MFM_PATTERN) {
+		_sectorType = SECTOR_TYPE_MFM;
+		readRawBits(48);
+		return SECTOR_RECORD;
+	}
+
+	if (matcher == &FM_PATTERN) {
+		_sectorType = SECTOR_TYPE_FM;
+		readRawBits(48);
+		return SECTOR_RECORD;
+	}
+
+	return UNKNOWN_RECORD;
+}

 /* Checksum is initially 0.
 * For each data byte, XOR with the current checksum.
 * Rotate checksum left, carrying bit 7 to bit 0.
 */
-uint8_t northstarChecksum(const Bytes& bytes)
-{
-    ByteReader br(bytes);
-    uint8_t checksum = 0;
+uint8_t northstarChecksum(const Bytes& bytes) {
+	ByteReader br(bytes);
+	uint8_t checksum = 0;

-    while (!br.eof())
-    {
-        checksum ^= br.read_8();
-        checksum = ((checksum << 1) | ((checksum >> 7)));
-    }
+	while (!br.eof()) {
+		checksum ^= br.read_8();
+		checksum = ((checksum << 1) | ((checksum >> 7)));
+	}

-    return checksum;
+	return checksum;
 }

-class NorthstarDecoder : public Decoder
+void NorthstarDecoder::decodeSectorRecord()
 {
-public:
-    NorthstarDecoder(const DecoderProto& config):
-        Decoder(config),
-        _config(config.northstar())
-    {
-    }
+	unsigned recordSize, payloadSize, headerSize;

-    /* Search for FM or MFM sector record */
-    nanoseconds_t advanceToNextRecord() override
-    {
-        nanoseconds_t now = tell().ns();
+	if (_sectorType == SECTOR_TYPE_MFM) {
+		recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_DD;
+		payloadSize = NORTHSTAR_PAYLOAD_SIZE_DD;
+		headerSize = NORTHSTAR_HEADER_SIZE_DD;
+	}
+	else {
+		recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_SD;
+		payloadSize = NORTHSTAR_PAYLOAD_SIZE_SD;
+		headerSize = NORTHSTAR_HEADER_SIZE_SD;
+	}

-        /* For all but the first sector, seek to the next sector pulse.
-         * The first sector does not contain the sector pulse in the fluxmap.
-         */
-        if (now != 0)
-        {
-            seekToIndexMark();
-            now = tell().ns();
-        }
+	auto rawbits = readRawBits(recordSize * 16);
+	auto bytes = decodeFmMfm(rawbits).slice(0, recordSize);
+	ByteReader br(bytes);
+	uint8_t sync_char;

-        /* Discard a possible partial sector at the end of the track.
-         * This partial sector could be mistaken for a conflicted sector, if
-         * whatever data read happens to match the checksum of 0, which is
-         * rare, but has been observed on some disks.
-         */
-        if (now > (getFluxmapDuration() - 21e6))
-        {
-            seekToIndexMark();
-            return 0;
-        }
+	_sector->logicalSide = _sector->physicalSide;
+	_sector->logicalSector = _hardSectorId;
+	_sector->logicalTrack = _sector->physicalTrack;

-        int msSinceIndex = std::round(now / 1e6);
+	sync_char = br.read_8();	/* Sync char: 0xFB */
+	if (_sectorType == SECTOR_TYPE_MFM) {
+		sync_char = br.read_8();/* MFM second Sync char, usually 0xFB */
+	}

-        /* Note that the seekToPattern ignores the sector pulses, so if
-         * a sector is not found for some reason, the seek will advance
-         * past one or more sector pulses.  For this reason, calculate
-         * _hardSectorId after the sector header is found.
-         */
-        nanoseconds_t clock = seekToPattern(ANY_SECTOR_PATTERN);
-        _sector->headerStartTime = tell().ns();
+	_sector->data = br.read(payloadSize);

-        /* Discard a possible partial sector. */
-        if (_sector->headerStartTime > (getFluxmapDuration() - 21e6))
-        {
-            return 0;
-        }
+	uint8_t wantChecksum = br.read_8();
+	uint8_t gotChecksum = northstarChecksum(bytes.slice(headerSize, payloadSize));

-        int sectorFoundTimeRaw = std::round(_sector->headerStartTime / 1e6);
-        int sectorFoundTime;
-
-        /* Round time to the nearest 20ms */
-        if ((sectorFoundTimeRaw % 20) < 10)
-        {
-            sectorFoundTime = (sectorFoundTimeRaw / 20) * 20;
-        }
-        else
-        {
-            sectorFoundTime = ((sectorFoundTimeRaw + 20) / 20) * 20;
-        }
-
-        /* Calculate the sector ID based on time since the index */
-        _hardSectorId = (sectorFoundTime / 20) % 10;
-
-        return clock;
-    }
-
-    void decodeSectorRecord() override
-    {
-        uint64_t id = toBytes(readRawBits(64)).reader().read_be64();
-        unsigned recordSize, payloadSize, headerSize;
-
-        if (id == MFM_ID)
-        {
-            recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_DD;
-            payloadSize = NORTHSTAR_PAYLOAD_SIZE_DD;
-            headerSize = NORTHSTAR_HEADER_SIZE_DD;
-        }
-        else
-        {
-            recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_SD;
-            payloadSize = NORTHSTAR_PAYLOAD_SIZE_SD;
-            headerSize = NORTHSTAR_HEADER_SIZE_SD;
-        }
-
-        auto rawbits = readRawBits(recordSize * 16);
-        auto bytes = decodeFmMfm(rawbits).slice(0, recordSize);
-        ByteReader br(bytes);
-
-        _sector->logicalSide = _sector->physicalSide;
-        _sector->logicalSector = _hardSectorId;
-        _sector->logicalTrack = _sector->physicalTrack;
-
-        if (headerSize == NORTHSTAR_HEADER_SIZE_DD)
-        {
-            br.read_8(); /* MFM second Sync char, usually 0xFB */
-        }
-
-        _sector->data = br.read(payloadSize);
-        uint8_t wantChecksum = br.read_8();
-        uint8_t gotChecksum =
-            northstarChecksum(bytes.slice(headerSize - 1, payloadSize));
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-
-private:
-    const NorthstarDecoderProto& _config;
-    uint8_t _hardSectorId;
-};
-
-std::unique_ptr<Decoder> createNorthstarDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new NorthstarDecoder(config));
+	_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+}
+
+std::set<unsigned> NorthstarDecoder::requiredSectors(Track& track) const
+{
+	static std::set<unsigned> sectors = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	return sectors;
 }
--- a/arch/northstar/encoder.cc
+++ b/arch/northstar/encoder.cc
@@ -1,168 +1,130 @@
-#include "lib/core/globals.h"
+#include "globals.h"
 #include "northstar.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "lib/data/image.h"
-#include "lib/encoders/encoders.pb.h"
+#include "sectorset.h"

 #define GAP_FILL_SIZE_SD 30
 #define PRE_HEADER_GAP_FILL_SIZE_SD 9
 #define GAP_FILL_SIZE_DD 62
 #define PRE_HEADER_GAP_FILL_SIZE_DD 16

-#define GAP1_FILL_BYTE (0x4F)
-#define GAP2_FILL_BYTE (0x4F)
+#define GAP1_FILL_BYTE	(0x4F)
+#define GAP2_FILL_BYTE	(0x4F)

 #define TOTAL_SECTOR_BYTES ()

-static void write_sector(std::vector<bool>& bits,
-    unsigned& cursor,
-    const std::shared_ptr<const Sector>& sector)
+static void write_sector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector)
 {
-    int preambleSize = 0;
-    int encodedSectorSize = 0;
-    int gapFillSize = 0;
-    int preHeaderGapFillSize = 0;
+	int preambleSize = 0;
+	int encodedSectorSize = 0;
+	int gapFillSize = 0;
+	int preHeaderGapFillSize = 0;

-    bool doubleDensity;
+	bool doubleDensity;

-    switch (sector->data.size())
-    {
-        case NORTHSTAR_PAYLOAD_SIZE_SD:
-            preambleSize = NORTHSTAR_PREAMBLE_SIZE_SD;
-            encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_SD +
-                                NORTHSTAR_ENCODED_SECTOR_SIZE_SD +
-                                GAP_FILL_SIZE_SD;
-            gapFillSize = GAP_FILL_SIZE_SD;
-            preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_SD;
-            doubleDensity = false;
-            break;
-        case NORTHSTAR_PAYLOAD_SIZE_DD:
-            preambleSize = NORTHSTAR_PREAMBLE_SIZE_DD;
-            encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_DD +
-                                NORTHSTAR_ENCODED_SECTOR_SIZE_DD +
-                                GAP_FILL_SIZE_DD;
-            gapFillSize = GAP_FILL_SIZE_DD;
-            preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_DD;
-            doubleDensity = true;
-            break;
-        default:
-            error("unsupported sector size --- you must pick 256 or 512");
-            break;
-    }
+	switch (sector->data.size()) {
+	case NORTHSTAR_PAYLOAD_SIZE_SD:
+		preambleSize = NORTHSTAR_PREAMBLE_SIZE_SD;
+		encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_SD + NORTHSTAR_ENCODED_SECTOR_SIZE_SD + GAP_FILL_SIZE_SD;
+		gapFillSize = GAP_FILL_SIZE_SD;
+		preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_SD;
+		doubleDensity = false;
+		break;
+	case NORTHSTAR_PAYLOAD_SIZE_DD:
+		preambleSize = NORTHSTAR_PREAMBLE_SIZE_DD;
+		encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_DD + NORTHSTAR_ENCODED_SECTOR_SIZE_DD + GAP_FILL_SIZE_DD;
+		gapFillSize = GAP_FILL_SIZE_DD;
+		preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_DD;
+		doubleDensity = true;
+		break;
+	default:
+		Error() << "unsupported sector size --- you must pick 256 or 512";
+		break;
+	}

-    int fullSectorSize = preambleSize + encodedSectorSize;
-    auto fullSector = std::make_shared<std::vector<uint8_t>>();
-    fullSector->reserve(fullSectorSize);
+	int fullSectorSize = preambleSize + encodedSectorSize;
+	auto fullSector = std::make_shared<std::vector<uint8_t>>();
+	fullSector->reserve(fullSectorSize);

-    /* sector gap after index pulse */
-    for (int i = 0; i < preHeaderGapFillSize; i++)
-        fullSector->push_back(GAP1_FILL_BYTE);
+	/* sector gap after index pulse */
+	for (int i = 0; i < preHeaderGapFillSize; i++)
+		fullSector->push_back(GAP1_FILL_BYTE);

-    /* sector preamble */
-    for (int i = 0; i < preambleSize; i++)
-        fullSector->push_back(0);
+	/* sector preamble */
+	for (int i = 0; i < preambleSize; i++)
+		fullSector->push_back(0);

-    Bytes sectorData;
-    if (sector->data.size() == encodedSectorSize)
-        sectorData = sector->data;
-    else
-    {
-        ByteWriter writer(sectorData);
-        writer.write_8(0xFB); /* sync character */
-        if (doubleDensity == true)
-        {
-            writer.write_8(0xFB); /* Double-density has two sync characters */
-        }
-        writer += sector->data;
-        if (doubleDensity == true)
-        {
-            writer.write_8(northstarChecksum(sectorData.slice(2)));
-        }
-        else
-        {
-            writer.write_8(northstarChecksum(sectorData.slice(1)));
-        }
-    }
-    for (uint8_t b : sectorData)
-        fullSector->push_back(b);
+	Bytes sectorData;
+	if (sector->data.size() == encodedSectorSize)
+		sectorData = sector->data;
+	else {
+		ByteWriter writer(sectorData);
+		writer.write_8(0xFB);     /* sync character */
+		if (doubleDensity == true) {
+			writer.write_8(0xFB); /* Double-density has two sync characters */
+		}
+		writer += sector->data;
+		if (doubleDensity == true) {
+			writer.write_8(northstarChecksum(sectorData.slice(2)));
+		} else {
+			writer.write_8(northstarChecksum(sectorData.slice(1)));
+		}
+	}
+	for (uint8_t b : sectorData)
+		fullSector->push_back(b);

-    if (sector->logicalSector != 9)
-    {
-        /* sector postamble */
-        for (int i = 0; i < gapFillSize; i++)
-            fullSector->push_back(GAP2_FILL_BYTE);
+	if (sector->logicalSector != 9) {
+		/* sector postamble */
+		for (int i = 0; i < gapFillSize; i++)
+			fullSector->push_back(GAP2_FILL_BYTE);

-        if (fullSector->size() != fullSectorSize)
-            error("sector mismatched length ({}); expected {}, got {}",
-                sector->data.size(),
-                fullSector->size(),
-                fullSectorSize);
-    }
-    else
-    {
-        /* sector postamble */
-        for (int i = 0; i < gapFillSize; i++)
-            fullSector->push_back(GAP2_FILL_BYTE);
-    }
+		if (fullSector->size() != fullSectorSize)
+			Error() << "sector mismatched length (" << sector->data.size() << ") expected: " << fullSector->size() << " got " << fullSectorSize;
+	} else {
+		/* sector postamble */
+		for (int i = 0; i < gapFillSize; i++)
+			fullSector->push_back(GAP2_FILL_BYTE);
+	}

-    bool lastBit = false;
+	bool lastBit = false;

-    if (doubleDensity == true)
-    {
-        encodeMfm(bits, cursor, fullSector, lastBit);
-    }
-    else
-    {
-        encodeFm(bits, cursor, fullSector);
-    }
+	if (doubleDensity == true) {
+		encodeMfm(bits, cursor, fullSector, lastBit);
+	}
+	else {
+		encodeFm(bits, cursor, fullSector);
+	}
 }

-class NorthstarEncoder : public Encoder
+std::unique_ptr<Fluxmap> NorthstarEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
 {
-public:
-    NorthstarEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.northstar())
-    {
-    }
+	int bitsPerRevolution = 100000;
+	double clockRateUs = 4.00;

-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        int bitsPerRevolution = 100000;
-        double clockRateUs = _config.clock_period_us();
+	if ((physicalTrack < 0) || (physicalTrack >= 35))
+		return std::unique_ptr<Fluxmap>();

-        const auto& sector = *sectors.begin();
-        if (sector->data.size() == NORTHSTAR_PAYLOAD_SIZE_SD)
-            bitsPerRevolution /= 2; // FM
-        else
-            clockRateUs /= 2.00;
+	const auto& sector = allSectors.get(physicalTrack, physicalSide, 0);

-        std::vector<bool> bits(bitsPerRevolution);
-        unsigned cursor = 0;
+	if (sector->data.size() == NORTHSTAR_PAYLOAD_SIZE_SD) {
+		bitsPerRevolution /= 2;		// FM
+	} else {
+		clockRateUs /= 2.00;
+	}

-        for (const auto& sectorData : sectors)
-            write_sector(bits, cursor, sectorData);
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;

-        if (cursor > bits.size())
-            error("track data overrun");
+	for (int sectorId = 0; sectorId < 10; sectorId++)
+	{
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		write_sector(bits, cursor, sectorData);
+	}

-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits,
-            calculatePhysicalClockPeriod(
-                clockRateUs * 1e3, _config.rotational_period_ms() * 1e6));
-        return fluxmap;
-    }
+	if (cursor > bits.size())
+		Error() << "track data overrun";

-private:
-    const NorthstarEncoderProto& _config;
-};
-
-std::unique_ptr<Encoder> createNorthstarEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new NorthstarEncoder(config));
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(bits, clockRateUs * 1e3);
+	return fluxmap;
 }
--- a/arch/northstar/northstar.h
+++ b/arch/northstar/northstar.h
@@ -1,8 +1,7 @@
 #ifndef NORTHSTAR_H
 #define NORTHSTAR_H

-/* Northstar floppies are 10-hard sectored disks with a sector format as
- * follows:
+/* Northstar floppies are 10-hard sectored disks with a sector format as follows:
 *
 * |----------------------------------|
 * | SYNC Byte  | Payload  | Checksum |
@@ -13,30 +12,61 @@
 *
 */

-#define NORTHSTAR_PREAMBLE_SIZE_SD (16)
-#define NORTHSTAR_PREAMBLE_SIZE_DD (32)
-#define NORTHSTAR_HEADER_SIZE_SD (1)
-#define NORTHSTAR_HEADER_SIZE_DD (2)
-#define NORTHSTAR_PAYLOAD_SIZE_SD (256)
-#define NORTHSTAR_PAYLOAD_SIZE_DD (512)
-#define NORTHSTAR_CHECKSUM_SIZE (1)
-#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD                    \
-    (NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + \
-        NORTHSTAR_CHECKSUM_SIZE)
-#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD                    \
-    (NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + \
-        NORTHSTAR_CHECKSUM_SIZE)
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"

-class Decoder;
-class Encoder;
-class EncoderProto;
-class DecoderProto;
+#define NORTHSTAR_PREAMBLE_SIZE_SD		(16)
+#define NORTHSTAR_PREAMBLE_SIZE_DD		(32)
+#define NORTHSTAR_HEADER_SIZE_SD		(1)
+#define NORTHSTAR_HEADER_SIZE_DD		(2)
+#define NORTHSTAR_PAYLOAD_SIZE_SD		(256)
+#define NORTHSTAR_PAYLOAD_SIZE_DD		(512)
+#define NORTHSTAR_CHECKSUM_SIZE		(1)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD	(NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + NORTHSTAR_CHECKSUM_SIZE)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD	(NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + NORTHSTAR_CHECKSUM_SIZE)

+#define SECTOR_TYPE_MFM			(0)
+#define SECTOR_TYPE_FM				(1)
+
+class NorthstarEncoderProto;
+class NorthstarDecoderProto;
+
+class NorthstarDecoder : public AbstractDecoder
+{
+public:
+	NorthstarDecoder(const NorthstarDecoderProto& config):
+		_config(config)
+	{
+		_sectorType = SECTOR_TYPE_MFM;
+	}
+
+	virtual ~NorthstarDecoder() {}
+
+	RecordType advanceToNextRecord();
+	void decodeSectorRecord();
+	std::set<unsigned> requiredSectors(Track& track) const;
+
+private:
+	const NorthstarDecoderProto& _config;
+	uint8_t _sectorType;
+	uint8_t _hardSectorId;
+};
+
+class NorthstarEncoder : public AbstractEncoder
+{
+public:
+	NorthstarEncoder(const NorthstarEncoderProto& config):
+		_config(config)
+	{}
+
+	virtual ~NorthstarEncoder() {}
+	std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	const NorthstarEncoderProto& _config;
+};
+
+extern FlagGroup northstarEncoderFlags;
 extern uint8_t northstarChecksum(const Bytes& bytes);

-extern std::unique_ptr<Decoder> createNorthstarDecoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createNorthstarEncoder(
-    const EncoderProto& config);
-
 #endif /* NORTHSTAR */
--- a/arch/northstar/northstar.proto
+++ b/arch/northstar/northstar.proto
@@ -1,13 +1,5 @@
 syntax = "proto2";

-import "lib/config/common.proto";
-
 message NorthstarDecoderProto {}
-
-message NorthstarEncoderProto {
-    optional double clock_period_us = 1
-        [ default = 4.0, (help) = "clock rate on the real device (for FM)" ];
-    optional double rotational_period_ms = 2
-        [ default = 166.0, (help) = "rotational period on the real device" ];
-}
+message NorthstarEncoderProto {}

--- a/arch/rolandd20/decoder.cc
+++ b/arch/rolandd20/decoder.cc
@@ -1,52 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
-#include "lib/core/bytes.h"
-#include "rolandd20.h"
-#include <string.h>
-
-/* Sector header record:
- *
- * BF FF FF FF FF FF FE AB
- *
- * This encodes to:
- *
- *    e    d    5    5    5    5    5    5
- * 1110 1101 0101 0101 0101 0101 0101 0101
- *    5    5    5    5    5    5    5    5
- * 0101 0101 0101 0101 0101 0101 0101 0101
- *    5    5    5    5    5    5    5    5
- * 0101 0101 0101 0101 0101 0101 0101 0101
- *    5    5    5    4    4    4    4    5
- * 0101 0101 0101 0100 0100 0100 0100 0101
- */
-
-static const FluxPattern SECTOR_PATTERN(64, 0xed55555555555555LL);
-
-class RolandD20Decoder : public Decoder
-{
-public:
-    RolandD20Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(SECTOR_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        auto rawbits = readRawBits(256);
-        const auto& bytes = decodeFmMfm(rawbits);
-        fmt::print("{} ", _sector->clock);
-        hexdump(std::cout, bytes);
-    }
-};
-
-std::unique_ptr<Decoder> createRolandD20Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new RolandD20Decoder(config));
-}
--- a/arch/rolandd20/rolandd20.h
+++ b/arch/rolandd20/rolandd20.h
@@ -1,4 +0,0 @@
-#pragma once
-
-extern std::unique_ptr<Decoder> createRolandD20Decoder(
-    const DecoderProto& config);
--- a/arch/rolandd20/rolandd20.proto
+++ b/arch/rolandd20/rolandd20.proto
@@ -1,5 +0,0 @@
-syntax = "proto2";
-
-message RolandD20DecoderProto {}
-
-
--- a/arch/smaky6/decoder.cc
+++ b/arch/smaky6/decoder.cc
@@ -1,155 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
-#include "smaky6.h"
-#include "lib/core/bytes.h"
-#include "lib/core/crc.h"
-#include "fmt/format.h"
-#include "lib/decoders/decoders.pb.h"
-#include <string.h>
-#include <algorithm>
-
-static const FluxPattern SECTOR_PATTERN(32, 0x54892aaa);
-
-class Smaky6Decoder : public Decoder
-{
-public:
-    Smaky6Decoder(const DecoderProto& config):
-        Decoder(config),
-        _config(config.smaky6())
-    {
-    }
-
-private:
-    /* Returns the sector ID of the _current_ sector. */
-    int advanceToNextSector()
-    {
-        auto previous = tell();
-        seekToIndexMark();
-        auto now = tell();
-        if ((now.ns() - previous.ns()) < 9e6)
-        {
-            seekToIndexMark();
-            auto next = tell();
-            if ((next.ns() - now.ns()) < 9e6)
-            {
-                /* We just found sector 0. */
-
-                _sectorId = 0;
-            }
-            else
-            {
-                /* Spurious... */
-
-                seek(now);
-            }
-        }
-
-        return _sectorId++;
-    }
-
-public:
-    void beginTrack() override
-    {
-        /* Find the start-of-track index marks, which will be an interval
-         * of about 6ms. */
-
-        seekToIndexMark();
-        _sectorId = 99;
-        for (;;)
-        {
-            auto pos = tell();
-            advanceToNextSector();
-            if (_sectorId < 99)
-            {
-                seek(pos);
-                break;
-            }
-
-            if (eof())
-                return;
-        }
-
-        /* Now we know where to start counting, start finding sectors. */
-
-        _sectorStarts.clear();
-        for (;;)
-        {
-            auto now = tell();
-            if (eof())
-                break;
-
-            int id = advanceToNextSector();
-            if (id < 16)
-                _sectorStarts.push_back(std::make_pair(id, now));
-        }
-
-        _sectorIndex = 0;
-    }
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        if (_sectorIndex == _sectorStarts.size())
-        {
-            seekToIndexMark();
-            return 0;
-        }
-
-        const auto& p = _sectorStarts[_sectorIndex++];
-        _sectorId = p.first;
-        seek(p.second);
-
-        nanoseconds_t clock = seekToPattern(SECTOR_PATTERN);
-        _sector->headerStartTime = tell().ns();
-
-        return clock;
-    }
-
-    void decodeSectorRecord() override
-    {
-        readRawBits(33);
-        const auto& rawbits = readRawBits(SMAKY6_RECORD_SIZE * 16);
-        if (rawbits.size() < SMAKY6_SECTOR_SIZE)
-            return;
-        const auto& rawbytes =
-            toBytes(rawbits).slice(0, SMAKY6_RECORD_SIZE * 16);
-
-        /* The Smaky bytes are stored backwards! Backwards! */
-
-        const auto& bytes =
-            decodeFmMfm(rawbits).slice(0, SMAKY6_RECORD_SIZE).reverseBits();
-        ByteReader br(bytes);
-
-        uint8_t track = br.read_8();
-        Bytes data = br.read(SMAKY6_SECTOR_SIZE);
-        uint8_t wantedChecksum = br.read_8();
-        uint8_t gotChecksum = sumBytes(data) & 0xff;
-
-        if (track != _sector->physicalTrack)
-            return;
-
-        _sector->logicalTrack = _sector->physicalTrack;
-        _sector->logicalSide = _sector->physicalSide;
-        _sector->logicalSector = _sectorId;
-
-        _sector->data = data;
-        _sector->status =
-            (wantedChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-
-private:
-    const Smaky6DecoderProto& _config;
-    nanoseconds_t _startOfTrack;
-    std::vector<std::pair<int, Fluxmap::Position>> _sectorStarts;
-    int _sectorId;
-    int _sectorIndex;
-};
-
-std::unique_ptr<Decoder> createSmaky6Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Smaky6Decoder(config));
-}
--- a/arch/smaky6/smaky6.h
+++ b/arch/smaky6/smaky6.h
@@ -1,9 +0,0 @@
-#ifndef SMAKY6_H
-#define SMAKY6_H
-
-#define SMAKY6_SECTOR_SIZE 256
-#define SMAKY6_RECORD_SIZE (1 + SMAKY6_SECTOR_SIZE + 1)
-
-extern std::unique_ptr<Decoder> createSmaky6Decoder(const DecoderProto& config);
-
-#endif
--- a/arch/smaky6/smaky6.proto
+++ b/arch/smaky6/smaky6.proto
@@ -1,4 +0,0 @@
-syntax = "proto2";
-
-message Smaky6DecoderProto {}
-
--- a/arch/tartu/decoder.cc
+++ b/arch/tartu/decoder.cc
@@ -1,81 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/config/config.h"
-#include "lib/decoders/decoders.h"
-#include "arch/tartu/tartu.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
-#include <string.h>
-
-constexpr uint64_t HEADER_BITS = 0xaaaaaaaa44895554LL;
-constexpr uint64_t DATA_BITS = 0xaaaaaaaa44895545LL;
-
-static const FluxPattern HEADER_PATTERN(64, HEADER_BITS);
-static const FluxPattern DATA_PATTERN(64, DATA_BITS);
-
-const FluxMatchers ANY_RECORD_PATTERN{&HEADER_PATTERN, &DATA_PATTERN};
-
-class TartuDecoder : public Decoder
-{
-public:
-    TartuDecoder(const DecoderProto& config):
-        Decoder(config),
-        _config(config.tartu())
-    {
-    }
-
-    void beginTrack() override {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        if (readRaw64() != HEADER_BITS)
-            return;
-
-        auto bits = readRawBits(16 * 4);
-        auto bytes = decodeFmMfm(bits).slice(0, 4);
-
-        ByteReader br(bytes);
-        uint8_t track = br.read_8();
-        _sector->logicalTrack = track >> 1;
-        _sector->logicalSide = track & 1;
-        br.skip(1); /* seems always to be 1 */
-        _sector->logicalSector = br.read_8();
-        uint8_t wantChecksum = br.read_8();
-        uint8_t gotChecksum = ~sumBytes(bytes.slice(0, 3));
-
-        if (wantChecksum == gotChecksum)
-            _sector->status = Sector::DATA_MISSING;
-
-        _sector->status = Sector::DATA_MISSING;
-    }
-
-    void decodeDataRecord() override
-    {
-        if (readRaw64() != DATA_BITS)
-            return;
-
-        const auto& bits = readRawBits(129 * 16);
-        const auto& bytes = decodeFmMfm(bits).slice(0, 129);
-        _sector->data = bytes.slice(0, 128);
-
-        uint8_t wantChecksum = bytes.reader().seek(128).read_8();
-        uint8_t gotChecksum = ~sumBytes(_sector->data);
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-
-private:
-    const TartuDecoderProto& _config;
-};
-
-std::unique_ptr<Decoder> createTartuDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new TartuDecoder(config));
-}
--- a/arch/tartu/encoder.cc
+++ b/arch/tartu/encoder.cc
@@ -1,115 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/config/config.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "arch/tartu/tartu.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/sector.h"
-#include <string.h>
-
-class TartuEncoder : public Encoder
-{
-public:
-    TartuEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.tartu())
-    {
-    }
-
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        _clockRateUs = _config.clock_period_us();
-        int bitsPerRevolution =
-            (_config.target_rotational_period_ms() * 1000.0) / _clockRateUs;
-
-        const auto& sector = *sectors.begin();
-        _bits.resize(bitsPerRevolution);
-        _cursor = 0;
-
-        writeFillerRawBitsUs(_config.gap1_us());
-        bool first = true;
-        for (const auto& sectorData : sectors)
-        {
-            if (!first)
-                writeFillerRawBitsUs(_config.gap4_us());
-            first = false;
-            writeSector(sectorData);
-        }
-
-        if (_cursor > _bits.size())
-            error("track data overrun");
-        writeFillerRawBitsUs(_config.target_rotational_period_ms() * 1000.0);
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(_bits,
-            calculatePhysicalClockPeriod(_clockRateUs * 1e3,
-                _config.target_rotational_period_ms() * 1e6));
-        return fluxmap;
-    }
-
-private:
-    void writeBytes(const Bytes& bytes)
-    {
-        encodeMfm(_bits, _cursor, bytes, _lastBit);
-    }
-
-    void writeRawBits(uint64_t data, int width)
-    {
-        _cursor += width;
-        _lastBit = data & 1;
-        for (int i = 0; i < width; i++)
-        {
-            unsigned pos = _cursor - i - 1;
-            if (pos < _bits.size())
-                _bits[pos] = data & 1;
-            data >>= 1;
-        }
-    }
-
-    void writeFillerRawBitsUs(double us)
-    {
-        unsigned count = (us / _clockRateUs) / 2;
-        for (int i = 0; i < count; i++)
-            writeRawBits(0b10, 2);
-    };
-
-    void writeSector(const std::shared_ptr<const Sector>& sectorData)
-    {
-        writeRawBits(_config.header_marker(), 64);
-        {
-            Bytes bytes;
-            ByteWriter bw(bytes);
-            bw.write_8(
-                (sectorData->logicalTrack << 1) | sectorData->logicalSide);
-            bw.write_8(1);
-            bw.write_8(sectorData->logicalSector);
-            bw.write_8(~sumBytes(bytes.slice(0, 3)));
-            writeBytes(bytes);
-        }
-
-        writeFillerRawBitsUs(_config.gap3_us());
-        writeRawBits(_config.data_marker(), 64);
-        {
-            Bytes bytes;
-            ByteWriter bw(bytes);
-            bw.append(sectorData->data);
-            bw.write_8(~sumBytes(bytes.slice(0, sectorData->data.size())));
-            writeBytes(bytes);
-        }
-    }
-
-private:
-    const TartuEncoderProto& _config;
-    double _clockRateUs;
-    std::vector<bool> _bits;
-    unsigned _cursor;
-    bool _lastBit;
-};
-
-std::unique_ptr<Encoder> createTartuEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new TartuEncoder(config));
-}
--- a/arch/tartu/tartu.h
+++ b/arch/tartu/tartu.h
@@ -1,7 +0,0 @@
-#ifndef TARTU_H
-#define TARTU_H
-
-extern std::unique_ptr<Decoder> createTartuDecoder(const DecoderProto& config);
-extern std::unique_ptr<Encoder> createTartuEncoder(const EncoderProto& config);
-
-#endif
--- a/arch/tartu/tartu.proto
+++ b/arch/tartu/tartu.proto
@@ -1,27 +0,0 @@
-syntax = "proto2";
-
-import "lib/config/common.proto";
-
-message TartuDecoderProto {}
-
-message TartuEncoderProto {
-    optional double clock_period_us = 1
-        [ default = 2.0, (help) = "clock rate on the real device (for MFM)" ];
-    optional double target_rotational_period_ms = 2
-        [ default=200, (help) = "rotational period of target disk" ];
-    optional double gap1_us = 3
-        [ default = 1200,
-          (help) = "size of gap 1 (the post-index gap)" ];
-    optional double gap3_us = 4
-        [ default = 150,
-          (help) = "size of gap 3 (the pre-data gap)" ];
-    optional double gap4_us = 5
-        [ default = 180,
-          (help) = "size of gap 4 (the post-data or format gap)" ];
-    optional uint64 header_marker = 6
-        [ default = 0xaaaaaaaa44895554,
-          (help) = "64-bit raw bit pattern of header record marker" ];
-    optional uint64 data_marker = 7
-        [ default = 0xaaaaaaaa44895545,
-          (help) = "64-bit raw bit pattern of data record marker" ];
-}
--- a/arch/tids990/decoder.cc
+++ b/arch/tids990/decoder.cc
@@ -1,14 +1,15 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "arch/tids990/tids990.h"
-#include "lib/core/crc.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
-#include "lib/data/sector.h"
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "tids990/tids990.h"
+#include "crc.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "sector.h"
+#include "record.h"
+#include "track.h"
 #include <string.h>
-#include "fmt/format.h"
+#include <fmt/format.h>

 /* The Texas Instruments DS990 uses MFM with a scheme similar to a simplified
 * version of the IBM record scheme (it's actually easier to parse than IBM).
@@ -24,78 +25,63 @@
 * When shifted out of phase, the special 0xa1 byte becomes an illegal
 * encoding (you can't do 10 00). So this can't be spoofed by user data.
 */
-const uint16_t SECTOR_ID = 0x550a;
 const FluxPattern SECTOR_RECORD_PATTERN(32, 0x11112244);

 /*
 * Data record:
- * data:    0  1  0  1  0  1  0  1 .0  0  0  0  1  0  1  1  = 0x550b
+ * data:    0  1  0  1  0  1  0  1 .0  0  0  0  1  0  1  1  = 0x550c
 * mfm:     00 01 00 01 00 01 00 01.00 10 10 10 01 00 01 01 = 0x11112a45
 * special: 00 01 00 01 00 01 00 01.00 10 00 10 01 00 01 01 = 0x11112245
 *                                        ^^
 * When shifted out of phase, the special 0xa1 byte becomes an illegal
 * encoding (you can't do 10 00). So this can't be spoofed by user data.
 */
-const uint16_t DATA_ID = 0x550b;
 const FluxPattern DATA_RECORD_PATTERN(32, 0x11112245);

-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

-class Tids990Decoder : public Decoder
+AbstractDecoder::RecordType Tids990Decoder::advanceToNextRecord()
 {
-public:
-    Tids990Decoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        auto bits = readRawBits(TIDS990_SECTOR_RECORD_SIZE * 16);
-        auto bytes = decodeFmMfm(bits).slice(0, TIDS990_SECTOR_RECORD_SIZE);
-
-        ByteReader br(bytes);
-        if (br.read_be16() != SECTOR_ID)
-            return;
-
-        uint16_t gotChecksum =
-            crc16(CCITT_POLY, bytes.slice(1, TIDS990_SECTOR_RECORD_SIZE - 3));
-
-        _sector->logicalSide = br.read_8() >> 3;
-        _sector->logicalTrack = br.read_8();
-        br.read_8(); /* number of sectors per track */
-        _sector->logicalSector = br.read_8();
-        br.read_be16(); /* sector size */
-        uint16_t wantChecksum = br.read_be16();
-
-        if (wantChecksum == gotChecksum)
-            _sector->status =
-                Sector::DATA_MISSING; /* correct but unintuitive */
-    }
-
-    void decodeDataRecord() override
-    {
-        auto bits = readRawBits(TIDS990_DATA_RECORD_SIZE * 16);
-        auto bytes = decodeFmMfm(bits).slice(0, TIDS990_DATA_RECORD_SIZE);
-
-        ByteReader br(bytes);
-        if (br.read_be16() != DATA_ID)
-            return;
-
-        uint16_t gotChecksum =
-            crc16(CCITT_POLY, bytes.slice(1, TIDS990_DATA_RECORD_SIZE - 3));
-
-        _sector->data = br.read(TIDS990_PAYLOAD_SIZE);
-        uint16_t wantChecksum = br.read_be16();
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createTids990Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Tids990Decoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return RecordType::SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return RecordType::DATA_RECORD;
+	return RecordType::UNKNOWN_RECORD;
 }
+
+void Tids990Decoder::decodeSectorRecord()
+{
+    auto bits = readRawBits(TIDS990_SECTOR_RECORD_SIZE*16);
+    auto bytes = decodeFmMfm(bits).slice(0, TIDS990_SECTOR_RECORD_SIZE);
+
+    ByteReader br(bytes);
+	uint16_t gotChecksum = crc16(CCITT_POLY, bytes.slice(1, TIDS990_SECTOR_RECORD_SIZE-3));
+
+	br.seek(2);
+	_sector->logicalSide = br.read_8() >> 3;
+	_sector->logicalTrack = br.read_8();
+	br.read_8(); /* number of sectors per track */
+	_sector->logicalSector = br.read_8();
+	br.read_be16(); /* sector size */
+    uint16_t wantChecksum = br.read_be16();
+
+    if (wantChecksum == gotChecksum)
+        _sector->status = Sector::DATA_MISSING; /* correct but unintuitive */
+}
+
+void Tids990Decoder::decodeDataRecord()
+{
+	auto bits = readRawBits(TIDS990_DATA_RECORD_SIZE*16);
+	auto bytes = decodeFmMfm(bits).slice(0, TIDS990_DATA_RECORD_SIZE);
+
+	ByteReader br(bytes);
+	uint16_t gotChecksum = crc16(CCITT_POLY, bytes.slice(1, TIDS990_DATA_RECORD_SIZE-3));
+
+	br.seek(2);
+	_sector->data = br.read(TIDS990_PAYLOAD_SIZE);
+	uint16_t wantChecksum = br.read_be16();
+    _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+}
+
--- a/arch/tids990/encoder.cc
+++ b/arch/tids990/encoder.cc
@@ -1,150 +1,130 @@
-#include "lib/core/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 #include "tids990.h"
-#include "lib/core/crc.h"
-#include "lib/data/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
 #include "arch/tids990/tids990.pb.h"
-#include "lib/encoders/encoders.pb.h"
-#include "fmt/format.h"
+#include <fmt/format.h>

 static int charToInt(char c)
 {
-    if (isdigit(c))
-        return c - '0';
-    return 10 + tolower(c) - 'a';
+	if (isdigit(c))
+		return c - '0';
+	return 10 + tolower(c) - 'a';
+}
+
+void Tids990Encoder::writeRawBits(uint32_t data, int width)
+{
+	_cursor += width;
+	_lastBit = data & 1;
+	for (int i=0; i<width; i++)
+	{
+		unsigned pos = _cursor - i - 1;
+		if (pos < _bits.size())
+			_bits[pos] = data & 1;
+		data >>= 1;
+	}
+}
+
+void Tids990Encoder::writeBytes(const Bytes& bytes)
+{
+	encodeMfm(_bits, _cursor, bytes, _lastBit);
+}
+
+void Tids990Encoder::writeBytes(int count, uint8_t byte)
+{
+	Bytes bytes = { byte };
+	for (int i=0; i<count; i++)
+		writeBytes(bytes);
 }

 static uint8_t decodeUint16(uint16_t raw)
 {
-    Bytes b;
-    ByteWriter bw(b);
-    bw.write_be16(raw);
-    return decodeFmMfm(b.toBits())[0];
+	Bytes b;
+	ByteWriter bw(b);
+	bw.write_be16(raw);
+	return decodeFmMfm(b.toBits())[0];
 }

-class Tids990Encoder : public Encoder
+std::unique_ptr<Fluxmap> Tids990Encoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
 {
-public:
-    Tids990Encoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.tids990())
-    {
+	double clockRateUs = 1e3 / _config.clock_rate_khz() / 2.0;
+	int bitsPerRevolution = (_config.track_length_ms() * 1000.0) / clockRateUs;
+	_bits.resize(bitsPerRevolution);
+	_cursor = 0;
+
+	uint8_t am1Unencoded = decodeUint16(_config.am1_byte());
+	uint8_t am2Unencoded = decodeUint16(_config.am2_byte());
+
+	writeBytes(_config.gap1_bytes(), 0x55);
+
+	bool first = true;
+	for (char sectorChar : _config.sector_skew())
+	{
+		int sectorId = charToInt(sectorChar);
+		if (!first)
+			writeBytes(_config.gap3_bytes(), 0x55);
+		first = false;
+
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		if (!sectorData)
+			Error() << fmt::format("format tried to find sector {} which wasn't in the input file", sectorId);
+
+		/* Writing the sector and data records are fantastically annoying.
+		 * The CRC is calculated from the *very start* of the record, and
+		 * include the malformed marker bytes. Our encoder doesn't know
+		 * about this, of course, with the result that we have to construct
+		 * the unencoded header, calculate the checksum, and then use the
+		 * same logic to emit the bytes which require special encoding
+		 * before encoding the rest of the header normally. */
+
+		{
+			Bytes header;
+			ByteWriter bw(header);
+
+			writeBytes(12, 0x55);
+			bw.write_8(am1Unencoded);
+			bw.write_8(sectorData->logicalSide << 3);
+			bw.write_8(sectorData->logicalTrack);
+			bw.write_8(_config.sector_count());
+			bw.write_8(sectorData->logicalSector);
+			bw.write_be16(sectorData->data.size());
+			uint16_t crc = crc16(CCITT_POLY, header);
+			bw.write_be16(crc);
+
+			writeRawBits(_config.am1_byte(), 16);
+			writeBytes(header.slice(1));
+		}
+
+		writeBytes(_config.gap2_bytes(), 0x55);
+
+		{
+			Bytes data;
+			ByteWriter bw(data);
+
+			writeBytes(12, 0x55);
+			bw.write_8(am2Unencoded);
+
+			bw += sectorData->data;
+			uint16_t crc = crc16(CCITT_POLY, data);
+			bw.write_be16(crc);
+
+			writeRawBits(_config.am2_byte(), 16);
+			writeBytes(data.slice(1));
+		}
    }

-private:
-    void writeRawBits(uint32_t data, int width)
-    {
-        _cursor += width;
-        _lastBit = data & 1;
-        for (int i = 0; i < width; i++)
-        {
-            unsigned pos = _cursor - i - 1;
-            if (pos < _bits.size())
-                _bits[pos] = data & 1;
-            data >>= 1;
-        }
-    }
-
-    void writeBytes(const Bytes& bytes)
-    {
-        encodeMfm(_bits, _cursor, bytes, _lastBit);
-    }
-
-    void writeBytes(int count, uint8_t byte)
-    {
-        Bytes bytes = {byte};
-        for (int i = 0; i < count; i++)
-            writeBytes(bytes);
-    }
-
-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        double clockRateUs = _config.clock_period_us() / 2.0;
-        int bitsPerRevolution =
-            (_config.rotational_period_ms() * 1000.0) / clockRateUs;
-        _bits.resize(bitsPerRevolution);
-        _cursor = 0;
-
-        uint8_t am1Unencoded = decodeUint16(_config.am1_byte());
-        uint8_t am2Unencoded = decodeUint16(_config.am2_byte());
-
-        writeBytes(_config.gap1_bytes(), 0x55);
-
-        bool first = true;
-        for (const auto& sectorData : sectors)
-        {
-            if (!first)
-                writeBytes(_config.gap3_bytes(), 0x55);
-            first = false;
-
-            /* Writing the sector and data records are fantastically annoying.
-             * The CRC is calculated from the *very start* of the record, and
-             * include the malformed marker bytes. Our encoder doesn't know
-             * about this, of course, with the result that we have to construct
-             * the unencoded header, calculate the checksum, and then use the
-             * same logic to emit the bytes which require special encoding
-             * before encoding the rest of the header normally. */
-
-            {
-                Bytes header;
-                ByteWriter bw(header);
-
-                writeBytes(12, 0x55);
-                bw.write_8(am1Unencoded);
-                bw.write_8(sectorData->logicalSide << 3);
-                bw.write_8(sectorData->logicalTrack);
-                bw.write_8(_config.sector_count());
-                bw.write_8(sectorData->logicalSector);
-                bw.write_be16(sectorData->data.size());
-                uint16_t crc = crc16(CCITT_POLY, header);
-                bw.write_be16(crc);
-
-                writeRawBits(_config.am1_byte(), 16);
-                writeBytes(header.slice(1));
-            }
-
-            writeBytes(_config.gap2_bytes(), 0x55);
-
-            {
-                Bytes data;
-                ByteWriter bw(data);
-
-                writeBytes(12, 0x55);
-                bw.write_8(am2Unencoded);
-
-                bw += sectorData->data;
-                uint16_t crc = crc16(CCITT_POLY, data);
-                bw.write_be16(crc);
-
-                writeRawBits(_config.am2_byte(), 16);
-                writeBytes(data.slice(1));
-            }
-        }
-
-        if (_cursor >= _bits.size())
-            error("track data overrun");
-        while (_cursor < _bits.size())
-            writeBytes(1, 0x55);
-
-        auto fluxmap = std::make_unique<Fluxmap>();
-        fluxmap->appendBits(_bits,
-            calculatePhysicalClockPeriod(
-                clockRateUs * 1e3, _config.rotational_period_ms() * 1e6));
-        return fluxmap;
-    }
-
-private:
-    const Tids990EncoderProto& _config;
-    std::vector<bool> _bits;
-    unsigned _cursor;
-    bool _lastBit;
-};
-
-std::unique_ptr<Encoder> createTids990Encoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new Tids990Encoder(config));
+	if (_cursor >= _bits.size())
+		Error() << "track data overrun";
+	while (_cursor < _bits.size())
+		writeBytes(1, 0x55);
+	
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(_bits, clockRateUs*1e3);
+	return fluxmap;
 }
+
--- a/arch/tids990/tids990.h
+++ b/arch/tids990/tids990.h
@@ -1,18 +1,54 @@
 #ifndef TIDS990_H
 #define TIDS990_H

-#define TIDS990_PAYLOAD_SIZE 288                            /* bytes */
-#define TIDS990_SECTOR_RECORD_SIZE 10                       /* bytes */
-#define TIDS990_DATA_RECORD_SIZE (TIDS990_PAYLOAD_SIZE + 4) /* bytes */
+#define TIDS990_PAYLOAD_SIZE       288 /* bytes */
+#define TIDS990_SECTOR_RECORD_SIZE 10 /* bytes */
+#define TIDS990_DATA_RECORD_SIZE   (TIDS990_PAYLOAD_SIZE + 4) /* bytes */

-class Encoder;
-class Decoder;
-class DecoderProto;
-class EncoderProto;
+class Sector;
+class SectorSet;
+class Fluxmap;
+class Track;
+class Tids990DecoderProto;
+class Tids990EncoderProto;

-extern std::unique_ptr<Decoder> createTids990Decoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createTids990Encoder(
-    const EncoderProto& config);
+class Tids990Decoder : public AbstractDecoder
+{
+public:
+	Tids990Decoder(const Tids990DecoderProto&) {}
+    virtual ~Tids990Decoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+	void decodeDataRecord();
+};
+
+class Tids990Encoder : public AbstractEncoder
+{
+public:
+	Tids990Encoder(const Tids990EncoderProto& config):
+		_config(config)
+	{}
+	virtual ~Tids990Encoder() {}
+
+private:
+	void writeRawBits(uint32_t data, int width);
+	void writeBytes(const Bytes& bytes);
+	void writeBytes(int count, uint8_t value);
+	void writeSync();
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	const Tids990EncoderProto& _config;
+	std::vector<bool> _bits;
+	unsigned _cursor;
+	bool _lastBit;
+};
+
+extern FlagGroup tids990EncoderFlags;

 #endif
+
+
--- a/arch/tids990/tids990.proto
+++ b/arch/tids990/tids990.proto
@@ -1,15 +1,14 @@
 syntax = "proto2";

-import "lib/config/common.proto";
+import "lib/common.proto";

 message Tids990DecoderProto {}
-
 message Tids990EncoderProto {
-	optional double rotational_period_ms = 1 [ default = 166,
+	optional double track_length_ms = 1 [ default = 166,
 		(help) = "length of a track" ];
 	optional int32 sector_count = 2 [ default = 26,
 		(help) = "number of sectors per track" ];
-	optional double clock_period_us = 3 [ default = 2,
+	optional double clock_rate_khz = 3 [ default = 500,
 		(help) = "clock rate of data to write" ];
 	optional int32 am1_byte = 4 [ default = 0x2244,
 		(help) = "16-bit RAW bit pattern to use for the AM1 ID byte" ];
@@ -21,5 +20,7 @@ message Tids990EncoderProto {
 		(help) = "size of gap 2 (the post-ID gap)" ];
 	optional int32 gap3_bytes = 8 [ default = 51,
 		(help) = "size of gap 3 (the post-data or format gap)" ];
+	optional string sector_skew = 9 [ default = "1mhc72nid83oje94pkfa50lgb6",
+		(help) = "order to emit sectors" ];
 }

--- a/arch/victor9k/decoder.cc
+++ b/arch/victor9k/decoder.cc
@@ -1,34 +1,33 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "victor9k.h"
-#include "lib/core/crc.h"
-#include "lib/core/bytes.h"
+#include "crc.h"
+#include "bytes.h"
+#include "track.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 const FluxPattern SECTOR_RECORD_PATTERN(32, VICTOR9K_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(32, VICTOR9K_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN(
-    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });

 static int decode_data_gcr(uint8_t gcr)
 {
    switch (gcr)
    {
-#define GCR_ENTRY(gcr, data) \
-    case gcr:                \
-        return data;
-#include "data_gcr.h"
-#undef GCR_ENTRY
+		#define GCR_ENTRY(gcr, data) \
+			case gcr: return data;
+		#include "data_gcr.h"
+		#undef GCR_ENTRY
    }
    return -1;
-}
+};

 static Bytes decode(const std::vector<bool>& bits)
 {
@@ -40,11 +39,11 @@ static Bytes decode(const std::vector<bool>& bits)
    while (ii != bits.end())
    {
        uint8_t inputfifo = 0;
-        for (size_t i = 0; i < 5; i++)
+        for (size_t i=0; i<5; i++)
        {
            if (ii == bits.end())
                break;
-            inputfifo = (inputfifo << 1) | *ii++;
+            inputfifo = (inputfifo<<1) | *ii++;
        }

        uint8_t decoded = decode_data_gcr(inputfifo);
@@ -55,65 +54,58 @@ static Bytes decode(const std::vector<bool>& bits)
    return output;
 }

-class Victor9kDecoder : public Decoder
+AbstractDecoder::RecordType Victor9kDecoder::advanceToNextRecord()
 {
-public:
-    Victor9kDecoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        /* Check the ID. */
-
-        if (readRaw32() != VICTOR9K_SECTOR_RECORD)
-            return;
-
-        /* Read header. */
-
-        auto bytes = decode(readRawBits(3 * 10)).slice(0, 3);
-
-        uint8_t rawTrack = bytes[0];
-        _sector->logicalSector = bytes[1];
-        uint8_t gotChecksum = bytes[2];
-
-        _sector->logicalTrack = rawTrack & 0x7f;
-        _sector->logicalSide = rawTrack >> 7;
-        uint8_t wantChecksum = bytes[0] + bytes[1];
-        if ((_sector->logicalSector > 20) || (_sector->logicalTrack > 85) ||
-            (_sector->logicalSide > 1))
-            return;
-
-        if (wantChecksum == gotChecksum)
-            _sector->status =
-                Sector::DATA_MISSING; /* unintuitive but correct */
-    }
-
-    void decodeDataRecord() override
-    {
-        /* Check the ID. */
-
-        if (readRaw32() != VICTOR9K_DATA_RECORD)
-            return;
-
-        /* Read data. */
-
-        auto bytes = decode(readRawBits((VICTOR9K_SECTOR_LENGTH + 4) * 10))
-                         .slice(0, VICTOR9K_SECTOR_LENGTH + 4);
-        ByteReader br(bytes);
-
-        _sector->data = br.read(VICTOR9K_SECTOR_LENGTH);
-        uint16_t gotChecksum = sumBytes(_sector->data);
-        uint16_t wantChecksum = br.read_le16();
-        _sector->status =
-            (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createVictor9kDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Victor9kDecoder(config));
+	const FluxMatcher* matcher = nullptr;
+	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
+	if (matcher == &SECTOR_RECORD_PATTERN)
+		return SECTOR_RECORD;
+	if (matcher == &DATA_RECORD_PATTERN)
+		return DATA_RECORD;
+	return UNKNOWN_RECORD;
+}
+
+void Victor9kDecoder::decodeSectorRecord()
+{
+    /* Skip the sync marker bit. */
+    readRawBits(23);
+
+    /* Read header. */
+
+    auto bytes = decode(readRawBits(4*10)).slice(0, 4);
+
+    uint8_t rawTrack = bytes[1];
+    _sector->logicalSector = bytes[2];
+    uint8_t gotChecksum = bytes[3];
+
+    _sector->logicalTrack = rawTrack & 0x7f;
+    _sector->logicalSide = rawTrack >> 7;
+    uint8_t wantChecksum = bytes[1] + bytes[2];
+    if ((_sector->logicalSector > 20) || (_sector->logicalTrack > 85) || (_sector->logicalSide > 1))
+        return;
+                
+    if (wantChecksum == gotChecksum)
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+}
+
+void Victor9kDecoder::decodeDataRecord()
+{
+    /* Skip the sync marker bit. */
+    readRawBits(23);
+
+    /* Read data. */
+
+    auto bytes = decode(readRawBits((VICTOR9K_SECTOR_LENGTH+5)*10))
+        .slice(0, VICTOR9K_SECTOR_LENGTH+5);
+    ByteReader br(bytes);
+
+    /* Check that this is actually a data record. */
+    
+    if (br.read_8() != 8)
+        return;
+
+    _sector->data = br.read(VICTOR9K_SECTOR_LENGTH);
+    uint16_t gotChecksum = sumBytes(_sector->data);
+    uint16_t wantChecksum = br.read_le16();
+    _sector->status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/victor9k/encoder.cc
+++ b/arch/victor9k/encoder.cc
@@ -1,210 +0,0 @@
-#include "lib/core/globals.h"
-#include "lib/core/utils.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "victor9k.h"
-#include "lib/core/crc.h"
-#include "lib/data/sector.h"
-#include "lib/data/image.h"
-#include "fmt/format.h"
-#include "arch/victor9k/victor9k.pb.h"
-#include "lib/encoders/encoders.pb.h"
-#include "lib/data/layout.h"
-#include <ctype.h>
-#include "lib/core/bytes.h"
-
-static bool lastBit;
-
-static void write_zero_bits(
-    std::vector<bool>& bits, unsigned& cursor, unsigned count)
-{
-    while (count--)
-    {
-        if (cursor < bits.size())
-            lastBit = bits[cursor++] = 0;
-    }
-}
-
-static void write_one_bits(
-    std::vector<bool>& bits, unsigned& cursor, unsigned count)
-{
-    while (count--)
-    {
-        if (cursor < bits.size())
-            lastBit = bits[cursor++] = 1;
-    }
-}
-
-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
-{
-    for (bool bit : src)
-    {
-        if (cursor < bits.size())
-            lastBit = bits[cursor++] = bit;
-    }
-}
-
-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
-{
-    cursor += width;
-    lastBit = data & 1;
-    for (int i = 0; i < width; i++)
-    {
-        unsigned pos = cursor - i - 1;
-        if (pos < bits.size())
-            bits[pos] = data & 1;
-        data >>= 1;
-    }
-}
-
-static void write_bits(
-    std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
-{
-    ByteReader br(bytes);
-    BitReader bitr(br);
-
-    while (!bitr.eof())
-    {
-        if (cursor < bits.size())
-            bits[cursor++] = bitr.get();
-    }
-}
-
-static int encode_data_gcr(uint8_t data)
-{
-    switch (data & 0x0f)
-    {
-#define GCR_ENTRY(gcr, data) \
-    case data:               \
-        return gcr;
-#include "data_gcr.h"
-#undef GCR_ENTRY
-    }
-    return -1;
-}
-
-static void write_byte(std::vector<bool>& bits, unsigned& cursor, uint8_t b)
-{
-    write_bits(bits, cursor, encode_data_gcr(b >> 4), 5);
-    write_bits(bits, cursor, encode_data_gcr(b), 5);
-}
-
-static void write_bytes(
-    std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
-{
-    for (uint8_t b : bytes)
-        write_byte(bits, cursor, b);
-}
-
-static void write_gap(std::vector<bool>& bits, unsigned& cursor, int length)
-{
-    for (int i = 0; i < length / 10; i++)
-        write_byte(bits, cursor, '0');
-}
-
-static void write_sector(std::vector<bool>& bits,
-    unsigned& cursor,
-    const Victor9kEncoderProto::TrackdataProto& trackdata,
-    const Sector& sector)
-{
-    write_one_bits(bits, cursor, trackdata.pre_header_sync_bits());
-    write_bits(bits, cursor, VICTOR9K_SECTOR_RECORD, 10);
-
-    uint8_t encodedTrack = sector.logicalTrack | (sector.logicalSide << 7);
-    uint8_t encodedSector = sector.logicalSector;
-    write_bytes(bits,
-        cursor,
-        Bytes{
-            encodedTrack,
-            encodedSector,
-            (uint8_t)(encodedTrack + encodedSector),
-        });
-
-    write_gap(bits, cursor, trackdata.post_header_gap_bits());
-
-    write_one_bits(bits, cursor, trackdata.pre_data_sync_bits());
-    write_bits(bits, cursor, VICTOR9K_DATA_RECORD, 10);
-
-    write_bytes(bits, cursor, sector.data);
-
-    Bytes checksum(2);
-    checksum.writer().write_le16(sumBytes(sector.data));
-    write_bytes(bits, cursor, checksum);
-    write_gap(bits, cursor, trackdata.post_data_gap_bits());
-}
-
-class Victor9kEncoder : public Encoder
-{
-public:
-    Victor9kEncoder(const EncoderProto& config):
-        Encoder(config),
-        _config(config.victor9k())
-    {
-    }
-
-private:
-    void getTrackFormat(Victor9kEncoderProto::TrackdataProto& trackdata,
-        unsigned track,
-        unsigned head)
-    {
-        trackdata.Clear();
-        for (const auto& f : _config.trackdata())
-        {
-            if (f.has_min_track() && (track < f.min_track()))
-                continue;
-            if (f.has_max_track() && (track > f.max_track()))
-                continue;
-            if (f.has_head() && (head != f.head()))
-                continue;
-
-            trackdata.MergeFrom(f);
-        }
-    }
-
-public:
-    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
-        const std::vector<std::shared_ptr<const Sector>>& sectors,
-        const Image& image) override
-    {
-        Victor9kEncoderProto::TrackdataProto trackdata;
-        getTrackFormat(
-            trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
-
-        unsigned bitsPerRevolution = (trackdata.rotational_period_ms() * 1e3) /
-                                     trackdata.clock_period_us();
-        std::vector<bool> bits(bitsPerRevolution);
-        nanoseconds_t clockPeriod =
-            calculatePhysicalClockPeriod(trackdata.clock_period_us() * 1e3,
-                trackdata.rotational_period_ms() * 1e6);
-        unsigned cursor = 0;
-
-        fillBitmapTo(bits,
-            cursor,
-            trackdata.post_index_gap_us() * 1e3 / clockPeriod,
-            {true, false});
-        lastBit = false;
-
-        for (const auto& sector : sectors)
-            write_sector(bits, cursor, trackdata, *sector);
-
-        if (cursor >= bits.size())
-            error("track data overrun by {} bits", cursor - bits.size());
-        fillBitmapTo(bits, cursor, bits.size(), {true, false});
-
-        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-        fluxmap->appendBits(bits, clockPeriod);
-        return fluxmap;
-    }
-
-private:
-    const Victor9kEncoderProto& _config;
-};
-
-std::unique_ptr<Encoder> createVictor9kEncoder(const EncoderProto& config)
-{
-    return std::unique_ptr<Encoder>(new Victor9kEncoder(config));
-}
-
-// vim: sw=4 ts=4 et
--- a/arch/victor9k/victor9k.h
+++ b/arch/victor9k/victor9k.h
@@ -1,26 +1,24 @@
 #ifndef VICTOR9K_H
 #define VICTOR9K_H

-class Encoder;
-class Decoder;
-class EncoderProto;
-class DecoderProto;
-
-/* ... 1101 0101 0111
- *       ^^ ^^^^ ^^^^ ten bit IO byte */
-#define VICTOR9K_SECTOR_RECORD 0xfffffd57
-#define VICTOR9K_HEADER_ID 0x7
-
-/* ... 1101 0100 1001
- *       ^^ ^^^^ ^^^^ ten bit IO byte */
-#define VICTOR9K_DATA_RECORD 0xfffffd49
-#define VICTOR9K_DATA_ID 0x8
+#define VICTOR9K_SECTOR_RECORD 0xfffffeab
+#define VICTOR9K_DATA_RECORD   0xfffffea4

 #define VICTOR9K_SECTOR_LENGTH 512

-extern std::unique_ptr<Decoder> createVictor9kDecoder(
-    const DecoderProto& config);
-extern std::unique_ptr<Encoder> createVictor9kEncoder(
-    const EncoderProto& config);
+class Sector;
+class Fluxmap;
+class Victor9kDecoderProto;
+
+class Victor9kDecoder : public AbstractDecoder
+{
+public:
+	Victor9kDecoder(const Victor9kDecoderProto&) {}
+    virtual ~Victor9kDecoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+    void decodeDataRecord();
+};

 #endif
--- a/arch/victor9k/victor9k.proto
+++ b/arch/victor9k/victor9k.proto
@@ -1,36 +1,4 @@
 syntax = "proto2";

-import "lib/config/common.proto";
-
 message Victor9kDecoderProto {}

-// NEXT: 12
-message Victor9kEncoderProto
-{
-    message TrackdataProto
-    {
-        optional int32 min_track = 1
-            [ (help) = "minimum track this format applies to" ];
-        optional int32 max_track = 2
-            [ (help) = "maximum track this format applies to" ];
-        optional int32 head = 3
-            [ (help) = "which head this format applies to" ];
-
-        optional double rotational_period_ms = 4
-            [ (help) = "original rotational period of this track" ];
-        optional double clock_period_us = 5
-            [ (help) = "original data rate of this track" ];
-        optional double post_index_gap_us = 6
-            [ (help) = "size of post-index gap" ];
-        optional int32 pre_header_sync_bits = 10
-            [ (help) = "number of sync bits before the sector header" ];
-        optional int32 pre_data_sync_bits = 8
-            [ (help) = "number of sync bits before the sector data" ];
-        optional int32 post_data_gap_bits = 9
-            [ (help) = "size of gap between data and the next header" ];
-        optional int32 post_header_gap_bits = 11
-            [ (help) = "size of gap between header and the data" ];
-    }
-
-    repeated TrackdataProto trackdata = 1;
-}
--- a/arch/zilogmcz/decoder.cc
+++ b/arch/zilogmcz/decoder.cc
@@ -1,56 +1,48 @@
-#include "lib/core/globals.h"
-#include "lib/data/fluxmap.h"
-#include "lib/data/fluxmapreader.h"
-#include "lib/data/fluxpattern.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/data/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "zilogmcz.h"
-#include "lib/core/bytes.h"
-#include "lib/core/crc.h"
+#include "bytes.h"
+#include "crc.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>

 static const FluxPattern SECTOR_START_PATTERN(16, 0xaaab);

-class ZilogMczDecoder : public Decoder
+AbstractDecoder::RecordType ZilogMczDecoder::advanceToNextRecord()
 {
-public:
-    ZilogMczDecoder(const DecoderProto& config): Decoder(config) {}
-
-    nanoseconds_t advanceToNextRecord() override
-    {
-        seekToIndexMark();
-        return seekToPattern(SECTOR_START_PATTERN);
-    }
-
-    void decodeSectorRecord() override
-    {
-        readRawBits(14);
-
-        auto rawbits = readRawBits(140 * 16);
-        auto bytes = decodeFmMfm(rawbits).slice(0, 140);
-        ByteReader br(bytes);
-
-        _sector->logicalSector = br.read_8() & 0x1f;
-        _sector->logicalSide = 0;
-        _sector->logicalTrack = br.read_8() & 0x7f;
-        if (_sector->logicalSector > 31)
-            return;
-        if (_sector->logicalTrack > 80)
-            return;
-
-        _sector->data = br.read(132);
-        uint16_t wantChecksum = br.read_be16();
-        uint16_t gotChecksum = crc16(MODBUS_POLY, 0x0000, bytes.slice(0, 134));
-
-        _sector->status =
-            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
-    }
-};
-
-std::unique_ptr<Decoder> createZilogMczDecoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new ZilogMczDecoder(config));
+	const FluxMatcher* matcher = nullptr;
+    _fmr->seekToIndexMark();
+	_sector->clock = _fmr->seekToPattern(SECTOR_START_PATTERN, matcher);
+	if (matcher == &SECTOR_START_PATTERN)
+		return SECTOR_RECORD;
+	return UNKNOWN_RECORD;
+}
+
+void ZilogMczDecoder::decodeSectorRecord()
+{
+    readRawBits(14);
+
+    auto rawbits = readRawBits(140*16);
+    auto bytes = decodeFmMfm(rawbits).slice(0, 140);
+    ByteReader br(bytes);
+
+    _sector->logicalSector = br.read_8() & 0x1f;
+    _sector->logicalSide = 0;
+    _sector->logicalTrack = br.read_8() & 0x7f;
+    if (_sector->logicalSector > 31)
+        return;
+    if (_sector->logicalTrack > 80)
+        return;
+
+    _sector->data = br.read(132);
+    uint16_t wantChecksum = br.read_be16();
+    uint16_t gotChecksum = crc16(MODBUS_POLY, 0x0000, bytes.slice(0, 134));
+
+    _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }
--- a/arch/zilogmcz/zilogmcz.h
+++ b/arch/zilogmcz/zilogmcz.h
@@ -1,7 +1,20 @@
 #ifndef ZILOGMCZ_H
 #define ZILOGMCZ_H

-extern std::unique_ptr<Decoder> createZilogMczDecoder(
-    const DecoderProto& config);
+class Sector;
+class Fluxmap;
+class ZilogMczDecoderProto;
+
+class ZilogMczDecoder : public AbstractDecoder
+{
+public:
+	ZilogMczDecoder(const ZilogMczDecoderProto&) {}
+    virtual ~ZilogMczDecoder() {}
+
+    RecordType advanceToNextRecord();
+    void decodeSectorRecord();
+};

 #endif
+
+
--- a/build.py
+++ b/build.py
@@ -1,108 +0,0 @@
-from build.ab import export
-from build.c import clibrary, cxxlibrary
-from build.protobuf import proto, protocc
-from build.pkg import package
-from build.utils import test
-from glob import glob
-import config
-import re
-
-package(name="protobuf_lib", package="protobuf")
-package(name="z_lib", package="zlib")
-package(name="fmt_lib", package="fmt", fallback="dep/fmt")
-package(name="sqlite3_lib", package="sqlite3")
-
-clibrary(name="protocol", hdrs={"protocol.h": "./protocol.h"})
-
-corpustests = []
-if not glob("../fluxengine-testdata/data"):
-    print("fluxengine-testdata not found; skipping corpus tests")
-else:
-    corpus = [
-        ("acorndfs", "", "--200"),
-        ("agat", "", ""),
-        ("amiga", "", ""),
-        ("apple2", "", "--140 40track_drive"),
-        ("atarist", "", "--360"),
-        ("atarist", "", "--370"),
-        ("atarist", "", "--400"),
-        ("atarist", "", "--410"),
-        ("atarist", "", "--720"),
-        ("atarist", "", "--740"),
-        ("atarist", "", "--800"),
-        ("atarist", "", "--820"),
-        ("bk", "", ""),
-        ("brother", "", "--120 40track_drive"),
-        ("brother", "", "--240"),
-        (
-            "commodore",
-            "scripts/commodore1541_test.textpb",
-            "--171 40track_drive",
-        ),
-        (
-            "commodore",
-            "scripts/commodore1541_test.textpb",
-            "--192 40track_drive",
-        ),
-        ("commodore", "", "--800"),
-        ("commodore", "", "--1620"),
-        ("hplif", "", "--264"),
-        ("hplif", "", "--608"),
-        ("hplif", "", "--616"),
-        ("hplif", "", "--770"),
-        ("ibm", "", "--1200"),
-        ("ibm", "", "--1232"),
-        ("ibm", "", "--1440"),
-        ("ibm", "", "--1680"),
-        ("ibm", "", "--180 40track_drive"),
-        ("ibm", "", "--160 40track_drive"),
-        ("ibm", "", "--320 40track_drive"),
-        ("ibm", "", "--360 40track_drive"),
-        ("ibm", "", "--720_96"),
-        ("ibm", "", "--720_135"),
-        ("mac", "scripts/mac400_test.textpb", "--400"),
-        ("mac", "scripts/mac800_test.textpb", "--800"),
-        ("n88basic", "", ""),
-        ("rx50", "", ""),
-        ("tartu", "", "--390 40track_drive"),
-        ("tartu", "", "--780"),
-        ("tids990", "", ""),
-        ("victor9k", "", "--612"),
-        ("victor9k", "", "--1224"),
-    ]
-
-    for c in corpus:
-        name = re.sub(r"[^a-zA-Z0-9]", "_", "".join(c), 0)
-        corpustests += [
-            test(
-                name=f"corpustest_{name}_{format}",
-                ins=["src+fluxengine"],
-                deps=["scripts/encodedecodetest.sh"],
-                commands=[
-                    "{deps[0]} "
-                    + c[0]
-                    + " "
-                    + format
-                    + " {ins[0]} '"
-                    + c[1]
-                    + "' '"
-                    + c[2]
-                    + "' $(dir {outs[0]}) > /dev/null"
-                ],
-                label="CORPUSTEST",
-            )
-            for format in ["scp", "flux"]
-        ]
-
-export(
-    name="all",
-    items={
-        "fluxengine$(EXT)": "src+fluxengine",
-        "fluxengine-gui$(EXT)": "src/gui",
-        "brother120tool$(EXT)": "tools+brother120tool",
-        "brother240tool$(EXT)": "tools+brother240tool",
-        "upgrade-flux-file$(EXT)": "tools+upgrade-flux-file",
-    }
-    | ({"FluxEngine.pkg": "src/gui+fluxengine_pkg"} if config.osx else {}),
-    deps=["tests", "src/formats+docs", "scripts+mkdocindex"] + corpustests,
-)
--- a/build/_objectify.py
+++ b/build/_objectify.py
@@ -1,19 +0,0 @@
-import sys
-from functools import partial
-
-if len(sys.argv) != 3:
-    sys.exit("Usage: %s <file> <symbol>" % sys.argv[0])
-filename = sys.argv[1]
-symbol = sys.argv[2]
-
-print("const uint8_t " + symbol + "[] = {")
-n = 0
-with open(filename, "rb") as in_file:
-    for c in iter(partial(in_file.read, 1), b""):
-        print("0x%02X," % ord(c), end="")
-        n += 1
-        if n % 16 == 0:
-            print()
-print("};")
-
-print("const size_t " + symbol + "_len = sizeof(" + symbol + ");")
--- a/build/ab.mk
+++ b/build/ab.mk
@@ -1,95 +0,0 @@
-MAKENOT4 := $(if $(findstring 3.9999, $(lastword $(sort 3.9999 $(MAKE_VERSION)))),yes,no)
-MAKE4.3 := $(if $(findstring 4.3, $(firstword $(sort 4.3 $(MAKE_VERSION)))),yes,no)
-MAKE4.1 := $(if $(findstring no_no,$(MAKENOT4)_$(MAKE4.3)),yes,no)
-
-ifeq ($(MAKENOT3),yes)
-$(error You need GNU Make 4.x for this (if you're on OSX, use gmake).)
-endif
-
-OBJ ?= .obj
-PYTHON ?= python3
-CC ?= gcc
-CXX ?= g++
-AR ?= ar
-CFLAGS ?= -g -Og
-LDFLAGS ?= -g
-PKG_CONFIG ?= pkg-config
-HOST_PKG_CONFIG ?= $(PKG_CONFIG)
-ECHO ?= echo
-CP ?= cp
-
-export PKG_CONFIG
-export HOST_PKG_CONFIG
-
-ifdef VERBOSE
-	hide =
-else
-	ifdef V
-		hide =
-	else
-		hide = @
-	endif
-endif
-
-WINDOWS := no
-OSX := no
-LINUX := no
-ifeq ($(OS),Windows_NT)
-    WINDOWS := yes
-else
-    UNAME_S := $(shell uname -s)
-    ifeq ($(UNAME_S),Linux)
-		LINUX := yes
-    endif
-    ifeq ($(UNAME_S),Darwin)
-		OSX := yes
-    endif
-endif
-
-ifeq ($(OS), Windows_NT)
-	EXT ?= .exe
-endif
-EXT ?=
-
-ifeq ($(PROGRESSINFO),)
-# The first make invocation here has to have its output discarded or else it
-# produces spurious 'Leaving directory' messages... don't know why.
-rulecount := $(strip $(shell $(MAKE) --no-print-directory -q $(OBJ)/build.mk PROGRESSINFO=1 > /dev/null \
-	&& $(MAKE) --no-print-directory -n $(MAKECMDGOALS) PROGRESSINFO=XXXPROGRESSINFOXXX | grep XXXPROGRESSINFOXXX | wc -l))
-ruleindex := 1
-PROGRESSINFO = "[$(ruleindex)/$(rulecount)]$(eval ruleindex := $(shell expr $(ruleindex) + 1))"
-endif
-
-PKG_CONFIG_HASHES = $(OBJ)/.pkg-config-hashes/target-$(word 1, $(shell $(PKG_CONFIG) --list-all | md5sum))
-HOST_PKG_CONFIG_HASHES = $(OBJ)/.pkg-config-hashes/host-$(word 1, $(shell $(HOST_PKG_CONFIG) --list-all | md5sum))
-
-$(OBJ)/build.mk : $(PKG_CONFIG_HASHES) $(HOST_PKG_CONFIG_HASHES)
-$(PKG_CONFIG_HASHES) $(HOST_PKG_CONFIG_HASHES) &:
-	$(hide) rm -rf $(OBJ)/.pkg-config-hashes
-	$(hide) mkdir -p $(OBJ)/.pkg-config-hashes
-	$(hide) touch $(PKG_CONFIG_HASHES) $(HOST_PKG_CONFIG_HASHES)
-
-include $(OBJ)/build.mk
-
-MAKEFLAGS += -r -j$(shell nproc)
-.DELETE_ON_ERROR:
-
-.PHONY: update-ab
-update-ab:
-	@echo "Press RETURN to update ab from the repository, or CTRL+C to cancel." \
-		&& read a \
-		&& (curl -L https://github.com/davidgiven/ab/releases/download/dev/distribution.tar.xz | tar xvJf -) \
-		&& echo "Done."
-
-.PHONY: clean
-clean::
-	@echo CLEAN
-	$(hide) rm -rf $(OBJ)
-
-export PYTHONHASHSEED = 1
-build-files = $(shell find . -name 'build.py') $(wildcard build/*.py) $(wildcard config.py)
-$(OBJ)/build.mk: Makefile $(build-files) build/ab.mk
-	@echo "AB"
-	@mkdir -p $(OBJ)
-	$(hide) $(PYTHON) -X pycache_prefix=$(OBJ)/__pycache__ build/ab.py -o $@ build.py \
-		|| rm -f $@
--- a/build/ab.py
+++ b/build/ab.py
@@ -1,557 +0,0 @@
-from os.path import *
-from pathlib import Path
-from typing import Iterable
-import argparse
-import builtins
-from copy import copy
-import functools
-import importlib
-import importlib.abc
-import importlib.util
-from importlib.machinery import (
-    SourceFileLoader,
-    PathFinder,
-    ModuleSpec,
-)
-import inspect
-import string
-import sys
-import hashlib
-
-verbose = False
-quiet = False
-cwdStack = [""]
-targets = {}
-unmaterialisedTargets = {}  # dict, not set, to get consistent ordering
-materialisingStack = []
-defaultGlobals = {}
-
-sys.path += ["."]
-old_import = builtins.__import__
-
-
-class PathFinderImpl(PathFinder):
-    def find_spec(self, fullname, path, target=None):
-        # The second test here is needed for Python 3.9.
-        if not path or not path[0]:
-            path = ["."]
-        if len(path) != 1:
-            return None
-
-        try:
-            path = relpath(path[0])
-        except ValueError:
-            return None
-
-        realpath = fullname.replace(".", "/")
-        buildpath = realpath + ".py"
-        if isfile(buildpath):
-            spec = importlib.util.spec_from_file_location(
-                name=fullname,
-                location=buildpath,
-                loader=BuildFileLoaderImpl(fullname=fullname, path=buildpath),
-                submodule_search_locations=[],
-            )
-            return spec
-        if isdir(realpath):
-            return ModuleSpec(fullname, None, origin=realpath, is_package=True)
-        return None
-
-
-class BuildFileLoaderImpl(SourceFileLoader):
-    def exec_module(self, module):
-        sourcepath = relpath(module.__file__)
-
-        if not quiet:
-            print("loading", sourcepath)
-        cwdStack.append(dirname(sourcepath))
-        super(SourceFileLoader, self).exec_module(module)
-        cwdStack.pop()
-
-
-sys.meta_path.insert(0, PathFinderImpl())
-
-
-class ABException(BaseException):
-    pass
-
-
-def error(message):
-    raise ABException(message)
-
-
-def Rule(func):
-    sig = inspect.signature(func)
-
-    @functools.wraps(func)
-    def wrapper(*, name=None, replaces=None, **kwargs):
-        cwd = None
-        if "cwd" in kwargs:
-            cwd = kwargs["cwd"]
-            del kwargs["cwd"]
-
-        if not cwd:
-            if replaces:
-                cwd = replaces.cwd
-            else:
-                cwd = cwdStack[-1]
-
-        if name:
-            if name[0] != "+":
-                name = "+" + name
-            t = Target(cwd, join(cwd, name))
-
-            assert (
-                t.name not in targets
-            ), f"target {t.name} has already been defined"
-            targets[t.name] = t
-        elif replaces:
-            t = replaces
-        else:
-            raise ABException("you must supply either 'name' or 'replaces'")
-
-        t.cwd = cwd
-        t.types = func.__annotations__
-        t.callback = func
-        t.traits.add(func.__name__)
-        if "args" in kwargs:
-            t.args |= kwargs["args"]
-            del kwargs["args"]
-        if "traits" in kwargs:
-            t.traits |= kwargs["traits"]
-            del kwargs["traits"]
-
-        t.binding = sig.bind(name=name, self=t, **kwargs)
-        t.binding.apply_defaults()
-
-        unmaterialisedTargets[t] = None
-        if replaces:
-            t.materialise(replacing=True)
-        return t
-
-    defaultGlobals[func.__name__] = wrapper
-    return wrapper
-
-
-def _isiterable(xs):
-    return isinstance(xs, Iterable) and not isinstance(
-        xs, (str, bytes, bytearray)
-    )
-
-
-class Target:
-    def __init__(self, cwd, name):
-        if verbose:
-            print("rule('%s', cwd='%s'" % (name, cwd))
-        self.name = name
-        self.localname = self.name.rsplit("+")[-1]
-        self.traits = set()
-        self.dir = join("$(OBJ)", name)
-        self.ins = []
-        self.outs = []
-        self.deps = []
-        self.materialised = False
-        self.args = {}
-
-    def __eq__(self, other):
-        return self.name is other.name
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-    def __hash__(self):
-        return id(self)
-
-    def __repr__(self):
-        return f"Target('{self.name}')"
-
-    def templateexpand(selfi, s):
-        class Formatter(string.Formatter):
-            def get_field(self, name, a1, a2):
-                return (
-                    eval(name, selfi.callback.__globals__, selfi.args),
-                    False,
-                )
-
-            def format_field(self, value, format_spec):
-                if not value:
-                    return ""
-                if type(value) == str:
-                    return value
-                if _isiterable(value):
-                    value = list(value)
-                if type(value) != list:
-                    value = [value]
-                return " ".join(
-                    [selfi.templateexpand(f) for f in filenamesof(value)]
-                )
-
-        return Formatter().format(s)
-
-    def materialise(self, replacing=False):
-        if self not in unmaterialisedTargets:
-            return
-
-        if not replacing and self in materialisingStack:
-            print("Found dependency cycle:")
-            for i in materialisingStack:
-                print(f"  {i.name}")
-            print(f"  {self.name}")
-            sys.exit(1)
-        materialisingStack.append(self)
-
-        # Perform type conversion to the declared rule parameter types.
-
-        try:
-            for k, v in self.binding.arguments.items():
-                if k != "kwargs":
-                    t = self.types.get(k, None)
-                    if t:
-                        v = t.convert(v, self)
-                    self.args[k] = copy(v)
-                else:
-                    for kk, vv in v.items():
-                        t = self.types.get(kk, None)
-                        if t:
-                            vv = t.convert(v, self)
-                        self.args[kk] = copy(vv)
-            self.args["name"] = self.name
-            self.args["dir"] = self.dir
-            self.args["self"] = self
-
-            # Actually call the callback.
-
-            cwdStack.append(self.cwd)
-            if "kwargs" in self.binding.arguments.keys():
-                # If the caller wants kwargs, return all arguments except the standard ones.
-                cbargs = {
-                    k: v for k, v in self.args.items() if k not in {"dir"}
-                }
-            else:
-                # Otherwise, just call the callback with the ones it asks for.
-                cbargs = {}
-                for k in self.binding.arguments.keys():
-                    if k != "kwargs":
-                        try:
-                            cbargs[k] = self.args[k]
-                        except KeyError:
-                            error(
-                                f"invocation of {self} failed because {k} isn't an argument"
-                            )
-            self.callback(**cbargs)
-            cwdStack.pop()
-        except BaseException as e:
-            print(f"Error materialising {self}: {self.callback}")
-            print(f"Arguments: {self.args}")
-            raise e
-
-        if self.outs is None:
-            raise ABException(f"{self.name} didn't set self.outs")
-
-        if self in unmaterialisedTargets:
-            del unmaterialisedTargets[self]
-        materialisingStack.pop()
-        self.materialised = True
-
-    def convert(value, target):
-        if not value:
-            return None
-        return target.targetof(value)
-
-    def targetof(self, value):
-        if isinstance(value, str) and (value[0] == "="):
-            value = join(self.dir, value[1:])
-
-        return targetof(value, self.cwd)
-
-
-def _filetarget(value, cwd):
-    if value in targets:
-        return targets[value]
-
-    t = Target(cwd, value)
-    t.outs = [value]
-    targets[value] = t
-    return t
-
-
-def targetof(value, cwd=None):
-    if not cwd:
-        cwd = cwdStack[-1]
-    if isinstance(value, Path):
-        value = value.as_posix()
-    if isinstance(value, Target):
-        t = value
-    else:
-        assert (
-            value[0] != "="
-        ), "can only use = for targets associated with another target"
-
-        if value.startswith("."):
-            # Check for local rule.
-            if value.startswith(".+"):
-                value = normpath(join(cwd, value[1:]))
-            # Check for local path.
-            elif value.startswith("./"):
-                value = normpath(join(cwd, value))
-        # Explicit directories are always raw files.
-        elif value.endswith("/"):
-            return _filetarget(value, cwd)
-        # Anything starting with a variable expansion is always a raw file.
-        elif value.startswith("$"):
-            return _filetarget(value, cwd)
-
-        # If this is not a rule lookup...
-        if "+" not in value:
-            # ...and if the value is pointing at a directory without a trailing /,
-            # it's a shorthand rule lookup.
-            if isdir(value):
-                value = value + "+" + basename(value)
-            # Otherwise it's an absolute file.
-            else:
-                return _filetarget(value, cwd)
-
-        # At this point we have the fully qualified name of a rule.
-
-        (path, target) = value.rsplit("+", 1)
-        value = join(path, "+" + target)
-        if value not in targets:
-            # Load the new build file.
-
-            path = join(path, "build.py")
-            try:
-                loadbuildfile(path)
-            except ModuleNotFoundError:
-                error(
-                    f"no such build file '{path}' while trying to resolve '{value}'"
-                )
-            assert (
-                value in targets
-            ), f"build file at '{path}' doesn't contain '+{target}' when trying to resolve '{value}'"
-
-        t = targets[value]
-
-    t.materialise()
-    return t
-
-
-class Targets:
-    def convert(value, target):
-        if not value:
-            return []
-        assert _isiterable(value), "cannot convert non-list to Targets"
-        return [target.targetof(x) for x in flatten(value)]
-
-
-class TargetsMap:
-    def convert(value, target):
-        if not value:
-            return {}
-        output = {k: target.targetof(v) for k, v in value.items()}
-        for k, v in output.items():
-            assert (
-                len(filenamesof([v])) == 1
-            ), f"targets of a TargetsMap used as an argument of {target} with key '{k}' must contain precisely one output file, but was {filenamesof([v])}"
-        return output
-
-
-def loadbuildfile(filename):
-    filename = filename.replace("/", ".").removesuffix(".py")
-    builtins.__import__(filename)
-
-
-def flatten(items):
-    def generate(xs):
-        for x in xs:
-            if _isiterable(x):
-                yield from generate(x)
-            else:
-                yield x
-
-    return list(generate(items))
-
-
-def targetnamesof(items):
-    assert _isiterable(items), "argument of filenamesof is not a collection"
-
-    return [t.name for t in items]
-
-
-def filenamesof(items):
-    assert _isiterable(items), "argument of filenamesof is not a collection"
-
-    def generate(xs):
-        for x in xs:
-            if isinstance(x, Target):
-                yield from generate(x.outs)
-            else:
-                yield x
-
-    return list(generate(items))
-
-
-def filenameof(x):
-    xs = filenamesof(x.outs)
-    assert (
-        len(xs) == 1
-    ), f"tried to use filenameof() on {x} which does not have exactly one output: {x.outs}"
-    return xs[0]
-
-
-def emit(*args, into=None):
-    s = " ".join(args) + "\n"
-    if into is not None:
-        into += [s]
-    else:
-        outputFp.write(s)
-
-
-def emit_rule(name, ins, outs, cmds=[], label=None):
-    fins = filenamesof(ins)
-    fouts = filenamesof(outs)
-    nonobjs = [f for f in fouts if not f.startswith("$(OBJ)")]
-
-    emit("")
-
-    lines = []
-    if nonobjs:
-        emit("clean::", into=lines)
-        emit("\t$(hide) rm -f", *nonobjs, into=lines)
-
-    emit(".PHONY:", name, into=lines)
-    if outs:
-        emit(name, ":", *fouts, into=lines)
-        if len(fouts) == 1:
-            emit(*fouts, ":", *fins, "\x01", into=lines)
-        else:
-            emit("ifeq ($(MAKE4.3),yes)", into=lines)
-            emit(*fouts, "&:", *fins, "\x01", into=lines)
-            emit("else", into=lines)
-            emit(*(fouts[1:]), ":", fouts[0], into=lines)
-            emit(fouts[0], ":", *fins, "\x01", into=lines)
-            emit("endif", into=lines)
-
-        if label:
-            emit("\t$(hide)", "$(ECHO) $(PROGRESSINFO)", label, into=lines)
-        for c in cmds:
-            emit("\t$(hide)", c, into=lines)
-    else:
-        assert len(cmds) == 0, "rules with no outputs cannot have commands"
-        emit(name, ":", *fins, into=lines)
-
-    cmd = "".join(lines)
-    hash = hashlib.sha1(bytes(cmd, "utf-8")).hexdigest()
-
-    outputFp.write(cmd.replace("\x01", f"$(OBJ)/.hashes/{hash}"))
-
-    if outs:
-        emit(f"$(OBJ)/.hashes/{hash}:")
-        emit(
-            f"\t$(hide) mkdir -p $(OBJ)/.hashes && touch $(OBJ)/.hashes/{hash}"
-        )
-    emit("")
-
-
-@Rule
-def simplerule(
-    self,
-    name,
-    ins: Targets = [],
-    outs: Targets = [],
-    deps: Targets = [],
-    commands=[],
-    label="RULE",
-):
-    self.ins = ins
-    self.outs = outs
-    self.deps = deps
-
-    dirs = []
-    cs = []
-    for out in filenamesof(outs):
-        dir = dirname(out)
-        if dir and dir not in dirs:
-            dirs += [dir]
-
-        cs = [("mkdir -p %s" % dir) for dir in dirs]
-
-    for c in commands:
-        cs += [self.templateexpand(c)]
-
-    emit_rule(
-        name=self.name,
-        ins=ins + deps,
-        outs=outs,
-        label=self.templateexpand("{label} {name}") if label else None,
-        cmds=cs,
-    )
-
-
-@Rule
-def export(self, name=None, items: TargetsMap = {}, deps: Targets = []):
-    ins = []
-    outs = []
-    for dest, src in items.items():
-        dest = self.targetof(dest)
-        outs += [dest]
-
-        destf = filenameof(dest)
-
-        srcs = filenamesof([src])
-        assert (
-            len(srcs) == 1
-        ), "a dependency of an exported file must have exactly one output file"
-
-        subrule = simplerule(
-            name=f"{self.localname}/{destf}",
-            cwd=self.cwd,
-            ins=[srcs[0]],
-            outs=[destf],
-            commands=["$(CP) %s %s" % (srcs[0], destf)],
-            label="",
-        )
-        subrule.materialise()
-
-    simplerule(
-        replaces=self,
-        ins=outs + deps,
-        outs=["=sentinel"],
-        commands=["touch {outs[0]}"],
-        label="EXPORT",
-    )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-v", "--verbose", action="store_true")
-    parser.add_argument("-q", "--quiet", action="store_true")
-    parser.add_argument("-o", "--output")
-    parser.add_argument("files", nargs="+")
-    args = parser.parse_args()
-
-    global verbose
-    verbose = args.verbose
-
-    global quiet
-    quiet = args.quiet
-
-    global outputFp
-    outputFp = open(args.output, "wt")
-
-    for k in ["Rule"]:
-        defaultGlobals[k] = globals()[k]
-
-    global __name__
-    sys.modules["build.ab"] = sys.modules[__name__]
-    __name__ = "build.ab"
-
-    for f in args.files:
-        loadbuildfile(f)
-
-    while unmaterialisedTargets:
-        t = next(iter(unmaterialisedTargets))
-        t.materialise()
-    emit("AB_LOADED = 1\n")
-
-
-main()
--- a/build/c.py
+++ b/build/c.py
@@ -1,335 +0,0 @@
-from build.ab import (
-    Rule,
-    Targets,
-    TargetsMap,
-    filenameof,
-    filenamesof,
-    flatten,
-    simplerule,
-    emit,
-)
-from build.utils import filenamesmatchingof, stripext, collectattrs
-from os.path import *
-
-emit(
-    """
-ifeq ($(OSX),no)
-STARTGROUP ?= -Wl,--start-group
-ENDGROUP ?= -Wl,--end-group
-endif
-"""
-)
-
-def _combine(list1, list2):
-    r = list(list1)
-    for i in list2:
-        if i not in r:
-            r.append(i)
-    return r
-
-def _indirect(deps, name):
-    r = []
-    for d in deps:
-        r = _combine(r, d.args.get(name, [d]))
-    return r
-
-
-def cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags):
-    outleaf = "=" + stripext(basename(filenameof(srcs[0]))) + suffix
-
-    hdr_deps = _indirect(deps, "cheader_deps")
-    cflags = collectattrs(
-        targets=hdr_deps, name="caller_cflags", initial=cflags
-    )
-
-    t = simplerule(
-        replaces=self,
-        ins=srcs,
-        deps=sorted(_indirect(hdr_deps, "cheader_files")),
-        outs=[outleaf],
-        label=label,
-        commands=commands,
-        args={"cflags": cflags},
-    )
-
-
-@Rule
-def cfile(
-    self,
-    name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    cflags=[],
-    suffix=".o",
-    commands=["$(CC) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"],
-    label="CC",
-):
-    cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags)
-
-
-@Rule
-def cxxfile(
-    self,
-    name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    cflags=[],
-    suffix=".o",
-    commands=["$(CXX) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"],
-    label="CXX",
-):
-    cfileimpl(self, name, srcs, deps, suffix, commands, label, cflags)
-
-
-def findsources(name, srcs, deps, cflags, filerule, cwd):
-    for f in filenamesof(srcs):
-        if f.endswith(".h") or f.endswith(".hh"):
-            cflags = cflags + [f"-I{dirname(f)}"]
-
-    objs = []
-    for s in flatten(srcs):
-        objs += [
-            filerule(
-                name=join(name, f.removeprefix("$(OBJ)/")),
-                srcs=[f],
-                deps=deps,
-                cflags=sorted(set(cflags)),
-                cwd=cwd,
-            )
-            for f in filenamesof([s])
-            if f.endswith(".c")
-            or f.endswith(".cc")
-            or f.endswith(".cpp")
-            or f.endswith(".S")
-            or f.endswith(".s")
-        ]
-        if any(f.endswith(".o") for f in filenamesof([s])):
-            objs += [s]
-
-    return objs
-
-
-def libraryimpl(
-    self,
-    name,
-    srcs,
-    deps,
-    hdrs,
-    caller_cflags,
-    caller_ldflags,
-    cflags,
-    ldflags,
-    commands,
-    label,
-    filerule,
-):
-    hdr_deps = _combine(_indirect(deps, "cheader_deps"), [self])
-    lib_deps = _combine(_indirect(deps, "clibrary_deps"), [self])
-
-    hr = None
-    hf = []
-    ar = None
-    if hdrs:
-        cs = []
-        ins = hdrs.values()
-        outs = []
-        i = 0
-        for dest, src in hdrs.items():
-            s = filenamesof([src])
-            assert (
-                len(s) == 1
-            ), "the target of a header must return exactly one file"
-
-            cs += ["$(CP) {ins[" + str(i) + "]} {outs[" + str(i) + "]}"]
-            outs += ["=" + dest]
-            i = i + 1
-
-        hr = simplerule(
-            name=f"{self.localname}_hdr",
-            ins=ins,
-            outs=outs,
-            commands=cs,
-            label="CHEADERS",
-        )
-        hr.materialise()
-        hf = [f"-I{hr.dir}"]
-
-    if srcs:
-        objs = findsources(
-            self.localname,
-            srcs,
-            deps + ([hr] if hr else []),
-            cflags + hf,
-            filerule,
-            self.cwd,
-        )
-
-        ar = simplerule(
-            name=f"{self.localname}_lib",
-            ins=objs,
-            outs=[f"={self.localname}.a"],
-            label=label,
-            commands=commands,
-        )
-        ar.materialise()
-
-    self.outs = ([hr] if hr else []) + ([ar] if ar else [])
-    self.deps = self.outs
-    self.args["cheader_deps"] = hdr_deps
-    self.args["clibrary_deps"] = lib_deps
-    self.args["cheader_files"] = [hr] if hr else []
-    self.args["clibrary_files"] = [ar] if ar else []
-    self.args["caller_cflags"] = caller_cflags + hf
-    self.args["caller_ldflags"] = caller_ldflags
-
-
-@Rule
-def clibrary(
-    self,
-    name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    hdrs: TargetsMap = None,
-    caller_cflags=[],
-    caller_ldflags=[],
-    cflags=[],
-    ldflags=[],
-    commands=["rm -f {outs[0]} && $(AR) cqs {outs[0]} {ins}"],
-    label="LIB",
-    cfilerule=cfile,
-):
-    libraryimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        hdrs,
-        caller_cflags,
-        caller_ldflags,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cfilerule,
-    )
-
-
-@Rule
-def cxxlibrary(
-    self,
-    name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    hdrs: TargetsMap = None,
-    caller_cflags=[],
-    caller_ldflags=[],
-    cflags=[],
-    ldflags=[],
-    commands=["rm -f {outs[0]} && $(AR) cqs {outs[0]} {ins}"],
-    label="CXXLIB",
-    cxxfilerule=cxxfile,
-):
-    libraryimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        hdrs,
-        caller_cflags,
-        caller_ldflags,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cxxfilerule,
-    )
-
-
-def programimpl(
-    self,
-    name,
-    srcs,
-    deps,
-    cflags,
-    ldflags,
-    commands,
-    label,
-    filerule,
-):
-    cfiles = findsources(self.localname, srcs, deps, cflags, filerule, self.cwd)
-
-    lib_deps = []
-    for d in deps:
-        lib_deps = _combine(lib_deps, d.args.get("clibrary_deps", {d}))
-    libs = filenamesmatchingof(lib_deps, "*.a")
-    ldflags = collectattrs(
-        targets=lib_deps, name="caller_ldflags", initial=ldflags
-    )
-
-    simplerule(
-        replaces=self,
-        ins=cfiles + libs,
-        outs=[f"={self.localname}$(EXT)"],
-        deps=_indirect(lib_deps, "clibrary_files"),
-        label=label,
-        commands=commands,
-        args={
-            "ldflags": collectattrs(
-                targets=lib_deps, name="caller_ldflags", initial=ldflags
-            )
-        },
-    )
-
-
-@Rule
-def cprogram(
-    self,
-    name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    cflags=[],
-    ldflags=[],
-    commands=[
-        "$(CC) -o {outs[0]} $(STARTGROUP) {ins} {ldflags} $(LDFLAGS) $(ENDGROUP)"
-    ],
-    label="CLINK",
-    cfilerule=cfile,
-):
-    programimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cfilerule,
-    )
-
-
-@Rule
-def cxxprogram(
-    self,
-    name,
-    srcs: Targets = None,
-    deps: Targets = None,
-    cflags=[],
-    ldflags=[],
-    commands=[
-        "$(CXX) -o {outs[0]} $(STARTGROUP) {ins} {ldflags} $(LDFLAGS) $(ENDGROUP)"
-    ],
-    label="CXXLINK",
-    cxxfilerule=cxxfile,
-):
-    programimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cxxfilerule,
-    )
--- a/build/pkg.py
+++ b/build/pkg.py
@@ -1,71 +0,0 @@
-from build.ab import Rule, emit, Target, filenamesof
-from types import SimpleNamespace
-import os
-import subprocess
-
-
-class _PkgConfig:
-    package_present = set()
-    package_properties = {}
-    pkgconfig = None
-
-    def __init__(self, cmd):
-        assert cmd, "no pkg-config environment variable supplied"
-        self.pkgconfig = cmd
-
-        r = subprocess.run(f"{cmd} --list-all", shell=True, capture_output=True)
-        ps = r.stdout.decode("utf-8")
-        self.package_present = {l.split(" ", 1)[0] for l in ps.splitlines()}
-
-    def has_package(self, name):
-        return name in self.package_present
-
-    def get_property(self, name, flag):
-        p = f"{name}.{flag}"
-        if p not in self.package_properties:
-            r = subprocess.run(
-                f"{self.pkgconfig} {flag} {name}",
-                shell=True,
-                capture_output=True,
-            )
-            self.package_properties[p] = r.stdout.decode("utf-8").strip()
-        return self.package_properties[p]
-
-
-TargetPkgConfig = _PkgConfig(os.getenv("PKG_CONFIG"))
-
-
-def _package(self, name, package, fallback, pkgconfig):
-    if pkgconfig.has_package(package):
-        cflags = pkgconfig.get_property(package, "--cflags")
-        ldflags = pkgconfig.get_property(package, "--libs")
-
-        if cflags:
-            self.args["caller_cflags"] = [cflags]
-        if ldflags:
-            self.args["caller_ldflags"] = [ldflags]
-        self.traits.add("clibrary")
-        self.traits.add("cheaders")
-        return
-
-    assert (
-        fallback
-    ), f"Required package '{package}' not installed when materialising target '{name}'"
-
-    if "cheader_deps" in fallback.args:
-        self.args["cheader_deps"] = fallback.args["cheader_deps"]
-    if "clibrary_deps" in fallback.args:
-        self.args["clibrary_deps"] = fallback.args["clibrary_deps"]
-    if "cheader_files" in fallback.args:
-        self.args["cheader_files"] = fallback.args["cheader_files"]
-    if "clibrary_files" in fallback.args:
-        self.args["clibrary_files"] = fallback.args["clibrary_files"]
-    self.ins = fallback.ins
-    self.outs = fallback.outs
-    self.deps = fallback.deps
-    self.traits = fallback.traits
-
-
-@Rule
-def package(self, name, package=None, fallback: Target = None):
-    _package(self, name, package, fallback, TargetPkgConfig)
--- a/build/protobuf.py
+++ b/build/protobuf.py
@@ -1,173 +0,0 @@
-from build.ab import Rule, Targets, emit, simplerule, filenamesof
-from build.utils import filenamesmatchingof, collectattrs
-from os.path import join, abspath, dirname, relpath
-import build.pkg  # to get the protobuf package check
-
-emit(
-    """
-PROTOC ?= protoc
-"""
-)
-
-assert build.pkg.TargetPkgConfig.has_package(
-    "protobuf"
-), "required package 'protobuf' not installed"
-
-
-def _getprotodeps(deps):
-    r = set()
-    for d in deps:
-        r.update(d.args.get("protodeps", {d}))
-    return sorted(r)
-
-
-@Rule
-def proto(self, name, srcs: Targets = [], deps: Targets = []):
-    protodeps = _getprotodeps(deps)
-    descriptorlist = ":".join(
-        [
-            relpath(f, start=self.dir)
-            for f in filenamesmatchingof(protodeps, "*.descriptor")
-        ]
-    )
-
-    dirs = sorted({"{dir}/" + dirname(f) for f in filenamesof(srcs)})
-    simplerule(
-        replaces=self,
-        ins=srcs,
-        outs=[f"={self.localname}.descriptor"],
-        deps=protodeps,
-        commands=(
-            ["mkdir -p " + (" ".join(dirs))]
-            + [f"$(CP) {f} {{dir}}/{f}" for f in filenamesof(srcs)]
-            + [
-                "cd {dir} && "
-                + (
-                    " ".join(
-                        [
-                            "$(PROTOC)",
-                            "--proto_path=.",
-                            "--include_source_info",
-                            f"--descriptor_set_out={self.localname}.descriptor",
-                        ]
-                        + (
-                            [f"--descriptor_set_in={descriptorlist}"]
-                            if descriptorlist
-                            else []
-                        )
-                        + ["{ins}"]
-                    )
-                )
-            ]
-        ),
-        label="PROTO",
-        args={
-            "protosrcs": filenamesof(srcs),
-            "protodeps": set(protodeps) | {self},
-        },
-    )
-
-
-@Rule
-def protocc(self, name, srcs: Targets = [], deps: Targets = []):
-    outs = []
-    protos = []
-
-    allsrcs = collectattrs(targets=srcs, name="protosrcs")
-    assert allsrcs, "no sources provided"
-    for f in filenamesmatchingof(allsrcs, "*.proto"):
-        cc = f.replace(".proto", ".pb.cc")
-        h = f.replace(".proto", ".pb.h")
-        protos += [f]
-        outs += ["=" + cc, "=" + h]
-
-    protodeps = _getprotodeps(deps + srcs)
-    descriptorlist = ":".join(
-        [
-            relpath(f, start=self.dir)
-            for f in filenamesmatchingof(protodeps, "*.descriptor")
-        ]
-    )
-
-    r = simplerule(
-        name=f"{self.localname}_srcs",
-        cwd=self.cwd,
-        ins=srcs,
-        outs=outs,
-        deps=protodeps,
-        commands=[
-            "cd {dir} && "
-            + (
-                " ".join(
-                    [
-                        "$(PROTOC)",
-                        "--proto_path=.",
-                        "--cpp_out=.",
-                        f"--descriptor_set_in={descriptorlist}",
-                    ]
-                    + protos
-                )
-            )
-        ],
-        label="PROTOCC",
-    )
-
-    headers = {f[1:]: join(r.dir, f[1:]) for f in outs if f.endswith(".pb.h")}
-
-    from build.c import cxxlibrary
-
-    cxxlibrary(
-        replaces=self,
-        srcs=[r],
-        deps=deps,
-        hdrs=headers,
-    )
-
-
-@Rule
-def protojava(self, name, srcs: Targets = [], deps: Targets = []):
-    outs = []
-
-    allsrcs = collectattrs(targets=srcs, name="protosrcs")
-    assert allsrcs, "no sources provided"
-    protos = []
-    for f in filenamesmatchingof(allsrcs, "*.proto"):
-        protos += [f]
-        srcs += [f]
-
-    descriptorlist = ":".join(
-        [abspath(f) for f in filenamesmatchingof(srcs + deps, "*.descriptor")]
-    )
-
-    r = simplerule(
-        name=f"{self.localname}_srcs",
-        cwd=self.cwd,
-        ins=protos,
-        outs=[f"={self.localname}.srcjar"],
-        deps=srcs + deps,
-        commands=[
-            "mkdir -p {dir}/srcs",
-            "cd {dir} && "
-            + (
-                " ".join(
-                    [
-                        "$(PROTOC)",
-                        "--proto_path=.",
-                        "--java_out=.",
-                        f"--descriptor_set_in={descriptorlist}",
-                    ]
-                    + protos
-                )
-            ),
-            "$(JAR) cf {outs[0]} -C {dir}/srcs .",
-        ],
-        traits={"srcjar"},
-        label="PROTOJAVA",
-    )
-
-    from build.java import javalibrary
-
-    javalibrary(
-        replaces=self,
-        deps=[r] + deps,
-    )
--- a/build/utils.py
+++ b/build/utils.py
@@ -1,93 +0,0 @@
-from build.ab import (
-    Rule,
-    Target,
-    Targets,
-    filenameof,
-    filenamesof,
-    cwdStack,
-    error,
-    simplerule,
-)
-from os.path import relpath, splitext, join, basename, isfile
-from glob import iglob
-import fnmatch
-import itertools
-
-
-def filenamesmatchingof(xs, pattern):
-    return fnmatch.filter(filenamesof(xs), pattern)
-
-
-def stripext(path):
-    return splitext(path)[0]
-
-
-def targetswithtraitsof(xs, trait):
-    return [t for t in xs if trait in t.traits]
-
-
-def collectattrs(*, targets, name, initial=[]):
-    s = set(initial)
-    for a in [t.args.get(name, []) for t in targets]:
-        s.update(a)
-    return sorted(s)
-
-
-def itemsof(pattern, root=None, cwd=None):
-    if not cwd:
-        cwd = cwdStack[-1]
-    if not root:
-        root = "."
-
-    pattern = join(cwd, pattern)
-    root = join(cwd, root)
-
-    result = {}
-    for f in iglob(pattern, recursive=True):
-        try:
-            if isfile(f):
-                result[relpath(f, root)] = f
-        except ValueError:
-            error(f"file '{f}' is not in root '{root}'")
-    return result
-
-
-@Rule
-def objectify(self, name, src: Target, symbol):
-    simplerule(
-        replaces=self,
-        ins=["build/_objectify.py", src],
-        outs=[f"={basename(filenameof(src))}.h"],
-        commands=["$(PYTHON) {ins[0]} {ins[1]} " + symbol + " > {outs}"],
-        label="OBJECTIFY",
-    )
-
-
-@Rule
-def test(
-    self,
-    name,
-    command: Target = None,
-    commands=None,
-    ins: Targets = None,
-    deps: Targets = None,
-    label="TEST",
-):
-    if command:
-        simplerule(
-            replaces=self,
-            ins=[command],
-            outs=["=sentinel"],
-            commands=["{ins[0]}", "touch {outs}"],
-            deps=deps,
-            label=label,
-        )
-    else:
-        simplerule(
-            replaces=self,
-            ins=ins,
-            outs=["=sentinel"],
-            commands=commands + ["touch {outs}"],
-            deps=deps,
-            label=label,
-        )
--- a/Show More
+++ b/Show More