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
725 changed files with 23432 additions and 108012 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,49 +2,28 @@ 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@v2
+    - uses: actions/checkout@v1
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v2
-      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-macos-current:
+  build-macos:
    runs-on: macos-latest
    steps:
    - uses: actions/checkout@v2
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v2
-      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 -j`nproc` -C fluxengine
-
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}
-        path: fluxengine/FluxEngine.pkg
+      run: make

  build-windows:
    runs-on: windows-latest
@@ -57,50 +36,19 @@ jobs:
        update: true
        msystem: MINGW32
        install: >-
-          diffutils
          make
-          mingw-w64-i686-binutils
-          mingw-w64-i686-fmt
-          mingw-w64-i686-gcc
+          ninja
          mingw-w64-i686-libusb
-          mingw-w64-i686-nsis
-          mingw-w64-i686-pkg-config
-          mingw-w64-i686-protobuf
-          mingw-w64-i686-python
          mingw-w64-i686-sqlite3
-          mingw-w64-i686-wxWidgets
          mingw-w64-i686-zlib
-          mingw-w64-i686-imagemagick
-          vim
+          mingw-w64-i686-gcc
          zip
-    - name: update-protobuf
-      run: |
-         pacman -U --noconfirm https://repo.msys2.org/mingw/mingw32/mingw-w64-i686-protobuf-21.9-1-any.pkg.tar.zst
-    - uses: actions/checkout@v2
+          mingw-w64-i686-protobuf
+          vim
+    - uses: actions/checkout@v1
      with:
-        repository: 'davidgiven/fluxengine'
-        path: 'fluxengine'
-    - uses: actions/checkout@v2
-      with:
-        repository: 'davidgiven/fluxengine-testdata'
-        path: 'fluxengine-testdata'
+        fetch-depth: 1
    - name: build
-      run: MAGICK_TIME_LIMIT=100 make -j`nproc` -C fluxengine
-
-    - name: nsis
      run: |
-        cd fluxengine
-        strip fluxengine.exe -o fluxengine-stripped.exe
-        strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe
-        makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi
+        make

-    - name: zip
-      run: |
-        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@v2
-      with:
-        name: ${{ github.event.repository.name }}.${{ github.sha }}
-        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:
@@ -21,54 +17,33 @@ jobs:
        update: true
        msystem: MINGW32
        install: >-
-          diffutils
          make
-          mingw-w64-i686-binutils
-          mingw-w64-i686-fmt
-          mingw-w64-i686-gcc
+          ninja
          mingw-w64-i686-libusb
-          mingw-w64-i686-nsis
-          mingw-w64-i686-pkg-config
-          mingw-w64-i686-protobuf
-          mingw-w64-i686-python
          mingw-w64-i686-sqlite3
-          mingw-w64-i686-wxWidgets
          mingw-w64-i686-zlib
-          mingw-w64-i686-imagemagick
-          vim
+          mingw-w64-i686-gcc
          zip
-    - uses: actions/checkout@v3
-
-    - name: update-protobuf
-      run: |
-         pacman -U --noconfirm https://repo.msys2.org/mingw/mingw32/mingw-w64-i686-protobuf-21.9-1-any.pkg.tar.zst
-
+          mingw-w64-i686-protobuf
+          vim
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 1
    - name: build
      run: |
-        MAGICK_TIME_LIMIT=100 make -j`nproc`
-
-    - name: nsis
-      run: |
-        strip fluxengine.exe -o fluxengine-stripped.exe
-        strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe
-        makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi
-
+        make
    - name: zip
      run: |
-        zip -9 fluxengine.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
-
+        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
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
    - name: delete-old-assets
      uses: mknejp/delete-release-assets@v1
      with:
@@ -76,55 +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.zip
-          fluxengine-installer.exe
        tag_name: dev
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  build-macos:
-    runs-on: macos-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: brew
-      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
-    - name: make
-      run: gmake
-
-    - 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.pkg
-        fail-if-no-assets: false
-
-    - name: release
-      uses: softprops/action-gh-release@v1
-      with:
-        name: Development build ${{ env.RELEASE_DATE }}
-        files: |
-          FluxEngine.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/97
+++ b/97
@@ -1,65 +1,64 @@
-CC = gcc
-CXX = g++ -std=c++17
-CFLAGS = -g -O3
-LDFLAGS =
+PACKAGES = zlib sqlite3 libusb-1.0 protobuf

-OBJ = .obj
-DESTDIR ?=
-PREFIX ?= /usr/local
-BINDIR ?= $(PREFIX)/bin
+export CFLAGS = -x c++ --std=c++14 -ffunction-sections -fdata-sections
+export LDFLAGS = -pthread

-# Special Windows settings.
+export COPTFLAGS = -Os
+export LDOPTFLAGS = -Os
+
+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/scripts+mkdocindex$(EXT)
-	@echo 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

-.PHONY: install install-bin
-install:: all install-bin
+all: .obj/build.ninja
+	@ninja -f .obj/build.ninja
+	@if command -v cscope > /dev/null; then cscope -bRq; fi

-install-bin:
-	@echo "INSTALL"
-	$(hide) install -D -v "$(OBJ)/src+fluxengine/src+fluxengine" "$(DESTDIR)$(BINDIR)/fluxengine"
-	$(hide) install -D -v "$(OBJ)/src/gui+gui/gui+gui" "$(DESTDIR)$(BINDIR)/fluxengine-gui"
-	$(hide) install -D -v "$(OBJ)/tools+brother120tool/tools+brother120tool" "$(DESTDIR)$(BINDIR)/brother120tool"
-	$(hide) install -D -v "$(OBJ)/tools+brother240tool/tools+brother240tool" "$(DESTDIR)$(BINDIR)/brother240tool"
-	$(hide) install -D -v "$(OBJ)/tools+upgrade-flux-file/tools+upgrade-flux-file" "$(DESTDIR)$(BINDIR)/upgrade-flux-file"
+clean:
+	@echo CLEAN
+	@rm -rf $(OBJDIR)
+
+.obj/build.ninja: mkninja.sh Makefile
+	@echo MKNINJA $@
+	@mkdir -p $(OBJDIR)
+	@sh $< > $@

-include build/ab.mk
--- a/README.md
+++ b/README.md
@@ -2,17 +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 2022-09-09, there's new [filesystem
-support](doc/filesystem.md). Read (and sometimes write) files directly from
-(and to) your disks, with eight different file systems! It works in the GUI,
-too, which is available for Linux (and other Unix clones), Windows and OSX. See
-the details below.
-
-<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?
 -----
@@ -35,13 +30,18 @@ Don't believe me? Watch the demo reel!
 </div>

 **New!** The FluxEngine client software now works with
-[Greaseweazle](https://github.com/keirf/Greaseweazle/wiki) hardware. So, if you
+[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)
+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?
 ------

@@ -65,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  |
-| [`q1`](doc/disk-q1.md) | Q1: Q1ish | 🦖 |  |  |
-| [`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  |
-| [`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

@@ -160,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.

@@ -214,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
@@ -237,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
@@ -2,10 +2,21 @@
 #define AESLANIER_H

 #define AESLANIER_RECORD_SEPARATOR 0x55555122
-#define AESLANIER_SECTOR_LENGTH 256
-#define AESLANIER_RECORD_SIZE (AESLANIER_SECTOR_LENGTH + 5)
+#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/decoder.cc
+++ b/arch/aeslanier/decoder.cc
@@ -1,64 +1,65 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
+#include "globals.h"
+#include "decoders/decoders.h"
 #include "aeslanier.h"
-#include "lib/crc.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/sector.h"
-#include "lib/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/agat/agat.cc
+++ b/arch/agat/agat.cc
@@ -1,20 +0,0 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
-#include "agat.h"
-#include "lib/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/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,89 +0,0 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
-#include "agat.h"
-#include "lib/crc.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/sector.h"
-#include "lib/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/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "agat.h"
-#include "lib/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/image.h"
-#include "lib/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/globals.h"
-#include "lib/decoders/decoders.h"
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
 #include "amiga.h"
-#include "lib/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/decoder.cc
+++ b/arch/amiga/decoder.cc
@@ -1,84 +1,67 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "amiga.h"
-#include "lib/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/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 "amiga.h"
-#include "lib/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/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/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,38 +1,34 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/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/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)
 {
@@ -52,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);
        }
    }

@@ -66,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/globals.h"
-#include "arch/apple2/apple2.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "lib/sector.h"
-#include "lib/readerwriter.h"
-#include "lib/image.h"
-#include "fmt/format.h"
-#include "lib/encoders/encoders.pb.h"
-#include <ctype.h>
-#include "lib/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/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,18 +1,19 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.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/sector.h"
-#include "lib/bytes.h"
-#include "lib/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;

@@ -33,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/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 "brother.h"
-#include "lib/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/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,27 +0,0 @@
-from build.c import cxxlibrary
-from build.protobuf import proto, protocc
-
-proto(
-    name="arch_proto",
-    srcs=[
-        "./aeslanier/aeslanier.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",
-        "./q1/q1.proto",
-        "./rolandd20/rolandd20.proto",
-        "./smaky6/smaky6.proto",
-        "./tids990/tids990.proto",
-        "./victor9k/victor9k.proto",
-        "./zilogmcz/zilogmcz.proto",
-    ],
-)
--- a/arch/c64/c64.cc
+++ b/arch/c64/c64.cc
@@ -1,28 +0,0 @@
-#include "lib/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
@@ -7,5 +7,7 @@ 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,33 +1,32 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "c64.h"
-#include "lib/crc.h"
-#include "lib/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)
 {
@@ -39,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);
@@ -53,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/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 "c64.h"
-#include "lib/crc.h"
-#include "lib/sector.h"
-#include "lib/readerwriter.h"
-#include "lib/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/layout.h"
 #include <ctype.h>
-#include "lib/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,33 +1,32 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "f85.h"
-#include "lib/crc.h"
-#include "lib/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)
 {
@@ -39,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);
@@ -53,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,23 +1,25 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "fb100.h"
-#include "lib/crc.h"
-#include "lib/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
@@ -97,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,31 +1,31 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
+#include "globals.h"
+#include "decoders/decoders.h"
 #include "ibm.h"
-#include "lib/crc.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/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/proto.h"
-#include "lib/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
@@ -33,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
@@ -41,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
@@ -49,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
@@ -57,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
@@ -73,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/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 "ibm.h"
-#include "lib/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/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/proto.h"
-#include "lib/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
@@ -3,29 +3,21 @@ syntax = "proto2";
 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,36 +1,35 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
+#include "track.h"
 #include "macintosh.h"
-#include "lib/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)
 {
@@ -44,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();
@@ -125,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/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 "macintosh.h"
-#include "lib/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/image.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
 #include "fmt/format.h"
-#include "lib/encoders/encoders.pb.h"
-#include "lib/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/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,294 +1,61 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "micropolis.h"
-#include "lib/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/globals.h"
-#include "micropolis.h"
-#include "lib/sector.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "lib/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/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,10 +1,12 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
-#include "arch/mx/mx.h"
-#include "lib/crc.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/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;
@@ -16,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,18 +11,15 @@
 * sure that the hardSectorId is correct.
 */

-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "northstar.h"
-#include "lib/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.
@@ -35,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/globals.h"
+#include "globals.h"
 #include "northstar.h"
-#include "lib/sector.h"
-#include "lib/bytes.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "lib/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/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/q1/decoder.cc
+++ b/arch/q1/decoder.cc
@@ -1,38 +0,0 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
-#include "arch/q1/q1.h"
-#include "lib/bytes.h"
-#include "lib/decoders/decoders.pb.h"
-#include "fmt/format.h"
-
-static const FluxPattern ADDRESS_RECORD(32, Q1_ADDRESS_RECORD);
-static const FluxPattern DATA_RECORD(32, Q1_DATA_RECORD);
-
-const FluxMatchers ANY_RECORD_PATTERN({&ADDRESS_RECORD, &DATA_RECORD});
-
-class Q1Decoder : public Decoder
-{
-public:
-    Q1Decoder(const DecoderProto& config): Decoder(config), _config(config.q1())
-    {
-    }
-
-    /* Search for FM or MFM sector record */
-    nanoseconds_t advanceToNextRecord() override
-    {
-        return seekToPattern(ANY_RECORD_PATTERN);
-    }
-
-    void decodeSectorRecord() override {}
-
-private:
-    const Q1DecoderProto& _config;
-};
-
-std::unique_ptr<Decoder> createQ1Decoder(const DecoderProto& config)
-{
-    return std::unique_ptr<Decoder>(new Q1Decoder(config));
-}
--- a/arch/q1/q1.h
+++ b/arch/q1/q1.h
@@ -1,9 +0,0 @@
-#ifndef Q1_H
-#define Q1_H
-
-#define Q1_ADDRESS_RECORD 0x55424954
-#define Q1_DATA_RECORD 0x55424955
-
-extern std::unique_ptr<Decoder> createQ1Decoder(const DecoderProto& config);
-
-#endif
--- a/arch/q1/q1.proto
+++ b/arch/q1/q1.proto
@@ -1,6 +0,0 @@
-syntax = "proto2";
-
-import "lib/common.proto";
-
-message Q1DecoderProto {}
-
--- a/arch/rolandd20/decoder.cc
+++ b/arch/rolandd20/decoder.cc
@@ -1,51 +0,0 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/crc.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/sector.h"
-#include "lib/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,154 +0,0 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
-#include "smaky6.h"
-#include "lib/bytes.h"
-#include "lib/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,6 +0,0 @@
-syntax = "proto2";
-
-import "lib/common.proto";
-
-message Smaky6DecoderProto {}
-
--- a/arch/tids990/decoder.cc
+++ b/arch/tids990/decoder.cc
@@ -1,11 +1,13 @@
-#include "lib/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "arch/tids990/tids990.h"
-#include "lib/crc.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
-#include "lib/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>

@@ -23,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,151 +1,130 @@
-#include "lib/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/crc.h"
-#include "lib/readerwriter.h"
-#include "lib/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>

 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
@@ -3,13 +3,12 @@ syntax = "proto2";
 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,33 +1,33 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "victor9k.h"
-#include "lib/crc.h"
-#include "lib/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)
 {
@@ -39,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);
@@ -54,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/globals.h"
-#include "lib/decoders/decoders.h"
-#include "lib/encoders/encoders.h"
-#include "victor9k.h"
-#include "lib/crc.h"
-#include "lib/sector.h"
-#include "lib/readerwriter.h"
-#include "lib/image.h"
-#include "fmt/format.h"
-#include "arch/victor9k/victor9k.pb.h"
-#include "lib/encoders/encoders.pb.h"
-#include "lib/layout.h"
-#include <ctype.h>
-#include "lib/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/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,55 +1,48 @@
-#include "lib/globals.h"
-#include "lib/fluxmap.h"
-#include "lib/decoders/fluxmapreader.h"
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "lib/decoders/decoders.h"
-#include "lib/sector.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "sector.h"
 #include "zilogmcz.h"
-#include "lib/bytes.h"
-#include "lib/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.lua
+++ b/build.lua
@@ -1,194 +0,0 @@
-vars.cflags = { "$(CFLAGS)" }
-vars.cxxflags = { "$(CXXFLAGS)" }
-vars.ldflags = { "-pthread" }
-
-include "build/protobuf.lua"
-include "build/dependency.lua"
-include "build/tests.lua"
-
-dependency {
-	name = "fmt_dep",
-	pkg_config = "fmt",
-}
-
-dependency {
-	name = "stb_dep",
-	pkg_config = "stb",
-	fallback = "dep/stb+stb"
-}
-
-dependency {
-	name = "protobuf_dep",
-	pkg_config = "protobuf"
-}
-
-dependency {
-	name = "zlib_dep",
-	pkg_config = "zlib"
-}
-
-proto_cc_library {
-	name = "config_lib",
-	srcs = {
-		"./lib/common.proto",
-		"./lib/config.proto",
-		"./lib/decoders/decoders.proto",
-		"./lib/drive.proto",
-		"./lib/encoders/encoders.proto",
-		"./lib/fl2.proto",
-		"./lib/fluxsink/fluxsink.proto",
-		"./lib/fluxsource/fluxsource.proto",
-		"./lib/imagereader/imagereader.proto",
-		"./lib/imagewriter/imagewriter.proto",
-		"./lib/mapper.proto",
-		"./lib/usb/usb.proto",
-		"./arch/aeslanier/aeslanier.proto",
-		"./arch/agat/agat.proto",
-		"./arch/amiga/amiga.proto",
-		"./arch/apple2/apple2.proto",
-		"./arch/brother/brother.proto",
-		"./arch/c64/c64.proto",
-		"./arch/f85/f85.proto",
-		"./arch/fb100/fb100.proto",
-		"./arch/ibm/ibm.proto",
-		"./arch/macintosh/macintosh.proto",
-		"./arch/micropolis/micropolis.proto",
-		"./arch/mx/mx.proto",
-		"./arch/northstar/northstar.proto",
-		"./arch/rolandd20/rolandd20.proto",
-		"./arch/tids990/tids990.proto",
-		"./arch/victor9k/victor9k.proto",
-		"./arch/zilogmcz/zilogmcz.proto",
-	}
-}
-
-clibrary {
-	name = "protocol_lib",
-	hdrs = { "./protocol.h" }
-}
-
-clibrary {
-	name = "libfluxengine",
-	srcs = {
-		"./arch/aeslanier/decoder.cc",
-		"./arch/agat/agat.cc",
-		"./arch/agat/decoder.cc",
-		"./arch/amiga/amiga.cc",
-		"./arch/amiga/decoder.cc",
-		"./arch/amiga/encoder.cc",
-		"./arch/apple2/decoder.cc",
-		"./arch/apple2/encoder.cc",
-		"./arch/brother/decoder.cc",
-		"./arch/brother/encoder.cc",
-		"./arch/c64/c64.cc",
-		"./arch/c64/decoder.cc",
-		"./arch/c64/encoder.cc",
-		"./arch/f85/decoder.cc",
-		"./arch/fb100/decoder.cc",
-		"./arch/ibm/decoder.cc",
-		"./arch/ibm/encoder.cc",
-		"./arch/macintosh/decoder.cc",
-		"./arch/macintosh/encoder.cc",
-		"./arch/micropolis/decoder.cc",
-		"./arch/micropolis/encoder.cc",
-		"./arch/mx/decoder.cc",
-		"./arch/northstar/decoder.cc",
-		"./arch/northstar/encoder.cc",
-		"./arch/rolandd20/rolandd20.cc",
-		"./arch/tids990/decoder.cc",
-		"./arch/tids990/encoder.cc",
-		"./arch/victor9k/decoder.cc",
-		"./arch/victor9k/encoder.cc",
-		"./arch/zilogmcz/decoder.cc",
-		"./lib/bitmap.cc",
-		"./lib/bytes.cc",
-		"./lib/crc.cc",
-		"./lib/csvreader.cc",
-		"./lib/decoders/decoders.cc",
-		"./lib/decoders/fluxdecoder.cc",
-		"./lib/decoders/fluxmapreader.cc",
-		"./lib/decoders/fmmfm.cc",
-		"./lib/encoders/encoders.cc",
-		"./lib/flags.cc",
-		"./lib/fluxmap.cc",
-		"./lib/fluxsink/aufluxsink.cc",
-		"./lib/fluxsink/fl2fluxsink.cc",
-		"./lib/fluxsink/fluxsink.cc",
-		"./lib/fluxsink/hardwarefluxsink.cc",
-		"./lib/fluxsink/scpfluxsink.cc",
-		"./lib/fluxsink/vcdfluxsink.cc",
-		"./lib/fluxsource/cwffluxsource.cc",
-		"./lib/fluxsource/erasefluxsource.cc",
-		"./lib/fluxsource/fl2fluxsource.cc",
-		"./lib/fluxsource/fluxsource.cc",
-		"./lib/fluxsource/hardwarefluxsource.cc",
-		"./lib/fluxsource/kryoflux.cc",
-		"./lib/fluxsource/kryofluxfluxsource.cc",
-		"./lib/fluxsource/scpfluxsource.cc",
-		"./lib/fluxsource/testpatternfluxsource.cc",
-		"./lib/globals.cc",
-		"./lib/hexdump.cc",
-		"./lib/image.cc",
-		"./lib/imagereader/d64imagereader.cc",
-		"./lib/imagereader/d88imagereader.cc",
-		"./lib/imagereader/dimimagereader.cc",
-		"./lib/imagereader/diskcopyimagereader.cc",
-		"./lib/imagereader/fdiimagereader.cc",
-		"./lib/imagereader/imagereader.cc",
-		"./lib/imagereader/imdimagereader.cc",
-		"./lib/imagereader/imgimagereader.cc",
-		"./lib/imagereader/jv3imagereader.cc",
-		"./lib/imagereader/nfdimagereader.cc",
-		"./lib/imagereader/nsiimagereader.cc",
-		"./lib/imagereader/td0imagereader.cc",
-		"./lib/imagewriter/d64imagewriter.cc",
-		"./lib/imagewriter/d88imagewriter.cc",
-		"./lib/imagewriter/diskcopyimagewriter.cc",
-		"./lib/imagewriter/imagewriter.cc",
-		"./lib/imagewriter/imgimagewriter.cc",
-		"./lib/imagewriter/ldbsimagewriter.cc",
-		"./lib/imagewriter/nsiimagewriter.cc",
-		"./lib/imagewriter/rawimagewriter.cc",
-		"./lib/imginputoutpututils.cc",
-		"./lib/ldbs.cc",
-		"./lib/logger.cc",
-		"./lib/mapper.cc",
-		"./lib/proto.cc",
-		"./lib/readerwriter.cc",
-		"./lib/sector.cc",
-		"./lib/usb/fluxengineusb.cc",
-		"./lib/usb/greaseweazle.cc",
-		"./lib/usb/greaseweazleusb.cc",
-		"./lib/usb/serial.cc",
-		"./lib/usb/usb.cc",
-		"./lib/usb/usbfinder.cc",
-		"./lib/utils.cc",
-		"protocol.h",
-	},
-	deps = {
-		"+config_lib",
-		"+protocol_lib",
-		"+fmt_dep",
-		"+protobuf_dep",
-		"+zlib_dep",
-		"dep/libusbp+libusbp",
-	},
-	dep_cflags = { "-Ilib", "-Iarch", "-I." },
-	vars = {
-		["+cflags"] = { "-Ilib", "-Iarch", "-I." }
-	}
-}
-
-installable {
-	name = "all",
-	map = {
-		["fluxengine"] = "src+fluxengine",
-		["fluxengine-gui"] = "src/gui+fluxengine",
-		["brother120tool"] = "tools+brother120tool",
-		["brother240tool"] = "tools+brother240tool",
-		["upgrade-flux-file"] = "tools+upgrade-flux-file",
-	}
-}
-
-include "tests/build.lua"
-
--- a/build.py
+++ b/build.py
@@ -1,315 +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")
-package(name="sqlite3_lib", package="sqlite3")
-
-clibrary(name="protocol", hdrs={"protocol.h": "./protocol.h"})
-
-proto(name="fl2_proto", srcs=["lib/fl2.proto"])
-protocc(name="fl2_proto_lib", srcs=["+fl2_proto"])
-
-cxxlibrary(
-    name="lib",
-    srcs=[
-        "./lib/bitmap.cc",
-        "./lib/bytes.cc",
-        "./lib/config.cc",
-        "./lib/crc.cc",
-        "./lib/csvreader.cc",
-        "./lib/decoders/decoders.cc",
-        "./lib/decoders/fluxdecoder.cc",
-        "./lib/decoders/fluxmapreader.cc",
-        "./lib/decoders/fmmfm.cc",
-        "./lib/encoders/encoders.cc",
-        "./lib/fl2.cc",
-        "./lib/flags.cc",
-        "./lib/fluxmap.cc",
-        "./lib/fluxsink/a2rfluxsink.cc",
-        "./lib/fluxsink/aufluxsink.cc",
-        "./lib/fluxsink/fl2fluxsink.cc",
-        "./lib/fluxsink/fluxsink.cc",
-        "./lib/fluxsink/hardwarefluxsink.cc",
-        "./lib/fluxsink/scpfluxsink.cc",
-        "./lib/fluxsink/vcdfluxsink.cc",
-        "./lib/fluxsource/a2rfluxsource.cc",
-        "./lib/fluxsource/catweasel.cc",
-        "./lib/fluxsource/cwffluxsource.cc",
-        "./lib/fluxsource/dmkfluxsource.cc",
-        "./lib/fluxsource/erasefluxsource.cc",
-        "./lib/fluxsource/fl2fluxsource.cc",
-        "./lib/fluxsource/fluxsource.cc",
-        "./lib/fluxsource/flx.cc",
-        "./lib/fluxsource/flxfluxsource.cc",
-        "./lib/fluxsource/hardwarefluxsource.cc",
-        "./lib/fluxsource/kryoflux.cc",
-        "./lib/fluxsource/kryofluxfluxsource.cc",
-        "./lib/fluxsource/memoryfluxsource.cc",
-        "./lib/fluxsource/scpfluxsource.cc",
-        "./lib/fluxsource/testpatternfluxsource.cc",
-        "./lib/globals.cc",
-        "./lib/hexdump.cc",
-        "./lib/image.cc",
-        "./lib/imagereader/d64imagereader.cc",
-        "./lib/imagereader/d88imagereader.cc",
-        "./lib/imagereader/dimimagereader.cc",
-        "./lib/imagereader/diskcopyimagereader.cc",
-        "./lib/imagereader/fdiimagereader.cc",
-        "./lib/imagereader/imagereader.cc",
-        "./lib/imagereader/imdimagereader.cc",
-        "./lib/imagereader/imgimagereader.cc",
-        "./lib/imagereader/jv3imagereader.cc",
-        "./lib/imagereader/nfdimagereader.cc",
-        "./lib/imagereader/nsiimagereader.cc",
-        "./lib/imagereader/td0imagereader.cc",
-        "./lib/imagewriter/d64imagewriter.cc",
-        "./lib/imagewriter/d88imagewriter.cc",
-        "./lib/imagewriter/diskcopyimagewriter.cc",
-        "./lib/imagewriter/imagewriter.cc",
-        "./lib/imagewriter/imdimagewriter.cc",
-        "./lib/imagewriter/imgimagewriter.cc",
-        "./lib/imagewriter/ldbsimagewriter.cc",
-        "./lib/imagewriter/nsiimagewriter.cc",
-        "./lib/imagewriter/rawimagewriter.cc",
-        "./lib/layout.cc",
-        "./lib/ldbs.cc",
-        "./lib/logger.cc",
-        "./lib/proto.cc",
-        "./lib/readerwriter.cc",
-        "./lib/sector.cc",
-        "./lib/usb/fluxengineusb.cc",
-        "./lib/usb/greaseweazle.cc",
-        "./lib/usb/greaseweazleusb.cc",
-        "./lib/usb/serial.cc",
-        "./lib/usb/usb.cc",
-        "./lib/usb/usbfinder.cc",
-        "./lib/utils.cc",
-        "./lib/vfs/acorndfs.cc",
-        "./lib/vfs/amigaffs.cc",
-        "./lib/vfs/appledos.cc",
-        "./lib/vfs/applesingle.cc",
-        "./lib/vfs/brother120fs.cc",
-        "./lib/vfs/cbmfs.cc",
-        "./lib/vfs/cpmfs.cc",
-        "./lib/vfs/fatfs.cc",
-        "./lib/vfs/fluxsectorinterface.cc",
-        "./lib/vfs/imagesectorinterface.cc",
-        "./lib/vfs/lif.cc",
-        "./lib/vfs/machfs.cc",
-        "./lib/vfs/microdos.cc",
-        "./lib/vfs/philefs.cc",
-        "./lib/vfs/prodos.cc",
-        "./lib/vfs/roland.cc",
-        "./lib/vfs/smaky6fs.cc",
-        "./lib/vfs/vfs.cc",
-        "./lib/vfs/zdos.cc",
-        "./arch/aeslanier/decoder.cc",
-        "./arch/agat/agat.cc",
-        "./arch/agat/decoder.cc",
-        "./arch/agat/encoder.cc",
-        "./arch/amiga/amiga.cc",
-        "./arch/amiga/decoder.cc",
-        "./arch/amiga/encoder.cc",
-        "./arch/apple2/decoder.cc",
-        "./arch/apple2/encoder.cc",
-        "./arch/brother/decoder.cc",
-        "./arch/brother/encoder.cc",
-        "./arch/c64/c64.cc",
-        "./arch/c64/decoder.cc",
-        "./arch/c64/encoder.cc",
-        "./arch/f85/decoder.cc",
-        "./arch/fb100/decoder.cc",
-        "./arch/ibm/decoder.cc",
-        "./arch/ibm/encoder.cc",
-        "./arch/macintosh/decoder.cc",
-        "./arch/macintosh/encoder.cc",
-        "./arch/micropolis/decoder.cc",
-        "./arch/micropolis/encoder.cc",
-        "./arch/mx/decoder.cc",
-        "./arch/northstar/decoder.cc",
-        "./arch/northstar/encoder.cc",
-        "./arch/q1/decoder.cc",
-        "./arch/rolandd20/decoder.cc",
-        "./arch/smaky6/decoder.cc",
-        "./arch/tids990/decoder.cc",
-        "./arch/tids990/encoder.cc",
-        "./arch/victor9k/decoder.cc",
-        "./arch/victor9k/encoder.cc",
-        "./arch/zilogmcz/decoder.cc",
-    ],
-    hdrs={
-        "arch/ibm/ibm.h": "./arch/ibm/ibm.h",
-        "arch/apple2/data_gcr.h": "./arch/apple2/data_gcr.h",
-        "arch/apple2/apple2.h": "./arch/apple2/apple2.h",
-        "arch/smaky6/smaky6.h": "./arch/smaky6/smaky6.h",
-        "arch/tids990/tids990.h": "./arch/tids990/tids990.h",
-        "arch/zilogmcz/zilogmcz.h": "./arch/zilogmcz/zilogmcz.h",
-        "arch/amiga/amiga.h": "./arch/amiga/amiga.h",
-        "arch/f85/data_gcr.h": "./arch/f85/data_gcr.h",
-        "arch/f85/f85.h": "./arch/f85/f85.h",
-        "arch/mx/mx.h": "./arch/mx/mx.h",
-        "arch/aeslanier/aeslanier.h": "./arch/aeslanier/aeslanier.h",
-        "arch/northstar/northstar.h": "./arch/northstar/northstar.h",
-        "arch/brother/data_gcr.h": "./arch/brother/data_gcr.h",
-        "arch/brother/brother.h": "./arch/brother/brother.h",
-        "arch/brother/header_gcr.h": "./arch/brother/header_gcr.h",
-        "arch/macintosh/data_gcr.h": "./arch/macintosh/data_gcr.h",
-        "arch/macintosh/macintosh.h": "./arch/macintosh/macintosh.h",
-        "arch/agat/agat.h": "./arch/agat/agat.h",
-        "arch/fb100/fb100.h": "./arch/fb100/fb100.h",
-        "arch/victor9k/data_gcr.h": "./arch/victor9k/data_gcr.h",
-        "arch/victor9k/victor9k.h": "./arch/victor9k/victor9k.h",
-        "arch/rolandd20/rolandd20.h": "./arch/rolandd20/rolandd20.h",
-        "arch/micropolis/micropolis.h": "./arch/micropolis/micropolis.h",
-        "arch/q1/q1.h": "./arch/q1/q1.h",
-        "arch/c64/data_gcr.h": "./arch/c64/data_gcr.h",
-        "arch/c64/c64.h": "./arch/c64/c64.h",
-        "lib/a2r.h": "./lib/a2r.h",
-        "lib/bitmap.h": "./lib/bitmap.h",
-        "lib/bytes.h": "./lib/bytes.h",
-        "lib/config.h": "./lib/config.h",
-        "lib/crc.h": "./lib/crc.h",
-        "lib/csvreader.h": "./lib/csvreader.h",
-        "lib/decoders/decoders.h": "./lib/decoders/decoders.h",
-        "lib/decoders/fluxdecoder.h": "./lib/decoders/fluxdecoder.h",
-        "lib/decoders/fluxmapreader.h": "./lib/decoders/fluxmapreader.h",
-        "lib/decoders/rawbits.h": "./lib/decoders/rawbits.h",
-        "lib/encoders/encoders.h": "./lib/encoders/encoders.h",
-        "lib/scp.h": "./lib/scp.h",
-        "lib/fl2.h": "./lib/fl2.h",
-        "lib/flags.h": "./lib/flags.h",
-        "lib/flux.h": "./lib/flux.h",
-        "lib/fluxmap.h": "./lib/fluxmap.h",
-        "lib/fluxsink/fluxsink.h": "./lib/fluxsink/fluxsink.h",
-        "lib/fluxsource/catweasel.h": "lib/fluxsource/catweasel.h",
-        "lib/fluxsource/fluxsource.h": "lib/fluxsource/fluxsource.h",
-        "lib/fluxsource/flx.h": "lib/fluxsource/flx.h",
-        "lib/fluxsource/kryoflux.h": "lib/fluxsource/kryoflux.h",
-        "lib/globals.h": "./lib/globals.h",
-        "lib/image.h": "./lib/image.h",
-        "lib/imagereader/imagereader.h": "./lib/imagereader/imagereader.h",
-        "lib/imagewriter/imagewriter.h": "./lib/imagewriter/imagewriter.h",
-        "lib/layout.h": "./lib/layout.h",
-        "lib/ldbs.h": "./lib/ldbs.h",
-        "lib/logger.h": "./lib/logger.h",
-        "lib/proto.h": "./lib/proto.h",
-        "lib/readerwriter.h": "./lib/readerwriter.h",
-        "lib/sector.h": "./lib/sector.h",
-        "lib/usb/greaseweazle.h": "./lib/usb/greaseweazle.h",
-        "lib/usb/usb.h": "./lib/usb/usb.h",
-        "lib/usb/usbfinder.h": "./lib/usb/usbfinder.h",
-        "lib/utils.h": "./lib/utils.h",
-        "lib/vfs/applesingle.h": "./lib/vfs/applesingle.h",
-        "lib/vfs/sectorinterface.h": "./lib/vfs/sectorinterface.h",
-        "lib/vfs/vfs.h": "./lib/vfs/vfs.h",
-    },
-    deps=[
-        "+fl2_proto_lib",
-        "+protocol",
-        "lib+config_proto_lib",
-        "dep/adflib",
-        "dep/agg",
-        "dep/fatfs",
-        "dep/hfsutils",
-        "dep/libusbp",
-        "dep/stb",
-    ],
-)
-
-corpustests = []
-if not glob("../fluxengine-testdata/data"):
-    print("fluxengine-testdata not found; skipping corpus tests")
-else:
-    corpus = [
-        ("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", "", ""),
-        ("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,42 +0,0 @@
-ifeq ($(findstring 4.,$(MAKE_VERSION)),)
-$(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
-hide = @
-PKG_CONFIG ?= pkg-config
-ECHO ?= echo
-
-ifeq ($(OS), Windows_NT)
-	EXT ?= .exe
-endif
-EXT ?=
-
-include $(OBJ)/build.mk
-
-.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) bin
-
-export PYTHONHASHSEED = 1
-build-files = $(shell find . -name 'build.py') build/*.py config.py
-$(OBJ)/build.mk: Makefile $(build-files)
-	@echo "AB"
-	@mkdir -p $(OBJ)
-	$(hide) $(PYTHON) -X pycache_prefix=$(OBJ) build/ab.py -t +all -o $@ \
-		build.py || rm -f $@
-
--- a/build/ab.py
+++ b/build/ab.py
@@ -1,486 +0,0 @@
-from collections.abc import Iterable, Sequence
-from os.path import *
-from types import SimpleNamespace
-import argparse
-import copy
-import functools
-import importlib
-import importlib.abc
-import importlib.util
-import inspect
-import re
-import sys
-import types
-import pathlib
-import builtins
-import os
-
-defaultGlobals = {}
-targets = {}
-unmaterialisedTargets = set()
-materialisingStack = []
-outputFp = None
-cwdStack = [""]
-
-sys.path += ["."]
-old_import = builtins.__import__
-
-
-def new_import(name, *args, **kwargs):
-    if name not in sys.modules:
-        path = name.replace(".", "/") + ".py"
-        if isfile(path):
-            sys.stderr.write(f"loading {path}\n")
-            loader = importlib.machinery.SourceFileLoader(name, path)
-
-            spec = importlib.util.spec_from_loader(
-                name, loader, origin="built-in"
-            )
-            module = importlib.util.module_from_spec(spec)
-            sys.modules[name] = module
-            cwdStack.append(dirname(path))
-            spec.loader.exec_module(module)
-            cwdStack.pop()
-
-    return old_import(name, *args, **kwargs)
-
-
-builtins.__import__ = new_import
-
-
-class ABException(BaseException):
-    pass
-
-
-class ParameterList(Sequence):
-    def __init__(self, parent=[]):
-        self.data = parent
-
-    def __getitem__(self, i):
-        return self.data[i]
-
-    def __len__(self):
-        return len(self.data)
-
-    def __str__(self):
-        return " ".join(self.data)
-
-    def __add__(self, other):
-        newdata = self.data.copy() + other
-        return ParameterList(newdata)
-
-    def __repr__(self):
-        return f"<PList: {self.data}>"
-
-
-class Invocation:
-    name = None
-    callback = None
-    types = None
-    ins = None
-    outs = None
-    binding = None
-
-    def materialise(self, replacing=False):
-        if self in unmaterialisedTargets:
-            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:
-                self.args = {}
-                for k, v in self.binding.arguments.items():
-                    if k != "kwargs":
-                        t = self.types.get(k, None)
-                        if t:
-                            v = t(v).convert(self)
-                        self.args[k] = v
-                    else:
-                        for kk, vv in v.items():
-                            t = self.types.get(kk, None)
-                            if t:
-                                vv = t(vv).convert(self)
-                            self.args[kk] = vv
-
-                # Actually call the callback.
-
-                cwdStack.append(self.cwd)
-                self.callback(**self.args)
-                cwdStack.pop()
-            except BaseException as e:
-                print(
-                    f"Error materialising {self} ({id(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:
-                unmaterialisedTargets.remove(self)
-
-            materialisingStack.pop()
-
-    def __repr__(self):
-        return "<Invocation %s>" % self.name
-
-
-def Rule(func):
-    sig = inspect.signature(func)
-
-    @functools.wraps(func)
-    def wrapper(*, name=None, replaces=None, **kwargs):
-        cwd = None
-        if name:
-            if ("+" in name) and not name.startswith("+"):
-                (cwd, _) = name.split("+", 1)
-        if not cwd:
-            cwd = cwdStack[-1]
-
-        if name:
-            i = Invocation()
-            if name.startswith("./"):
-                name = join(cwd, name)
-            elif "+" not in name:
-                name = cwd + "+" + name
-
-            i.name = name
-            i.localname = name.split("+")[-1]
-
-            if name in targets:
-                raise ABException(f"target {i.name} has already been defined")
-            targets[name] = i
-        elif replaces:
-            i = replaces
-            name = i.name
-        else:
-            raise ABException("you must supply either name or replaces")
-
-        i.cwd = cwd
-        i.types = func.__annotations__
-        i.callback = func
-        setattr(i, func.__name__, SimpleNamespace())
-
-        i.binding = sig.bind(name=name, self=i, **kwargs)
-        i.binding.apply_defaults()
-
-        unmaterialisedTargets.add(i)
-        if replaces:
-            i.materialise(replacing=True)
-        return i
-
-    defaultGlobals[func.__name__] = wrapper
-    return wrapper
-
-
-class Type:
-    def __init__(self, value):
-        self.value = value
-
-
-class Targets(Type):
-    def convert(self, invocation):
-        value = self.value
-        if type(value) is str:
-            value = [value]
-        if type(value) is list:
-            value = targetsof(value, cwd=invocation.cwd)
-        return value
-
-
-class Target(Type):
-    def convert(self, invocation):
-        value = self.value
-        if not value:
-            return None
-        return targetof(value, cwd=invocation.cwd)
-
-
-class TargetsMap(Type):
-    def convert(self, invocation):
-        value = self.value
-        if type(value) is dict:
-            return {
-                k: targetof(v, cwd=invocation.cwd) for k, v in value.items()
-            }
-        raise ABException(f"wanted a dict of targets, got a {type(value)}")
-
-
-def flatten(*xs):
-    def recurse(xs):
-        for x in xs:
-            if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
-                yield from recurse(x)
-            else:
-                yield x
-
-    return list(recurse(xs))
-
-
-def fileinvocation(s):
-    i = Invocation()
-    i.name = s
-    i.outs = [s]
-    targets[s] = i
-    return i
-
-
-def targetof(s, cwd):
-    if isinstance(s, Invocation):
-        s.materialise()
-        return s
-
-    if s in targets:
-        t = targets[s]
-        t.materialise()
-        return t
-
-    if s.startswith(".+"):
-        s = cwd + s[1:]
-    elif s.startswith("./"):
-        s = normpath(join(cwd, s))
-    elif s.endswith("/"):
-        return fileinvocation(s)
-    elif s.startswith("$"):
-        return fileinvocation(s)
-
-    if "+" not in s:
-        if isdir(s):
-            s = s + "+" + basename(s)
-        else:
-            return fileinvocation(s)
-
-    (path, target) = s.split("+", 2)
-    loadbuildfile(join(path, "build.py"))
-    if not s in targets:
-        raise ABException(f"build file at {path} doesn't contain +{target}")
-    i = targets[s]
-    i.materialise()
-    return i
-
-
-def targetsof(*xs, cwd):
-    return flatten([targetof(x, cwd) for x in flatten(xs)])
-
-
-def filenamesof(*xs):
-    s = []
-    for t in flatten(xs):
-        if type(t) == str:
-            t = normpath(t)
-            s += [t]
-        else:
-            s += [f for f in [normpath(f) for f in filenamesof(t.outs)]]
-    return s
-
-
-def targetnamesof(*xs):
-    s = []
-    for x in flatten(xs):
-        if type(x) == str:
-            x = normpath(x)
-            if x not in s:
-                s += [x]
-        else:
-            if x.name not in s:
-                s += [x.name]
-    return s
-
-
-def filenameof(x):
-    xs = filenamesof(x)
-    if len(xs) != 1:
-        raise ABException("expected a single item")
-    return xs[0]
-
-
-def stripext(path):
-    return splitext(path)[0]
-
-
-def emit(*args):
-    outputFp.write(" ".join(flatten(args)))
-    outputFp.write("\n")
-
-
-def templateexpand(s, invocation):
-    class Converter:
-        def __getitem__(self, key):
-            if key == "self":
-                return invocation
-            f = filenamesof(invocation.args[key])
-            if isinstance(f, Sequence):
-                f = ParameterList(f)
-            return f
-
-    return eval("f%r" % s, invocation.callback.__globals__, Converter())
-
-
-def emitter_rule(name, ins, outs, deps=[]):
-    emit("")
-    emit(".PHONY:", name)
-    if outs:
-        emit(name, ":", filenamesof(outs), ";")
-        emit(filenamesof(outs), "&:", filenamesof(ins), filenamesof(deps))
-    else:
-        emit(name, "&:", filenamesof(ins), filenamesof(deps))
-
-
-def emitter_endrule(name):
-    pass
-
-
-def emitter_label(s):
-    emit("\t$(hide)", "$(ECHO)", s)
-
-
-def emitter_exec(cs):
-    for c in cs:
-        emit("\t$(hide)", c)
-
-
-def unmake(*ss):
-    return [
-        re.sub(r"\$\(([^)]*)\)", r"$\1", s) for s in flatten(filenamesof(ss))
-    ]
-
-
-@Rule
-def simplerule(
-    self,
-    name,
-    ins: Targets = [],
-    outs=[],
-    deps: Targets = [],
-    commands=[],
-    label="RULE",
-    **kwargs,
-):
-    self.ins = ins
-    self.outs = outs
-    self.deps = deps
-    emitter_rule(self.name, ins + deps, outs)
-    emitter_label(templateexpand("{label} {name}", self))
-
-    dirs = []
-    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 += [templateexpand(c, self)]
-    emitter_exec(cs)
-    emitter_endrule(self.name)
-
-
-@Rule
-def normalrule(
-    self,
-    name=None,
-    ins: Targets = [],
-    deps: Targets = [],
-    outs=[],
-    label="RULE",
-    objdir=None,
-    commands=[],
-    **kwargs,
-):
-    objdir = objdir or join("$(OBJ)", name)
-
-    self.normalrule.objdir = objdir
-    simplerule(
-        replaces=self,
-        ins=ins,
-        deps=deps,
-        outs=[join(objdir, f) for f in outs],
-        label=label,
-        commands=commands,
-        **kwargs,
-    )
-
-
-@Rule
-def export(self, name=None, items: TargetsMap = {}, deps: Targets = []):
-    cs = []
-    self.ins = items.values()
-    self.outs = []
-    for dest, src in items.items():
-        destf = filenameof(dest)
-        dir = dirname(destf)
-        if dir:
-            cs += ["mkdir -p " + dir]
-
-        srcs = filenamesof(src)
-        if len(srcs) != 1:
-            raise ABException(
-                "a dependency of an export must have exactly one output file"
-            )
-
-        cs += ["cp %s %s" % (srcs[0], destf)]
-        self.outs += [destf]
-
-    emitter_rule(self.name, items.values(), self.outs, deps)
-    emitter_label(f"EXPORT {self.name}")
-
-    emitter_exec(cs)
-
-    if self.outs:
-        emit("clean::")
-        emit("\t$(hide) rm -f " + (" ".join(filenamesof(self.outs))))
-    self.outs += deps
-
-    emitter_endrule(self.name)
-
-
-def loadbuildfile(filename):
-    filename = filename.replace("/", ".").removesuffix(".py")
-    builtins.__import__(filename)
-
-
-def load(filename):
-    loadbuildfile(filename)
-    callerglobals = inspect.stack()[1][0].f_globals
-    for k, v in defaultGlobals.items():
-        callerglobals[k] = v
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-o", "--output")
-    parser.add_argument("files", nargs="+")
-    parser.add_argument("-t", "--targets", action="append")
-    args = parser.parse_args()
-    if not args.targets:
-        raise ABException("no targets supplied")
-
-    global outputFp
-    outputFp = open(args.output, "wt")
-
-    for k in ("Rule", "Targets", "load", "filenamesof", "stripext"):
-        defaultGlobals[k] = globals()[k]
-
-    global __name__
-    sys.modules["build.ab"] = sys.modules[__name__]
-    __name__ = "build.ab"
-
-    for f in args.files:
-        loadbuildfile(f)
-
-    for t in flatten([a.split(",") for a in args.targets]):
-        if t not in targets:
-            raise ABException("target %s is not defined" % t)
-        targets[t].materialise()
-    emit("AB_LOADED = 1\n")
-
-
-main()
--- a/build/build.lua
+++ b/build/build.lua
@@ -1,251 +0,0 @@
-local OBJDIR = "$(OBJDIR)"
-
-local function objdir(e)
-	return concatpath(OBJDIR, e.cwd, e.name)
-end
-
-definerule("normalrule",
-	{
-		ins = { type="targets" },
-		deps = { type="targets", default={} },
-		outs = { type="targets", default={} },
-		outleaves = { type="strings" },
-		label = { type="string", optional=true },
-		objdir = { type="string", optional=true },
-		commands = { type="strings" },
-	},
-	function (e)
-		local dir = e.objdir or objdir(e)
-		local realouts = {}
-		for _, v in pairs(e.outleaves) do
-			realouts[#realouts+1] = concatpath(dir, v)
-		end
-
-		local vars = inherit(e.vars, {
-			dir = dir
-		})
-
-		local result = simplerule {
-			name = e.name,
-			ins = e.ins,
-			deps = e.deps,
-			outs = concat(realouts, filenamesof(e.outs)),
-			label = e.label,
-			commands = e.commands,
-			vars = vars,
-		}
-		result.dir = dir
-		return result
-	end
-)
-
-local function is_clike(f)
-	return f:find("%.c$") or f:find("%.cc$") or f:find("%.cpp$")
-end
-
-definerule("cfile",
-	{
-		srcs = { type="targets" },
-		deps = { type="targets", default={} }
-	},
-	function (e)
-		local cflags = e.vars.cflags
-		local cxxflags = e.vars.cxxflags
-		for _, target in ipairs(targetsof(e.deps)) do
-			if target.is.clibrary then
-				cflags = concat(cflags, target.dep_cflags)
-				cxxflags = concat(cxxflags, target.dep_cxxflags)
-			end
-		end
-
-		local src = filter(filenamesof(e.srcs), is_clike)
-		local cmd
-		local cxx = false
-		if src[1]:find("%.c$") then
-			cmd = "$(CC) -c -o %{outs[1]} %{ins[1]} %{hdrpaths} %{cflags}"
-		else
-			cmd = "$(CXX) -c -o %{outs[1]} %{ins[1]} %{hdrpaths} %{cflags} %{cxxflags}"
-			cxx = true
-		end
-
-		local outleaf = basename(e.name)..".o"
-		local rule = normalrule {
-			name = e.name,
-			cwd = e.cwd,
-			ins = e.srcs,
-			deps = e.deps,
-			outleaves = {outleaf},
-			label = e.label,
-			commands = cmd,
-			vars = {
-				hdrpaths = {},
-				cflags = cflags,
-				cxxflags = cxxflags,
-			}
-		}
-
-		rule.is.cxxfile = cxx
-		return rule
-	end
-)
-
-local function do_cfiles(e)
-	local outs = {}
-	local srcs = filenamesof(e.srcs)
-	for _, f in ipairs(sorted(filter(srcs, is_clike))) do
-		local ofile
-		if f:find(OBJDIR, 1, true) == 1 then
-			ofile = e.name.."/"..f:sub(#OBJDIR+1)..".o"
-		else
-			ofile = e.name.."/"..f..".o"
-		end
-		outs[#outs+1] = cfile {
-			name = ofile,
-			srcs = { f },
-			deps = e.deps
-		}
-	end
-	return outs
-end
-
-definerule("clibrary",
-	{
-		srcs = { type="targets", default={} },
-		deps = { type="targets", default={} },
-		hdrs = { type="targets", default={} },
-		dep_cflags = { type="strings", default={} },
-		dep_cxxflags = { type="strings", default={} },
-		dep_ldflags = { type="strings", default={} },
-		dep_libs = { type="strings", default={} },
-	},
-	function (e)
-		local ins = do_cfiles(e)
-		local cxx = false
-		for _, f in ipairs(ins) do
-			if f.is.cxxfile then
-				cxx = true
-				break
-			end
-		end
-
-		local mkdirs = {}
-		local copies = {}
-		local outs = {}
-		local function copy_file(src, dest)
-			mkdirs[#mkdirs+1] = "mkdir -p %{dir}/"..dirname(dest)
-			copies[#copies+1] = "cp "..src.." %{dir}/"..dest
-			outs[#outs+1] = objdir(e).."/"..dest
-		end
-
-		local deps = {}
-		for k, v in pairs(e.hdrs) do
-			deps[#deps+1] = v
-			if type(k) == "number" then
-				v = filenamesof(v)
-				for _, v in ipairs(v) do
-					if not startswith(e.cwd, v) then
-						error(string.format("filename '%s' is not local to '%s' --- "..
-							"you'll have to specify the output filename manually", v, e.cwd))
-					end
-					copy_file(v, v:gsub("^"..e.cwd, ""))
-				end
-			else
-				v = filenamesof(v)
-				if #v ~= 1 then
-					error("each mapped hdrs item can only cope with a single file")
-				end
-				copy_file(v[1], k)
-			end
-		end
-
-		ins = sorted(filenamesof(ins))
-		local has_ar = (#ins ~= 0)
-		local lib = normalrule {
-			name = e.name,
-			cwd = e.cwd,
-			ins = sorted(filenamesof(ins)),
-			deps = deps,
-			outs = outs,
-			outleaves = { e.name..".a" },
-			label = e.label,
-			commands = {
-				sorted(mkdirs),
-				sorted(copies),
-				has_ar and "rm -f %{outs[1]} && $(AR) cqs %{outs[1]} %{ins}" or {},
-			}
-		}
-		
-		lib.dep_cflags = concat(e.dep_cflags, "-I"..lib.dir)
-		lib.dep_cxxflags = e.dep_cxxflags
-		lib.dep_ldflags = e.dep_ldflags
-		lib.dep_libs = concat(e.dep_libs, has_ar and matching(filenamesof(lib), "%.a$") or {})
-		lib.dep_cxx = cxx
-
-		for _, d in pairs(targetsof(e.deps)) do
-			lib.dep_cflags = concat(lib.dep_cflags, d.dep_cflags)
-			lib.dep_cxxflags = concat(lib.dep_cxxflags, d.dep_cxxflags)
-			lib.dep_ldflags = concat(lib.dep_ldflags, d.dep_ldflags)
-			lib.dep_libs = concat(lib.dep_libs, d.dep_libs)
-			lib.dep_cxx = lib.dep_cxx or d.dep_cxx
-		end
-
-		return lib
-	end
-)
-
-definerule("cprogram",
-	{
-		srcs = { type="targets", default={} },
-		deps = { type="targets", default={} },
-	},
-	function (e)
-		local deps = e.deps
-		local ins = {}
-		local cxx = false
-
-		if (#e.srcs > 0) then
-			local objs = do_cfiles(e)
-			for _, obj in pairs(objs) do
-				if obj.is.cxxfile then
-					cxx = true
-				end
-				ins[#ins+1] = obj
-			end
-		end
-
-		local libs = {}
-		local cflags = {}
-		local cxxflags = {}
-		local ldflags = {}
-		for _, lib in pairs(e.deps) do
-			cflags = concat(cflags, lib.dep_cflags)
-			cxxflags = concat(cxxflags, lib.dep_cxxflags)
-			ldflags = concat(ldflags, lib.dep_ldflags)
-			libs = concat(libs, lib.dep_libs)
-			cxx = cxx or lib.dep_cxx
-		end
-
-		local command
-		if cxx then
-			command = "$(CXX) $(LDFLAGS) %{ldflags} -o %{outs[1]} %{ins} %{libs} %{libs}"
-		else
-			command = "$(CC) $(LDFLAGS) %{ldflags} -o %{outs[1]} %{ins} %{libs} %{libs}"
-		end
-
-		return normalrule {
-			name = e.name,
-			cwd = e.cwd,
-			deps = deps,
-			ins = ins,
-			outleaves = { e.name },
-			commands = { command },
-			vars = {
-				cflags = cflags,
-				cxxflags = cxxflags,
-				ldflags = ldflags,
-				libs = libs,
-			}
-		}
-	end
-)
-
--- a/build/c.py
+++ b/build/c.py
@@ -1,265 +0,0 @@
-from os.path import basename, join
-from build.ab import (
-    ABException,
-    Rule,
-    Targets,
-    TargetsMap,
-    filenameof,
-    flatten,
-    filenamesof,
-    normalrule,
-    stripext,
-)
-from os.path import *
-from types import SimpleNamespace
-
-
-def cfileimpl(self, name, srcs, deps, suffix, commands, label, kind, cflags):
-    outleaf = stripext(basename(filenameof(srcs[0]))) + suffix
-
-    normalrule(
-        replaces=self,
-        ins=srcs,
-        deps=deps,
-        outs=[outleaf],
-        label=label,
-        commands=commands,
-        cflags=cflags,
-    )
-
-
-@Rule
-def cfile(
-    self,
-    name,
-    srcs: Targets = [],
-    deps: Targets = [],
-    cflags=[],
-    suffix=".o",
-    commands=["$(CC) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"],
-    label="CC",
-):
-    cfileimpl(self, name, srcs, deps, suffix, commands, label, "cfile", cflags)
-
-
-@Rule
-def cxxfile(
-    self,
-    name,
-    srcs: Targets = [],
-    deps: Targets = [],
-    cflags=[],
-    suffix=".o",
-    commands=["$(CXX) -c -o {outs[0]} {ins[0]} $(CFLAGS) {cflags}"],
-    label="CXX",
-):
-    cfileimpl(
-        self, name, srcs, deps, suffix, commands, label, "cxxfile", cflags
-    )
-
-
-def findsources(name, srcs, deps, cflags, filerule):
-    objs = []
-    for s in flatten(srcs):
-        objs += [
-            filerule(
-                name=join(name, f.removeprefix("$(OBJ)/")),
-                srcs=[f],
-                deps=deps,
-                cflags=cflags,
-            )
-            for f in filenamesof(s)
-            if f.endswith(".c") or f.endswith(".cc") or f.endswith(".cpp")
-        ]
-        if any(f.endswith(".o") for f in filenamesof(s)):
-            objs += [s]
-
-    return objs
-
-
-def libraryimpl(
-    self, name, srcs, deps, hdrs, cflags, ldflags, commands, label, kind
-):
-    if not srcs and not hdrs:
-        raise ABException(
-            "clibrary contains no sources and no exported headers"
-        )
-
-    libraries = [d for d in deps if hasattr(d, "clibrary")]
-    for library in libraries:
-        if library.clibrary.cflags:
-            cflags += library.clibrary.cflags
-        if library.clibrary.ldflags:
-            ldflags += library.clibrary.ldflags
-
-    for f in filenamesof(srcs):
-        if f.endswith(".h"):
-            deps += [f]
-
-    hdrcs = []
-    hdrins = list(hdrs.values())
-    hdrouts = []
-    i = 0
-    for dest, src in hdrs.items():
-        s = filenamesof(src)
-        if len(s) != 1:
-            raise ABException(
-                "a dependency of an export must have exactly one output file"
-            )
-
-        hdrcs += ["cp {ins[" + str(i) + "]} {outs[" + str(i) + "]}"]
-        hdrouts += [dest]
-        i = i + 1
-
-    if not hasattr(self, "clibrary"):
-        self.clibrary = SimpleNamespace()
-    if srcs:
-        hr = None
-        if hdrcs:
-            hr = normalrule(
-                name=f"{name}_hdrs",
-                ins=hdrins,
-                outs=hdrouts,
-                label="HEADERS",
-                commands=hdrcs,
-            )
-            hr.materialise()
-
-        actualsrcs = findsources(
-            name,
-            srcs,
-            deps + ([f"{name}_hdrs"] if hr else []),
-            cflags + ([f"-I{hr.normalrule.objdir}"] if hr else []),
-            kind,
-        )
-
-        normalrule(
-            replaces=self,
-            ins=actualsrcs,
-            outs=[basename(name) + ".a"],
-            label=label,
-            commands=commands if actualsrcs else [],
-        )
-
-        self.clibrary.ldflags = ldflags
-        self.clibrary.cflags = ["-I" + hr.normalrule.objdir] if hr else []
-    else:
-        r = normalrule(
-            replaces=self,
-            ins=hdrins,
-            outs=hdrouts,
-            label="HEADERS",
-            commands=hdrcs,
-        )
-        r.materialise()
-
-        self.clibrary.ldflags = ldflags
-        self.clibrary.cflags = ["-I" + r.normalrule.objdir]
-
-
-@Rule
-def clibrary(
-    self,
-    name,
-    srcs: Targets = [],
-    deps: Targets = [],
-    hdrs: TargetsMap = {},
-    cflags=[],
-    ldflags=[],
-    commands=["$(AR) cqs {outs[0]} {ins}"],
-    label="LIB",
-):
-    return libraryimpl(
-        self, name, srcs, deps, hdrs, cflags, ldflags, commands, label, cfile
-    )
-
-
-@Rule
-def cxxlibrary(
-    self,
-    name,
-    srcs: Targets = [],
-    deps: Targets = [],
-    hdrs: TargetsMap = {},
-    cflags=[],
-    ldflags=[],
-    commands=["$(AR) cqs {outs[0]} {ins}"],
-    label="LIB",
-):
-    return libraryimpl(
-        self, name, srcs, deps, hdrs, cflags, ldflags, commands, label, cxxfile
-    )
-
-
-def programimpl(
-    self, name, srcs, deps, cflags, ldflags, commands, label, filerule, kind
-):
-    libraries = [d for d in deps if hasattr(d, "clibrary")]
-    for library in libraries:
-        if library.clibrary.cflags:
-            cflags += library.clibrary.cflags
-        if library.clibrary.ldflags:
-            ldflags += library.clibrary.ldflags
-
-    deps += [f for f in filenamesof(srcs) if f.endswith(".h")]
-
-    ars = [f for f in filenamesof(libraries) if f.endswith(".a")]
-    normalrule(
-        replaces=self,
-        ins=(findsources(name, srcs, deps, cflags, filerule) + ars + ars),
-        outs=[basename(name) + "$(EXT)"],
-        deps=deps,
-        label=label,
-        commands=commands,
-        ldflags=ldflags,
-    )
-
-
-@Rule
-def cprogram(
-    self,
-    name,
-    srcs: Targets = [],
-    deps: Targets = [],
-    cflags=[],
-    ldflags=[],
-    commands=["$(CC) -o {outs[0]} {ins} {ldflags} $(LDFLAGS)"],
-    label="CLINK",
-):
-    programimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cfile,
-        "cprogram",
-    )
-
-
-@Rule
-def cxxprogram(
-    self,
-    name,
-    srcs: Targets = [],
-    deps: Targets = [],
-    cflags=[],
-    ldflags=[],
-    commands=["$(CXX) -o {outs[0]} {ins} {ldflags} $(LDFLAGS)"],
-    label="CXXLINK",
-):
-    programimpl(
-        self,
-        name,
-        srcs,
-        deps,
-        cflags,
-        ldflags,
-        commands,
-        label,
-        cxxfile,
-        "cxxprogram",
-    )
--- a/build/pkg.py
+++ b/build/pkg.py
@@ -1,38 +0,0 @@
-from build.ab import Rule, emit, Target
-from types import SimpleNamespace
-import os
-import subprocess
-
-emit(
-    """
-PKG_CONFIG ?= pkg-config
-PACKAGES := $(shell $(PKG_CONFIG) --list-all | cut -d' ' -f1)
-"""
-)
-
-
-@Rule
-def package(self, name, package=None, fallback: Target = None):
-    emit("ifeq ($(filter %s, $(PACKAGES)),)" % package)
-    if fallback:
-        emit(f"PACKAGE_CFLAGS_{package} :=", fallback.clibrary.cflags)
-        emit(f"PACKAGE_LDFLAGS_{package} := ", fallback.clibrary.ldflags)
-        emit(f"PACKAGE_DEP_{package} := ", fallback.name)
-    else:
-        emit(f"$(error Required package '{package}' not installed.)")
-    emit("else")
-    emit(
-        f"PACKAGE_CFLAGS_{package} := $(shell $(PKG_CONFIG) --cflags {package})"
-    )
-    emit(
-        f"PACKAGE_LDFLAGS_{package} := $(shell $(PKG_CONFIG) --libs {package})"
-    )
-    emit(f"PACKAGE_DEP_{package} := ")
-    emit("endif")
-
-    self.clibrary = SimpleNamespace()
-    self.clibrary.cflags = [f"$(PACKAGE_CFLAGS_{package})"]
-    self.clibrary.ldflags = [f"$(PACKAGE_LDFLAGS_{package})"]
-
-    self.ins = []
-    self.outs = [f"$(PACKAGE_DEP_{package})"]
--- a/build/protobuf.py
+++ b/build/protobuf.py
@@ -1,65 +0,0 @@
-from os.path import join
-from build.ab import Rule, Targets, emit, normalrule, filenamesof, flatten
-from build.c import cxxlibrary
-import build.pkg
-from types import SimpleNamespace
-
-emit(
-    """
-PROTOC ?= protoc
-ifeq ($(filter protobuf, $(PACKAGES)),)
-$(error Required package 'protobuf' not installed.)"
-endif
-"""
-)
-
-
-@Rule
-def proto(self, name, srcs: Targets = [], deps: Targets = []):
-    normalrule(
-        replaces=self,
-        ins=srcs,
-        outs=[f"{name}.descriptor"],
-        deps=deps,
-        commands=[
-            "$(PROTOC) --include_source_info --descriptor_set_out={outs[0]} {ins}"
-        ],
-        label="PROTO",
-    )
-    self.proto.srcs = filenamesof(srcs) + flatten(
-        [s.proto.srcs for s in flatten(deps)]
-    )
-
-
-@Rule
-def protocc(self, name, srcs: Targets = [], deps: Targets = []):
-    outs = []
-    protos = []
-    for f in flatten([s.proto.srcs for s in flatten(srcs + deps)]):
-        if f.endswith(".proto"):
-            cc = f.replace(".proto", ".pb.cc")
-            h = f.replace(".proto", ".pb.h")
-            protos += [f]
-            srcs += [f]
-            outs += [cc, h]
-
-    r = normalrule(
-        name=f"{name}_srcs",
-        ins=protos,
-        outs=outs,
-        deps=deps,
-        commands=["$(PROTOC) --cpp_out={self.normalrule.objdir} {ins}"],
-        label="PROTOCC",
-    )
-
-    r.materialise()
-    headers = {
-        f: join(r.normalrule.objdir, f) for f in outs if f.endswith(".pb.h")
-    }
-
-    cxxlibrary(
-        replaces=self,
-        srcs=[f"{name}_srcs"],
-        hdrs=headers,
-        cflags=[f"-I{r.normalrule.objdir}"],
-    )
--- a/build/tests.lua
+++ b/build/tests.lua
@@ -1,18 +0,0 @@
-definerule("test",
-	{
-		srcs = { type="targets", default={} },
-	},
-	function (e)
-		if vars.TESTS == "yes" then
-			normalrule {
-				name = e.name,
-				ins = e.srcs,
-				outleaves = { "log.txt" },
-				commands = {
-					"%{ins} > %{outs}",
-				}
-			}
-		end
-	end
-)
-
--- a/build/utils.py
+++ b/build/utils.py
@@ -1,43 +0,0 @@
-from build.ab import Rule, normalrule, Target, filenameof, Targets
-from os.path import basename
-
-
-@Rule
-def objectify(self, name, src: Target, symbol):
-    normalrule(
-        replaces=self,
-        ins=["build/_objectify.py", src],
-        outs=[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 = [],
-    deps: Targets = [],
-    label="TEST",
-):
-    if command:
-        normalrule(
-            replaces=self,
-            ins=[command],
-            outs=["sentinel"],
-            commands=["{ins[0]}", "touch {outs}"],
-            deps=deps,
-            label=label,
-        )
-    else:
-        normalrule(
-            replaces=self,
-            ins=ins,
-            outs=["sentinel"],
-            commands=commands + ["touch {outs}"],
-            deps=deps,
-            label=label,
-        )
--- a/config.py
+++ b/config.py
@@ -1,5 +0,0 @@
-import platform
-
-windows = platform.system() == "Windows"
-osx = platform.system() == "Darwin"
-unix = not windows
--- a/dep/adflib/.gitignore
+++ b/dep/adflib/.gitignore
@@ -1,45 +0,0 @@
-# Object files
-*.o
-*.lo
-
-# Libraries
-.libs
-*.lib
-*.a
-*.la
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# generated by autogen.sh
-INSTALL
-Makefile.in
-aclocal.m4
-autom4te.cache
-compile
-config.guess
-config.h.in
-config.sub
-configure
-depcomp
-install-sh
-ltmain.sh
-missing
-
-# generated by configure
-.deps
-Makefile
-adflib.pc
-config.h
-config.log
-config.status
-libtool
-stamp-h1
--- a/dep/adflib/AUTHORS
+++ b/dep/adflib/AUTHORS
@@ -1,13 +0,0 @@
-
-The main developper is 
- Laurent Clévy (laurent.clevy@club-internet.fr)
-
-Contributors are:
- Bjarne Viksoe 
-   (C++ wrapper, lot of bug fixes)
- Gary Harris 
-   (bug fixes and W32 support)
- Dan Sutherland 
-   (bug fixes and W32 support)
-
-See CHANGES.txt for detailed contributions.
--- a/dep/adflib/COPYING
+++ b/dep/adflib/COPYING
@@ -1,339 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
--- a/dep/adflib/README
+++ b/dep/adflib/README
@@ -1,128 +0,0 @@
-
-
-The ADFlib is a free, portable and open implementation of the Amiga filesystem.
-
-initial release in 1999
-
-It supports :
- floppy dumps
- multiple partitions harddisk dumps
- UAE hardfiles
- WinNT devices with the 'native driver' written by Dan Sutherland
- mount/unmount/create a device (real one or a dump file),
- mount/unmount/create a volume (partition),
- create/open/close/delete/rename/undel a file,
- read/write bytes from/to a file,
- create/delete/rename/move/undel a directory,
- get directory contents, change current directory, get parent directory
- use dir cache to get directory contents.
-
-
-It is written in portable C, and support the WinNT platform to access
-real drives.
-
-See also : 
-https://packages.debian.org/source/sid/unadf
-https://www.cvedetails.com/cve/CVE-2016-1243/
-https://www.cvedetails.com/cve/CVE-2016-1244/
-
---
-
-unADF is a unzip like for .ADF files :
-
-
-unadf [-lrcsp -v n] dumpname.adf [files-with-path] [-d extractdir]
-    -l : lists root directory contents
-    -r : lists directory tree contents
-    -c : use dircache data (must be used with -l)
-    -s : display entries logical block pointer (must be used with -l)
-    -m : display file comments, if exists (must be used with -l)
-
-    -v n : mount volume #n instead of default #0 volume
-
-    -p : send extracted files to pipe (unadf -p dump.adf Pics/pic1.gif | xv -)
-    -d dir : extract to 'dir' directory
-
-
-
-Credits:
--------
-
-main design and code             Laurent Clevy
-Bug fixes and C++ wrapper        Bjarke Viksoe (adfwrapper.h)
-WinNT native driver              Dan Sutherland and Gary Harris
-
-
-New versions and contact e-mail can be found at : 
-
-http://lclevy.free.fr/adflib
-
-
-
-COMPILATION
-----------
-
-The following commands should automatically detect the system 
-configuration and build the library and examples/unadf, 
-the ADF extractor binary.
-
-	./autogen.sh
-	./configure
-	make
-
-
-
-FEATURES NEEDING FURTHER TESTS
------------------------------
-
-* Native driver
-
-The NATIV_DIR variable is used to choose the (only one) target platform
-of the native driver. The default is :
-
-NATIV_DIR = ./Generic
-
-This one do not give access to any real device. The other one available is
-Win32, to access real devices under WinNT.
-
-
-* Win32DLL
-
-The 'prefix.h' is used to create the Win32 DLL version of the library.
-If the WIN32DLL variable is defined in the library code, public functions
-are preceded by the '__declspec(dllexport)' directive. If this same
-variable is defined, the '__declspec(dllimport)' is put before the functions
-prototypes in the 'adflib.h' library include file.
-
-
-
-
-FILES
-----
-
-AUTHORS   Contributors
-README			The file you are reading
-TODO			Future improvements and bugfixes
-CHANGES			Detailed changes
-src/			main library files
-src/win32/		WinNT native driver
-src/generic/		native files templates
-boot/			Bootblocks that might by used to put on floppy disks
-doc/			The library developpers documentation 
-doc/FAQ/		The Amiga Filesystem explained
-examples/		unadf.c
-
-
-Possible bugs
-------------
-
- in dircache updates
- when a volume is becoming full
- lost memory releases
-
-
-Please report any bugs or mistakes in the documentation !
-
-
-
-Have fun anyway !
--- a/Show More
+++ b/Show More