Teach the Amiga decoder how many sectors to expect on each track.

Merge pull request #140 from davidgiven/sectors
Fix a couple of annoying but minor issues
2025-10-24 11:11:02 -07:00 · 2020-03-09 12:54:29 +00:00 · 2020-02-28 00:08:11 +01:00 · 2020-02-27 22:32:27 +01:00 · 2020-02-27 22:30:05 +01:00 · 2020-02-24 21:55:27 +01:00
65 changed files with 2714 additions and 937 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -15,7 +15,7 @@ install:

 build_script:
  - make
-  - zip -9 fluxengine.zip fluxengine.exe brother120tool.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

 artifacts:
  - path: fluxengine.zip
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -7,6 +7,8 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 1
    - name: apt
      run: sudo apt install libusb-1.0-0-dev libsqlite3-dev ninja-build
    - name: make
@@ -16,6 +18,8 @@ jobs:
    runs-on: macos-latest
    steps:
    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 1
    - name: brew
      run: brew install sqlite pkg-config libusb ninja
    - name: make
@@ -26,9 +30,12 @@ jobs:
 #    steps:
 #    - uses: numworks/setup-msys2@v1
 #      with:
-#        msystem: MSYS
+#        path-type: inherit
 #    - uses: actions/checkout@v1
 #    - name: pacman
-#      run: msys2do pacman -S --noconfirm --needed make ninja mingw-w64-i686-libusb mingw-w64-i686-sqlite3 mingw-w64-i686-zlib mingw-w64-i686-gcc zip
-#    - name: make
-#      run: msys2do make
+#      run: |
+#        msys2do pacman -S --noconfirm --needed make ninja mingw-w64-i686-libusb mingw-w64-i686-sqlite3 mingw-w64-i686-zlib mingw-w64-i686-gcc zip
+#    - name: build
+#      run: |
+#        msys2do make
+
--- a/FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
+++ b/FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
@@ -1,254 +1,254 @@
-:4000000000800020110000003510000035100000064A08B5136843F020031360044B1A6803F53F5302331A6001F022F8E8460040FA46004010B5054C237833B9044B13B181
-:400040000448AFF300800123237010BD6881FF1F0000000098380000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF0000000071
-:400080006C81FF1F98380000C880FF1F0000000072B6034A13680133136062B6704700BF8881FF1F0A4A0B4B516801310B40002BBEBF03F1FF3363F00F0301335360516800
-:4000C0009368994202BF024B01221A73704700BF8881FF1F0F0000800A4A0B4B916801310B40002BBEBF03F1FF3363F00F030133936091685368994202BF024B01221A7379
-:40010000704700BF8881FF1F0F000080024B012200205A7302F052B98881FF1F10B5C4B2204601F067F90128FAD110BD10B50446094B9A7B987382421CBF0022DA7310F0CE
-:40014000010F14BF0220012002F064FE6008BDE8104002F059BE00BF8881FF1F70B5C4B220460E4601F04EF9314605460246204601F00AFA204601F03DF90128FAD02846D9
-:4001800070BD000038B50B4C257C55B9A07BFFF7CDFF012002F0A8F84FF47A7002F0BAFAE5732368636101232374BDE8384002F0EFBA00BF8881FF1F38B50446C5B22846A0
-:4001C00002F09EF8062002F0BBFA44F00200C0B202F096F8062002F0B3FA284602F090F8BDE83840062002F095BA10B5642402F081F820B10120BDE81040FFF7DDBF0120FF
-:40020000FFF7DAFF013CF2D1F4E7000038B5044D0024285D013402F043FA102CF9D138BDA081FF1F08B502F05DFC002002F066FC02F078FC02F082FC80B208BD10B5044637
-:40024000012002F075F8642002F064FAFFF7EAFF2080002002F06CF8642002F05BFAFFF7E1FF608010BD08B502F068FD002002F071FD02F083FD02F08DFD80B208BD10B5A9
-:400280000446FFF7B2FF322002F044FAFFF7EBFF20800020FFF790FF322002F03BFAFFF7E2FF608010BD0FB400B593B014AB53F8042B402102A8019302F0D6FE02A802F0B4
-:4002C00084F802F08EF813B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF71DFF62782146BDE81040042001F0DAB8AA38000007B50023ADF804308DF80600B0
-:40030000032301A88DF80530FFF7E2FF03B05DF804FB0000F8B51D4C0646FFF733FFE37B03B156B91A48FFF7BEFFFFF75EFF01200023E073A36202F003FA3246A16A1548D8
-:40034000FFF7B1FF114D0027A36A9E4216D001F0D1FF00B1AF62A36A9E4205DD0020FFF72BFFAB6A013305E005DA0120FFF724FFAB6A013BAB6202F00BFAE5E7322002F041
-:40038000C9F9BDE8F8400448FFF78DBF8881FF1FB7380000BE380000DB3800002DE9F04F9BB062B602F05EFABE49042002F082FABD4801F0ABFFBD4802F04EFDBC4801F07F
-:4003C000DFFF02F02FFC02F001FB002002F022FD01F0FAFF0221002000F0C2FFB54D0321084602F0B5F92E462C4602F0D1F92B7C73B16A692B689B1A41F28832934207D9C7
-:40040000002001F071FF002002F004FD00232B7400F0DEFF18B9A848FFF745FF04E000F0DDFF0028F7D109E000F0D2FF0028FBD0A248FFF738FF032001F0FAF8032000F031
-:40044000D9FF0128D1D1A07BFFF770FE9C490320FFF784FE94F82C109A48FFF724FF94F82C30023B122B00F2DF83DFE813F01300DD031C00DD032200DD033A00DD035E002E
-:40048000DD039301DD031E03DD033D03DD034303DD034F0303238DF828308DF8293008238DF82A302EE394F82E00FFF733FF864B25E3FFF767FE00236373637B002BFCD06F
-:4004C000002373733268637B002BFCD0336807218DF828109B1A04218DF82910ADF82A3010E30220FFF71AFE4FF000090DF1280A4FF480780027C8EB0903DA1907F80A2095
-:400500000137402FF9D10220FFF708FE3A465146022000F0C7FFB8F10108EBD109F10109B9F1400FE4D1694BBAE294F82E0001F0FFFEA06AFFF7EEFE02F002FD644BDFF8C2
-:4005400094811A78002742F004021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F0F0FC0220FFF7D7FD41F6FF734FF480420121022002F051FC84F807
-:400580006C0002F073F808F807000137102FF8D1DFF844A100270AF159081FFA88F90137102F14BF3A4600221AF8010F22440623127E402102F08EF84A4646F243419AF86E
-:4005C000000002F099F809F14009102F1FFA89F9E5D100237373637B002BFCD00027142239460AA8777302F00BFD40230D934FF0FF337760B36037737368DFF8E0903344B4
-:40060000197E96F86C00CDF8309001F0E7FF96F86C0001F0A5FF012196F86C0001F078FF636813B96B7B002BFAD0002794F82FA0A76094F80CB0BBF1000F6AD102F0A8F8EF
-:400640006B7B43B1BAF1010A85F80DB003D160E02B7B002B5DD1A26863689A42F8D04FF0000BA3680AA808EB83135B440A93CBF140030B9300F0F8FA0B9B0137C3F1400304
-:400680009B440D9B5FFA8BFB9BBB022000F0B2FE012825D0637B002B3BD12B7B002BF4D037E000BF910000000D010000A5000000D90000008881FF1FE9380000FC38000085
-:4006C000B481FF1F063900009C3800009E38000093640040A081FF1F9F81FF1FF885FF1F4022B849022000F0DDFE4023CDF830900D93BBF13F0FB4D9A268B34B0132134082
-:40070000002BBEBF03F1FF3363F00F030133A3608FE7042194F86C0001F06CFF94F86C0001F078FF0028F9D10AA800F0D1FA0220FFF7F4FC337B63B90D9A402A06D0C2F135
-:40074000400292B29F49022000F0ACFE0220FFF7E5FC0D9A32F0400203D11146022000F0A1FEFFF753FD237B33B19848FFF79BFD0220FFF7BFFD06E0954B09A81B88ADF8A6
-:400780002430FFF7A5FD627B3946237B9148FFF78AFD4CE29048FFF786FD276B17F03F0701D0032041E2012001F0C8FD95F82E0001F0BEFD02F0C4FB884BDFF824821A78B7
-:4007C00002F0FB021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F0B3FBA86AFFF796FD01214FF4804341F6FF72084601F0A8FD85F86C0001F036FF15
-:4008000008F807000137102FF8D1DFF8D891002709F159031FFA83F807930137102F14BF3A46002219F8010F22440523127E402101F050FF414646F2475299F8000001F0E0
-:400840005BFF08F14008102F1FFA88F8E5D10027BB46B946BA46336B4FF0FF389B09142239460AA877600593C6F80880377302F0C7FB402301200D9300F0DAFECDF81880AD
-:400880006268514B01321340002BBCBF03F1FF3363F00F03A168B8BF01338B4200F0A480BAF1000F07D0237B002B40F0B0806B7B002B40F0AC800B9B002B34D1B9F1000FD0
-:4008C0000BD07F223F495A540133402BFAD10A910B9328E0BAF1000F06D1012000F08AFD01288046F6D107E0237B002B40F08F806B7B002BF1D08AE03249FFF72FFC81462E
-:40090000304B0B9040460A9300F092FEB9F13F0F07F1010706DD059BDB1BD3F1000949EB030900E0C1460B9BDBB16368079A0AA802EB83120D9BC3F1400313440C9300F042
-:40094000D6F90D9B6BB96A681F4B01321340002BBEBF03F1FF3363F00F030133636040230D93A36801333FD16B680F2B3CD14FF00008C5F8088001F015FD85F80C80AB68D9
-:4009800095F86C002B44197E01F028FE95F86C0001F0E6FD012195F86C0001F0B9FD85F80D80637B002BFCD04FF00008012086F80D8001F003FD404601F0C0FCCDF81880BF
-:4009C00015E000BFF885FF1F0F00008015390000A03800002F3900004239000097650040A081FF1F9F81FF1FBAF1000F05D0237B6BB96B7B5BB94FF0010AA368069A934242
-:400A00003FF43EAFAB680BF1010B069338E701F0CFFC012001F092FC002001F0CFFC042194F86C0001F0E6FD94F86C0001F0F2FD0028F9D196F86C0001F080FD737B327BCD
-:400A40000293012303920193CDF800905B463A4605997B48FFF727FCB9F1000F16D1059BBB420ADD012000F0C5FC01288046F6D17449FFF773FB3F2803DC012000F0ECFD97
-:400A800004E0404600F0D4FD0137E8E7FFF7BEFB6D48FFF708FC237B0BB10220C5E06B4B1B8809A8ADF824302DE094F82E0001F03FFCA06AFFF72EFC6548FFF7F4FB0023B0
-:400AC0006373637B002BFCD0012001F077FC00237373637B002BFCD0002001F06FFC5D48FFF7E1FB5C4B0AE00020E073FFF712FC5A4B04E094F82E00FFF718FB584B1B885B
-:400B0000ADF828300AA8FFF7E3FB90E0237C3BB1002001F0E9FB002002F07CF900232B7402F0FEF8002002F0A1F82A2701F0CCFF002001F06FFF3A4600210AA802F060FA3B
-:400B400015238DF828308DF8297001F021FE002001F0CAFB002002F05DF9C82001F0DAFD0DEB0700FFF76AFB0DF13E00FFF787FB01F00EFE012002F04DF9322001F0CAFDD6
-:400B80000DF12E00FFF75AFB0DF14200FFF777FB012001F0A9FB4FF4967001F0BBFD01F0F7FD0DF13600FFF749FB0DF14A00FFF766FB002001F098FB4FF4967001F0AAFDF7
-:400BC00001F0E6FD022002F025F9322001F0A2FD0DF13200FFF732FB0DF14600FFF74FFB012001F081FB4FF4967001F093FD01F0CFFD0DF13A00FFF721FB0DF14E00FFF795
-:400C00003EFB002001F070FB4FF4967001F082FD01F0BEFD002002F0FDF80023E37302F001F801F0D3FE6DE70120FFF763FB032000F0FEFC0B48FFF736FBFFF7D6BB00BFD7
-:400C40004C390000F885FF1F7C390000A23800008B39000099390000A4380000A6380000A8380000A639000010B54268002A2ED0C368002B2BD00368048A591C01601B786C
-:400C8000013A13F0800F817C42601DBF03F0010242EA84030231083114BF43F0020343EA0423817414BF03820382837C072BDCD9028A083B42FA03F38268511C8160137004
-:400CC000C368013BC360837C083B8374CDE710BD07B5827C42B102AA002102F8011D026001224260FFF7C0FF03B05DF804FB30B543686BB3C2685AB3827C072A0CD80468D7
-:400D000090F91050611C01602178013B41EA05210832018243608274827C018AA2F108042141CBB2090608D5C3F3801363F07F03023A03F08103827402E08474002BD7D00A
-:400D40008268511C81601370C368013BC360CFE730BD00002DE9F04172B644F21A118E4B61221A70A3F5F06301221A8019244FF443729C709A80894A1B231370518044F633
-:400D80001F611371D1801372854A864B92E80300062283F8002283E80300522203F580731A70814B814A1B78814EDBB2137040F61802804B00251A8041F2512223F8022C4E
-:400DC00033784FF4F07003F0010343EA450502F0AFF8013C05F003052ED0032DF0D1764B4FF480721A8007221A70744A002548211570917002221D705D7103F8032C042291
-:400E0000DA716F4A6F4C13786F4E43F00F03137012F8013C062743F0030302F8013C2378012243F0800323705B4B1A70674A137843F02003137000E0FEE707FB0563002163
-:400E40009A881868013502F0DBF8072DF5D16048604E002550F8041F05F1105303F1560221F0FF075733C9B20B4452005B0002329A4206D012F802EC12F801CC0EF807C0B6
-:400E8000F5E7B0420D44E5D1534A00231360936013619361514B524F1A68524BDFF890811A60514B1A68514B1A60514A137843F002031370137C43F0020313742378A2F57C
-:400EC000863243F040032370413A137843F010031370484A484B07CA03C31A80474A2833106843F8250C127903F8212C444A07CA03C31A80434AE83B07CA03C31A80424A3D
-:400F0000083307CA03C31A80404A414BA2F5616203CBC2F8100EC2F8141E1378042043F0080313703B4B02F5AA521B783D78DBB298F80060EDB203F007010C321B09117018
-:400F4000F6B2537045F003033B7046F0030388F80030314B48221A70304A402313703049937013729372082382F81F3220220A7048710A722B4A0A20137001F0E1FB2A4B13
-:400F800088F8006044223D70284D1A7094E80F0007C52B80BDE8F081004800408640004070100048004100400F010049A1460040254200402242004004400040064000407B
-:400FC000A2430040A0430040AB390000E8460040FCFFFF47A80000480076004078100048F8460040207600407C100048287600400350014030100048C05100403C10004899
-:4010000044100048501000485C1000483251004068100048CF0100491D51004001590040235B0040585B004076580040B0430040F946004008B501F0B7FF03680C2B00D18C
-:40104000FEE7FEE7084908B50B68084A1844821A802A01DC086005E001F0A6FF0C2303604FF0FF33184608BDCC80FF1F4887FF1F80B51148114B0025C0B1A3F1100192C974
-:4010800022460439161BB74204D051F8046F42F8046BF7E7114653F8046C8C1AA64202D041F8045BF9E701381033E5E701F082FFFFF774F9FEE700BF010000007C3B0000E7
-:4010C000124A134B10B51A60124A134C1368134843F4007313600023032B98BF54F823204FEA830188BF0E4A0133302B4250F3D10C4B1A780C4B1A700C4B084A1A60FFF7EE
-:4011000029FEBDE8104001F0EDB900BF0004FA050CED00E014ED00E0000000000080FF1F35100000BC760040C080FF1F08ED00E0F8B501F005FF4B4A01271378022643F0B3
-:4011400001031370137C484C43F001031374474B02F5E3521F700B3203F8946C1378054603F07F031370002001F0EAFA2378404A03F0F90323701378384603F0DF031370B7
-:4011800023783B43237001F0DBFA282001F0D8FA384B30461A7802F07F021A701A7802F0BF021A7023783343237001F0C9FA2378314A43F0040323700023137053702F4A3E
-:4011C000FF2199540133092BFBD1284601F0BCFE0721172001F0FCFA2949172001F0EAFA0721182001F0F4FA2649182001F0E2FA0721152001F0ECFA2349152001F0DAFA84
-:401200000721052001F0E4FA2049052001F0D2FA0721062001F0DCFA1D49062001F0CAFA0721084601F0D4FA1A49072001F0C2FA0721082001F0CCFA1749082001F0BAFA51
-:401240000021162001F0C4FA1449162001F0B2FA07210C2001F0BCFABDE8F84010490C2001F0A8BAA5430040944300409D60004012600040F8510040846000406D86FF1F9C
-:40128000FF1A000039190000FD1A0000311A00005D1A00008D1A0000C51A0000051B0000791B0000214B224A10B5187000231370204A40201370204A0F2413701F4A13708C
-:4012C0001F4A13701F4A13701F4A13701F4B4FF400021A604FF080721A604FF400121A6020221A601860802018604FF480701860174804704FF480001860164B1A70933BC9
-:4013000019B91A7802F0FE0202E01A7842F001021A70114B03221A70802203F8202C012001F006FE0D4B04221A7010BD8886FF1F8E86FF1F8C86FF1F8D86FF1F8986FF1F59
-:401340007886FF1F8B86FF1F0087FF1F00E100E09E6000409C600040286000401260004070B5074C054623780E461BB9FFF7E0FE0123237031462846BDE87040FFF792BF36
-:401380003886FF1F0A4A002313700A4A13700A4A13700A4A13700A4A13700A4A13700A4A13700A4B03221A70802203F8202C70478E86FF1F8C86FF1F8D86FF1F8986FF1FE9
-:4013C0007886FF1F8B86FF1F0087FF1F28600040014B1878704700BF8D86FF1F044B1A7802F0FF001AB118780022C0B21A7070478C86FF1F024A0C2303FB00204078704778
-:401400009486FF1F431E072B0CD8074A064B00010344805C5B7800F00F0043EA0020023880B2704700207047FC5F00401A4A38B50C2303FB00231B79090C13F0800F00F1B6
-:40144000FF35044619BF8AB24FF480438BB24FF48042032D18D8DFE805F002070C110021084601F01BF80DE00021084600F0FAFF08E00021084600F0D9FF03E00021084667
-:4014800000F0B8FF054B1855EDB2072D03D801F0EDF8034B185538BD9486FF1F6486FF1F6D86FF1F431E072B2DE9F0470446894615465CD82F4F0C2202FB0072D388DFF86E
-:4014C000B8A09BB2C3F500739D424FF00C0303FB007388BFD588DB7884BFC5F50075ADB2254A43EA15230601B354B244EBB28AF80130224B1A5C9846FF2A01D1FFF796FF47
-:401500000C2303FB047200215170B9F1000F28D03DB31B4F385D01F011F811232946FE2218F8040001F0D6F806F5C04278321FFA89F118F8040001F0DFF8124D18F804105D
-:40154000385D01F04BF80121385D00F0E1FF735D43F002037355735D03F0FD037355BDE8F08703FB04746379DBB28AF80230BDE8F08700BF9486FF1FFC5F00406D86FF1F52
-:401580006486FF1F706000402DE9F047044615468846002940D0431E072B3FD8FFF732FFA84203D22046FFF72DFF05461D4E335DFF2B03D141462046FFF738FFDFF868A0C5
-:4015C00027011AF8040000F0B9FF1223FE222946305D01F07FF807F5C0411FFA88F27831305D01F089F8DFF84490315D1AF8040000F0F4FF01211AF8040000F089FF17F823
-:40160000093043F0020307F8093017F8093003F0FD0307F8093002E00D4600E000252846BDE8F0876D86FF1F6486FF1F70600040431E072B0AD8064A0C2303FB002300226A
-:401640005A705A79034BD2B200011A54704700BF9486FF1FFE5F0040431E072B9FBF024B000108221A547047FE5F004030B51A4A1A491B4D0878138803449BB21380194A5D
-:4016800000231488D8B2A4B27CB1082B0CD050680078C0B2E85450680133013050601088013880B21080ECE718460B780E4C082B0E4A00D040B10E4D2B7883F080032B7028
-:4016C0000F232370022301E0022323701370094B1870087030BD00BF0487FF1F0087FF1F006000407C86FF1F7986FF1F8E86FF1F8A86FF1F0187FF1F074B02221A70074B61
-:4017000080221A70064B0F221A70064A00231370054A0120137070478E86FF1F8A86FF1F7986FF1F0087FF1F0187FF1F30B5164B16491B780A8803F00F03023BDBB21A4412
-:4017400092B20A80124C134A0020118889B279B173B15568215C013BC9B229705168DBB20131516011880130013989B21180ECE7094A1370094A137883F080031370084BC8
-:401780000B221A7030BD00BF296000400487FF1F006000407C86FF1F0187FF1F8A86FF1F7986FF1F064A06231370064A01201370054B80221A70054B00221A70704700BFC5
-:4017C0008E86FF1F7986FF1F8A86FF1F0187FF1F054B9A683AB19A68044910709A680988518000229A6070477C86FF1F0487FF1F08B5124B1A78D2B21A701B78DBB21A06C0
-:4018000002D50F4A137008BD0220FFF7E1FF0D4B1B7803F06003202B05D0402B06D043B900F012FC04E001F093FB01E000F046FD10B9034B03221A7008BD00BF2860004013
-:401840007986FF1F0060004008B5084A084B0120197813880B449BB21380064B00221A70FFF7B6FF044B03221A7008BD0487FF1F0087FF1F8E86FF1F7986FF1F08B50C4BB1
-:401880001B78DBB2042B07D0062B09D0022B0DD1BDE80840FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A7008BD00BF8E86FF1F7986FF1F08B5054B00220120BE
-:4018C0001A70FFF785FF034B03221A7008BD00BF8E86FF1F7986FF1F08B50A4B1A7832B11A78094942F080020A7000221A70074B002201201A70FFF76BFF054B03221A7051
-:4019000008BD00BF7886FF1F086000408E86FF1F7986FF1F074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF7C5BFFFF7D3BF70478E86FF1F38B51D4C2378DBB2D3
-:40194000DD0634D518060AD503F00F03012B2ED1FFF74EFF174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5FFF786FF23781B061BD4104B1A78104B1B7813434F
-:401980000F4A13701278934211D10A4A0849154613782078DBB2000605D41378DBB20B700B7803F00F0328788342F1D138BD38BD286000407986FF1F8A86FF1F0187FF1F96
-:4019C00029600040054A00231380054A916819B191680B7092685380704700BF0487FF1F7C86FF1F0E4808B503889BB213B9FFF783FE13E00B4B02221A700B4B00221A7060
-:401A0000FFF7E0FF094AD1799379028843EA012392B2934238BF0380FFF728FE012008BD7C86FF1F8E86FF1F8A86FF1F00600040084B01221A700F3B9B7C074B1A7B02F05E
-:401A40000302012A1EBFDA7B82F08002DA7301225A7370470B6000409486FF1F094B02221A700F3B93F82230074B1A7E02F00302012A1EBFDA7E82F08002DA7601225A7698
-:401A8000704700BF0B6000409486FF1F0B4B04221A700F3B93F83230094B93F8242002F00302012A1EBF93F8272082F0800283F82720012283F82520704700BF0B600040E2
-:401AC0009486FF1F0B4B08221A700F3B93F84230094B93F8302002F00302012A1EBF93F8332082F0800283F83320012283F83120704700BF0B6000409486FF1F7047FFF79A
-:401B000041BC0000F0B5184B184E19780C27C9B201234FF0000C31B3CA0720D5144A4FEA031E7244947850782040C5070DD507FB03652C79240608D5147804F0FE04147076
-:401B40006D790C4CEDB204F80E50840706D507FB036425792D0658BF84F801C090700133DBB24908D7E7F0BD9F6000409486FF1F70600040FE5F004000F0ACBC70B50446D2
-:401B8000184B88B003AA03F11006154618685968083303C5B3422A46F7D11B782B70FCB12223237001AD03232846637000F08AFE002220461146AB5C08AC04EB131414F80B
-:401BC000144C03F00F03847008AC234413F8143C0132082AC1700371417100F10400EAD108B070BDD53900002DE9F0431C4D01222E460C201F274FF0800E4FF0080C194B78
-:401C000000FB02581401234418705F70164998F805902144B9F1000F07D098F8044024064CBF887081F802C001E081F802E000FB0261CC880132E4B29C71CC88092AC4F3C5
-:401C40000724DC71CC88E4B21C71C988C1F307215971D4D1054BFF221A70BDE8F08300BF9486FF1F70600040FC5F00400A600040064B074A1B7802EBC30253681A7C82427E
-:401C800086BF03EBC0035869002070478886FF1F383A00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFA8463F4AC3681478007ADFF800C1E4B203EBC000E0
-:401CC0000C2600274FF0010E834268D01A78A24263D11CF80420597891425ED19A7893F8039002F07F0206FB02FA05EB0A01CF7093F802B009F0030981F804B093F803B004
-:401D000005F80AB0B3F804A0A1F808A093F902A0BAF1000F0BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E009E0B9F1010F0CBF4FF005094FF0090981F80590E4
-:401D40004F704FEA02191A4906FB0282494481F802E0B2F808A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F806A011495FFA8AFA494481F806A0B2F80690C9F3AF
-:401D8000072981F80790B2F806905FFA89F981F80490D288C2F307224A71083394E7BDE8F88F00BF8D86FF1F9486FF1F8986FF1FFC5F0040706000407A86FF1F08B5064BBA
-:401DC00018780138C0B2FFF753FF20B143681B7900EBC300406908BD8D86FF1F00212DE9F84F0B464E4E0C2707FB01F401313219092933554FF000059370494CD370138184
-:401E0000937253705371EFD118B1464B1D70464B1D70464B1A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8F8E0DB790C2713F0400F3E4B4FF0000C1A7814BFE0
-:401E400042F0010202F0FE021A70027AD20007FB0541C36803EB02094B4531D093F802A00AF07F06AE4229D10E89B3F804B0B6B25E4538BFA1F808B01E7893F801B01EF89F
-:401E80000660B3451AD181F804A0DE780E7093F902A0DE78BAF1000F06F0030607DA012E0CBF07260D264E7181F8018006E0012E0CBF052609264E7181F801C00833CBE797
-:401EC0000135092DC3D1C1680A328B1C0A440C200833934209D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF767FF114B0121186000230C2000FB0142D380128980
-:401F0000013113449BB203F00102134409299BB2F2D1BDE8F84FFFF767BEBDE8F88F00BF9486FF1F7A86FF1F0287FF1F8D86FF1F8B86FF1F9086FF1F114B1B7903F07F0354
-:401F40005A1E072A19D80F490C2202FB031291781B0141F0010191700021D170517841F002015170127912F0800F074A1A4414BF8D2389239370FFF715BC0020704700BF5C
-:401F8000006000409486FF1FFC5F004030B4194B1A7902F07F02531E072B27D8164B0C2404FB02339978154D01F0FE0199700021D97029461201505D114400F07F0050558B
-:401FC0005A7802F0FD025A701A795B78120605D5012B01D18C7006E00D2303E0012B0CBF082309238B7030BCFFF7DCBB002030BC704700BF006000409486FF1FFC5F004052
-:4020000010B50D4B0D4C21791878C9B20138C0B2FFF72EFE43681B798B4201D2012909D8074A0848535CDBB24354A3780120DBB2535410BD002010BD8D86FF1F006000405F
-:402040007A86FF1F0287FF1F38B58A4A8A4C13780021DBB221801806517840F18D800A2900F20581DFE811F05D00030103010301030103010B0003017E0003018200D378C3
-:402080007C49012B09D17D4B1A787D4B03EBC2035B685B686360122310E0CB78022B12D18878FFF7E5FD002800F0E180436863606368DA7863689B7843EA02232380BDE86B
-:4020C0003840FFF78FBCCB78032B26D16D4B00228878D5B2854209D3664A91786A4AEE2908BF1346634A917881B106E0187801320028F1D018780344EAE764499278097CB9
-:40210000914203D16248FFF739FD614B1A78002A00F0AD801A78228018E0BDE8384000F017BF13F0030313D0022B40F0A0802380504B0C211B7903F07F02564B01FB0233E0
-:402140009A78554BD2B21A7000225A706360B6E702222280514A11784F4AC9B2117053706260ACE7012323804D4BEFE70123238013794C4A1344E9E701390A2977D8DFE8F4
-:4021800001F037764F76067676760A7620009378454ADBB25AE0937803F0FF0153B9404B1A7891425FD01970404B01201870FFF715FE58E0481EC0B2FFF75AFD0028EED120
-:4021C00055E0FFF71DFF002851D02A4A384913791279DBB2D2B20A70364A3249D25CCB5C9A4240D0314B01221A70FFF753FD3AE003F00303012B2BD009D3022B37D11D4B5A
-:402200009B78002B33D1BDE83840FFF7BFBE194B9B78012B2BD1214A137803F0FD0315E003F00303012B13D008D3022B1FD1114B9B78E3B9BDE83840FFF77EBE0D4B9B788A
-:40224000012B14D1154A137843F0020313700AE0084B1A795AB998781B791749DBB2CA5C22EA0002CA54BDE83840FFF79BBA002038BD00BF006000407C86FF1F8886FF1FBA
-:40228000383A00009C3A0000243A00000F3B00002087FF1F9486FF1F3986FF1F8B86FF1F8D86FF1F7A86FF1F7886FF1F8C86FF1F8986FF1F0287FF1F8F86FF1F074B1A789F
-:4022C000120609D55B78012B06D1054B054A5A6012781A80FFF786BB00207047006000407C86FF1FFC390000014B1870704700BF72640040014B1878704700BF6D640040CF
-:40230000014B1870704700BF7A650040064A0123136002F688321268E0211064034A1170A2F540721360704780E100E000E400E0014B1870704700BF76650040014B18702D
-:40234000704700BF7965004073B515461E460B4C05230022019200920A4601461846237000F064F932462946207800F01FF90221207800F009F9207802B070BDD080FF1F2E
-:40238000064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B04221A60704700E100E0014B04221A60704780E100E0014B18702F
-:4023C000704700BF7C640040704738B505460078012428B100F054FD285D0134E4B2F8E738BD08B50D2000F04BFDBDE808400A2000F046BDF7B516461F460B4C0023032542
-:40240000019300930A4601462846257000F00EF93A463146207800F0C9F80221207800F0B3F8207803B0F0BDE080FF1FF7B516461F460B4C00230225019300930A4601460C
-:402440002846257000F0F2F83A463146207800F0ADF82946207800F097F8207803B0F0BDE180FF1FF7B516461F460B4C00230125019300930A4601462846257000F0D6F8D2
-:402480003A463146207800F091F80221207800F07BF8207803B0F0BDE280FF1F73B515461E460B4C0023019300930A4601461846237000F0BBF832462946207800F076F8EE
-:4024C0000221207800F060F8207802B070BD00BFE380FF1F024B1878C0F38010704700BF8F450040074A7F23802113705170064A013BDBB202F80839002BF9D1034A137087
-:40250000704700BFE480FF1FF87B00400078004017280FD8084B0001C25C11B142F0200201E002F0DF02C254C25C42F00102C25400207047012070471070004017280BD8C6
-:40254000064B0001C25C02F0FE02C254C25C02F0DF02C25400207047012070471070004017280DD8074900010B4603441A7942F004021A71435C43F00103435400207047C6
-:40258000012070471070004017280BD8064A0001835C490003F0F10301F00E011943815400207047012070471070004041F6FF73994208BF4FF400519A4208BF4FF400524A
-:4025C00017289FBFC00000F1804000F5EC4081809ABFC280002001207047000017289FBF034B00011954002088BF0120704700BF1970004017289FBF054B00011A5C01F0A3
-:4026000007019DBF1143195400200120704700BF1470004017289FBF034B0001185C00F0070088BFFF20704714700040172810B51AD8C00001F07F0100F1804441EAC212E7
-:4026400004F5EC44D2B222709DF8082003F00F0343EA0213DBB263709DF80C30002003F00F03A370E07010BD012010BD10B500F067FC0A4A5378182B0AD91478013B5370BB
-:40268000E30003F1804303F5F0431B78137000E0FF2400F059FC204610BD00BFE480FF1F030610B5044611D400F04AFC084AE300117803F1804303F5F043197053781470D8
-:4026C00001335370BDE8104000F03EBC10BD00BFE480FF1F30B504060CD411F4704509D1C40004F1804404F5F0442180A270E370284630BD012030BD03065FBFC00000F1A2
-:40270000804000F5F04081805ABFC280002001207047000038B50446084DB4F5004F05D9286800F005FCA4F50044F6E7034B58686043BDE8384000F0FBBB00BFEC80FF1F06
-:40274000024B1B7A584300F0F3BB00BFEC80FF1F0E4B00F003001A78490102F0FC02104318701A7801F0600142F080021A701A7802F07F021A701A7802F09F020A431A7055
-:402780001A7842F010021A70704700BF83430040014B01221A70704784430040044B00F00F021B6853F8220043F82210704700BF08ED00E0054A00F01F00126800F11003B2
-:4027C00052F8230042F82310704700BF08ED00E000F01F0000F16040490100F56440C9B2017070470F4B10B50F4900240F205C609C60DC601C615C61FFF7D0FF0B4A136801
-:4028000043F0040313600A4B4FF47A72DB68B3FBF2F3084A1360084B4FF400421C60C3F8E82010BD3C86FF1F9128000010E000E0EC80FF1F14E000E018E000E0024A136882
-:4028400043F002031360704710E000E008B5FFF7F5FF034A136843F00103136008BD00BF10E000E010B5054CA3691BB9FFF7BAFF0123A361BDE81040FFF7E8BF3C86FF1F7A
-:40288000024B1868C0F30040704700BF10E000E038B5FFF7F5FF012808D1054D002455F8243003B198470134052CF8D138BD00BF4086FF1F024B03EB8003586859607047DA
-:4028C0003C86FF1F134B144A1B78DBB20360127843EA0223114A0360127843EA0243104A0360127843EA026303600E4B0E4A1B78DBB24360127843EA02230C4A4360127814
-:4029000043EA02430A4A4360127843EA02634360704700BF0301004904010049EC460040020100490101004900010049050100490601004910B500F003FB204A044613787A
-:402940000A2043F002031370137C43F00203137412F80A3C43F0010302F80A3C937943F00103937102F5AB52137843F003031370134B18221A7013F8012C42F0400203F812
-:40298000012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222183B1A70094A137843F008031370FFF7CAFE064B10222046BDE810401A6000F0C6BAAB430040A7
-:4029C0000E5900402F5B004080E200E008B500F0B7FA0F4A137803F0FE031370A2F5AA521D3A137803F0FD031370137C03F0FD03137412F80A3C03F0FE0302F80A3C9379E7
-:402A000003F0FE039371BDE8084000F09DBA00BF08590040044A137803F03F0343EA8010C0B21070704700BF08590040082804D00A280CBF8223C22300E0422308380E4ACE
-:402A4000C0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A8070470A590040E639000087
-:402A80000A87FF1F0C87FF1F1087FF1F08B5102000F0A6F907210420FFF79AFE07490420FFF788FE064A0C20137843F006031370FFF7BCFF034B00221A8008BD852B0000C5
-:402AC000095900400887FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF72ABF5886FF1F044B1A7802F0FB021A701A7842F001021A7070470859004010B5084B8F
-:402B00001C7814F0010403D10028F9D0002404E02046FFF715FE024B1B78204610BD00BF09590040034A044B1B881088181A00B2704700BF1087FF1FA25B00400E4A138832
-:402B40001BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270470A87FF1F0C87FF1F31
-:402B80000887FF1F7047000010B500F0D9F9214A044613780A2043F001031370137C43F00103137412F80A3C43F0020302F80A3C937943F00203937102F5AA5218321378E1
-:402BC00043F003031370144B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222123B1A70094A137843F008031370FFF7A3
-:402C00009FFD074B08222046BDE810401A6000F09BB900BFAB43004006590040275B004080E200E008B500F08BF90F4A137803F0FE031370A2F5AA52153A137803F0FE03E6
-:402C40001370137C03F0FE03137412F80A3C03F0FD0302F80A3C937903F0FD039371BDE8084000F071B900BF00590040044A137803F03F0343EA8010C0B21070704700BFAF
-:402C800000590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6A9
-:402CC000C41393FBF1F305490B60054B1A80704702590040F03900001687FF1F1C87FF1F1487FF1F08B5102000F084F807210320FFF76EFD07490320FFF75CFD064A0C20F5
-:402D0000137843F006031370FFF7BCFF034B00221A8008BDDD2D0000015900401887FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF728BF5986FF1F044B1A78AB
-:402D400002F0FB021A701A7842F001021A7070470059004010B5084B1C7814F0010403D10028F9D0002404E02046FFF7E9FC024B1B78204610BD00BF01590040034A044B6E
-:402D80001B881088181A00B2704700BF1487FF1FA05B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F35E
-:402DC0000028D8BF5B42134493FBF1F000B270471687FF1F1C87FF1F1887FF1F70470000034A00F0F800137803431370704700BF02410040034A00F0F8001378034313704D
-:402E0000704700BF06410040014B1870704700BF78650040014B1870704700BF7564004073B515461E460B4C04230022019200920A46014618462370FFF7F8FB32462946C7
-:402E40002078FFF7B3FB02212078FFF79DFB207802B070BDFC80FF1F074A0223136002F688321268E0215064044A11706FF440710A441360704700BF80E100E001E400E0D2
-:402E8000FEB5494652465B460EB40746244909688A46244A12682448022100F071F8030020480068C018204900F06AF8143883460121C9430C460125002600F041F88146D3
-:402EC00051460B7823400B705846013000F030F83800F04028400B78234003430B70584600F026F80136072EF2D9002001300138013001200B78234003430B705846043044
-:402F000000F016F8484600F01FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F00C20100000000000230800803D000BF01380046FCD17047B9
-:402F4000EFF3108072B6704780F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F02044B01FB02339B7A00E0137900207047006000409486FF1FBE
-:402F8000002902D0B0FBF1F0704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BF014B1868704700BF6081FF1F0E4B70B51E460E4C0025E41A3D
-:402FC000A410A54204D056F8253098470135F8E700F0BAFD084B094C1E46E41AA4100025A54204D056F8253098470135F8E770BD543B0000543B0000543B00005C3B00007E
-:4030000003460244934202D003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF40273ADF80C300CBF234604F1FF33029305934FF6FF730091B5
-:403040000491ADF80E3002461E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000007B5009313460A46014603480068FFF7CBFF03B05DF804FBCF
-:403080006081FF1F2DE9F0478E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656905EB450595FBF3F57B1C43449D4238BF1D4653050FD52946B8
-:4030C00000F04AFB064698B13A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B92169504600F0E8FA0C23CAF80030A3894FF0FF3043F04003B2
-:40310000A381BDE8F08726613E44266046466561ED1BA560464528BF464649463246206800F0B3FAA36800209B1BA36023681E442660BDE8F08700002DE9F04F9DB003938C
-:403140008B8980461C060D4616460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B610023099320238DF82930DFF89CB130238DF82A3037463C46DB
-:4031800014F8013B1BB9B7EB060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780099B4B4409933B78002B00F0A08000234FF0FF3204930793F2
-:4031C000059206938DF853301A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F018430490EFE7D90644BF20228DF853201A0744BF2B228DF853204C
-:4032000022782A2A03D0079A00210A200BE0039A111D12680391002A10DA524243F00200079204900BE027463B780134303B092B03D800FB02320121F5E701B107923B782E
-:403240002E2B1ED17B782A2B0AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781C0A2407463A780130303A092A03D804FB01210123F5E703B1C9
-:40328000059103223978224800F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1C8DF8281000F0D4F988B1194B33B9039B073323F007030833A3
-:4032C000039314E003AB00932A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F1FF3F824603D0099B5344099342E7AB895B0601D4099801E0D9
-:403300004FF0FF301DB0BDE8F08F00BF233B0000293B00002D3B000000000000853000002DE9F04791461F460A698B6806469342B8BF1346C9F8003091F843200C46DDF8AC
-:40334000208012B10133C9F800302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E00123524639463046C04701301AD00135E368D9F800209B1AFC
-:403380009D42F1DB94F843302268003318BF012392060FD5E118302081F843005A1C94F845102244023382F8431003E04FF0FF30BDE8F08704F1430239463046C047013097
-:4033C000F4D02268D9F80050E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED184FF000091A344D4509D00123224639463046C0470130D5D04C
-:4034000009F10109F3E70020BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8011D8632A22D009D8002A00F0BB80582A40F0CA8081F845207B
-:40344000834955E0642A1ED0692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A603EE0752A24D0782A3AD0ADE01A6801F14205111D1960136882
-:4034800084F84230A8E021681A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E01368002B3CDA2D225B4284F8432037E021681A6811F0800F13
-:4034C00002D0111D196007E011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE078225A4984F845202268186812F0800F00F104051D6003D1DE
-:40350000550601D5038800E00368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E049490A226568002DA56008DB206820F0040020602BB9002D01
-:403540007DD175460CE0002B79D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0708D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0320
-:4035800023612EE008681A6810F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198000E0196000232361754616E01A68111D196015680021626886
-:4035C000284600F049F808B1401B6060636804E004F1420584F8422001232361002384F84330CDF800803B4603AA21463046FFF797FE013002D14FF0FF3026E023692A4686
-:4036000039463046C0470130F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B784F
-:4036400004F1420584F842308AE705B0BDE8F083D5390000343B000010B5C9B202449042034605D01C7801308C42F8D1184610BD002010BD10B5431E0A44914204D011F857
-:40368000014B03F8014FF8E710BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014D01F8014DF8E710BD994204D011F8014B02F8014FF8E710BDC8
-:4036C00038B50546002944D051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A3420DD92268A018834201BF18685B681218226063600C6023E047
-:40370000A24203D813465A68002AF9D118681918A1420BD12168014458188242196013D110685268014419605A600DE002D90C232B6009E021686018824201BF1068526820
-:403740000918216062605C602846BDE8384000F098B838BD6086FF1F70B5CD1C25F0030508350C2D38BF0C25002D064601DBA94202D90C23336046E000F082F8234B1C683D
-:403780001A462146A1B10B685B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4615E00C464968E9E7174C23681BB9304600F052F8206029460B
-:4037C000304600F04DF8431C18D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A0ED05A42E25070BD211A304600F034F80130EBD10C2333605D
-:40380000304600F03EF8002070BD00BF6086FF1F5C86FF1FF8B5074615460E4621B91146BDE8F840FFF798BF1AB9FFF749FF2846F8BD00F027F885420ED929463846FFF704
-:403840008BFF044650B131462A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C0023054608462360FDF7EAFB431C02D1236803B12B6038BD4487FF1F0D
-:403880007047704751F8040C0028BEBF091851F8043CC0180438704700000000050209020B020D020F02110213027265706C792030782530327800686F6D696E6700626584
-:4038C00067696E6E696E67207365656B2066726F6D20256420746F2025640066696E6973686564207365656B0057616974696E6720666F72205553422E2E2E005553422003
-:40390000726561647900636F6D6D616E642030782530327800756E64657272756E206166746572202564207061636B65747300636F756E743D256420693D256420643D254F
-:403940006400636D645F777269746500703D25642063723D25642063773D256420663D256420773D256420696E6465783D256420756E64657272756E3D25640077726974AE
-:40398000652066696E69736865640073746172742065726173696E670073746F702065726173696E670069646C65000051004010004051004030000000014000100014018C
-:4039C00040000800400140000A004C0140000200500140200030313233343536373839414243444546000001000000040000001000010000000400000010000028000000C0
-:403A0000000104000100000000000000000157494E5553420000303030303100000000000000000012034D005300460054003100300030000100000001000000403A00005A
-:403A4000010000000F3B0000000000000000000001000000583A000001000000E13A0000040000007A3A0000000000000000000000000000783A0000FF00000001024000A0
-:403A8000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500780045006E00670069006E0065002A0343006F0077006C0050
-:403AC000610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010080320904000004FF0000010705010240000007058202400067
-:403B0000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B2000686C4C00656667454647003031323334353637383961621F
-:403B40006364656600000000F8B500BFF8BC08BC9E46704759000000C1100000F8B500BFF8BC08BC9E46704735000000803B0000C880FF1FA0000000E005000000000000B0
-:403B8000000000004887FF1FFF000000675000400C00000007000000FFFFFFFF7F8000003F0000000000007D00FA0000400000000090D003FF0000000000000000000000BC
-:403BC000000000000000000000000000000000000000000000000000213B000000000000000000000000000000000000000000000000000000000000000000000000000069
-:403C00000000000000000000000000000000000000000000000000000081FF1F000000000000000000000000000000000000000000000000000000000000000000000000E5
-:403C40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044
-:403C80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004
-:403CC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C4
-:403D00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083
-:403D40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043
-:403D80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003
-:403DC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C3
-:403E00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082
-:403E40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042
-:403E80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002
+:4000000000800020110000006512000065120000064A08B5136843F020031360044B1A6803F53F5302331A6001F03AF9E8460040FA46004010B5054C237833B9044B13B104
+:400040000448AFF300800123237010BD6881FF1F00000000E03A0000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF0000000027
+:400080006C81FF1FE03A0000C880FF1F000000000A4A0B4B116801310B40002BBEBF03F1FF3363F03F030133136011685368994202BF024B01221A72704700BF8881FF1FA2
+:4000C0003F0000800A4A0B4B516801310B40002BBEBF03F1FF3363F03F030133536051681368994202BF024B01221A72704700BF8881FF1F3F000080024B012200205A7293
+:4001000002F074BA8881FF1F10B5C4B2204601F089FA0128FAD110BD08B572B60F4B0F49DA680132DA601A690132C82A08BF00221A615A6918690132A72A08BF00224A6174
+:400140005B69002B0CBF02230023002814BF184643F0010002F0B2FF62B608BD8881FF1F38B50446C5B2284602F0E2F9062002F0FFFB44F00200C0B202F0DAF9062002F0C9
+:40018000F7FB284602F0D4F9BDE83840062002F0D9BB10B5642402F0C5F930B90120FFF7DFFF013CF7D1204610BD012010BD70B5C4B220460E4601F03DFA314605460246CF
+:4001C000204601F0F9FA204601F02CFA0128FAD0284670BD38B5044D0024285D013402F077FB402CF9D138BDA081FF1F08B502F091FD002002F09AFD02F0ACFD02F0B6FD9A
+:4002000080B208BD10B50446012002F0A9F9642002F098FBFFF7EAFF2080002002F0A0F9642002F08FFBFFF7E1FF608010BD08B502F09CFE002002F0A5FE02F0B7FE02F0B6
+:40024000C1FE80B208BD10B50446FFF7A2FF322002F078FBFFF7EBFF20800020FFF780FF322002F06FFBFFF7E2FF608010BD0FB400B593B014AB53F8042B402102A8019391
+:4002800003F016F802A802F0B8F902F0C2F913B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF72FFF62782146BDE81040042001F00EBAF43A000007B50023B9
+:4002C000ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB000010B5074C94F8583043B1002002F016F9002002F0A9FE002384F8583010BD00BF8881FF1F5F
+:4003000038B5104D837895F85B2004469A4204D0FFF7E4FF002385F85E302368C5F859302279094B1A71A378002B14BF0220012002F088FEE07802F07FFE2079BDE83840D3
+:4003400002F0B6BE8881FF1FE181FF1F38B50D4C94F8585065B904F15900FFF7D1FF012002F0DAF84FF47A7002F0ECFA84F85E50E3682366012384F85830BDE8384002F0A5
+:400380001FBB00BF8881FF1FF8B51E4C0646FFF7DDFF94F85E3003B15EB91B48FFF767FFFFF7F7FE0120002384F85E00636602F0DFFA3246616E1548FFF759FF114D002790
+:4003C000636E9E4216D002F0ADF800B16F66636E9E4205DD0020FFF7C3FE6B6E013305E005DA0120FFF7BCFE6B6E013B6B6602F0E7FAE5E7322002F0A5FABDE8F8400448AC
+:40040000FFF735BF8881FF1F013B0000083B0000253B00002DE9F04F9BB062B602F03AFB9C49042002F05EFB9B4802F087F89B4802F02AFE9A4802F0BBF802F00BFD02F0D5
+:40044000DDFB0020974C02F0FDFD02F0D5F80221002001F09DF8002384F85B30FFF776FFFFF797FE84F86800FFF738FF012384F85B30FFF76BFFFFF78CFE84F86900FFF716
+:400480002DFF894B94F86800884994F869202546002A14BF0A461A46002808BF19468448FFF7E5FE0321084602F06AFAA24602F087FA94F8583043B12A6EEB689B1A41F259
+:4004C0008832934201D9FFF709FF01F099F818B97848FFF7CCFE04E001F098F80028F7D10BE001F08DF810B902F06AFAF9E77248FFF7BDFE032001F0B3F9032001F092F844
+:400500000128D4D16D48FFF7FBFE6D490320FFF74EFE94F86A106B48FFF7A9FE94F86A30023B142B00F27684DFE813F0150074041E00740424007404480074046B0074041E
+:40054000D8007404FE017404AC037404CC037404D3037404ED0303238DF828308DF829300C238DF82A30CAE394F86C00FFF70CFF554BC1E3FFF7EAFE00236372E068627A35
+:4005800002F0FF0132B9EB681B1AB3F57A7FF6DD0B460AE04BB100228AF80920DAF80C10627A12B9EB685B1AFAE707228DF8282004228DF82920ADF82A30A0E30220FFF79C
+:4005C000A3FD00270DF1280902F0FAF94FF480780026C8EB07039A1906F809200136402EF9D10220FFF790FD32464946022001F071F8B8F10108EBD10137402FE4D1334B49
+:4006000042E04FF00109002702F0DAF94FF00008012001F025F9012001F004F80128FAD10DF1280B4022594601F0C6F8012000F0F9FF0028FAD1064608EB07030593059B8C
+:400640001BF806203344DBB2934209D08DE80C003946334642461E48FFF709FE4FF000090136402EEBD108F10108B8F5807FCFD10137402FC8D149461648FFF7F8FDB9F172
+:40068000000F00F05981144B1B8809A8ADF8243036E300BF19010000F900000091000000C50000008881FF1F373B0000333B00003A3B0000523B0000653B0000E181FF1F4B
+:4006C000F281FF1F6F3B0000E43A0000E63A00007E3B00009A3B0000E83A000094F86C0001F03EFF606EFFF74FFE02F04DFD934B934F1A78002602F0FB021A701A7842F0A9
+:4007000001021A701A7802F0FE021A701A7802F0FE021A7002F03CFD0220FFF7F5FC41F6FF734FF480420121022002F091FC84F8AA0002F0B3F8B8550136402EF9D1DFF855
+:400740002082002608F1990B1FFA8BF70136402E14BF3246002218F8010F22440623127E402102F0CFF83A4646F2434198F8000002F0DAF84037402EBFB2E7D19AF86D3041
+:4007800043B100238AF80930637A002BFCD000238AF80930182200210AA802F055FD694B4FF0FF320C9340230D930023236062602372236894F8AA002344197E02F026F8D2
+:4007C00094F8AA0001F0E4FF012194F8AA0001F0B7FF2368002BFCD000239946CAF80430DAF80C200127059202F0EAF8059AE3689B1AB4F86E2093420ED36FB1042195F884
+:40080000AA0002F00FF894F8AA0002F01BF80028F9D107468AF80800237A03F0FF08002B48D16A682B689A4202D1002FDCD141E063680AA80BEB831343440A93C8F14003FC
+:400840000B9300F001FB0B9B09F10109C3F1400398440D9B5FFA88F8E3B93B4E0220FFF753FCA6F1400EBEE80F000FC6BEE80F000FC6BEE80F000FC69EE80F0086E80F00CF
+:40088000A6F130014022022000F024FF703E40230C960D93B8F13F0FCAD962682B4B01321340002BBEBF03F1FF3363F03F030133636099E70AA8267A00F01CFB0220FFF7DB
+:4008C00023FC0D9BF6B2402B07D0022040221E4900F000FF0220FFF717FC0D9B022033F040021DBFC3F1400292B21749114600F0F1FE0220FFF708FCFFF76CFC36B11448AA
+:40090000FFF7B5FC0220FFF7D9FC06E0114B09A81B88ADF82430FFF7BFFC627A4946237A0D48FFF7A4FC78E20C48FFF7A0FCD4F86E6016F03F0615D003206CE2936400403E
+:40094000A081FF1F3892FF1F7892FF1F3F000080A43B0000EA3A0000BE3B0000D13B00009F81FF1F012001F001FE95F86C0001F0F7FD02F009FCB94BB94F1A7842F0040267
+:400980001A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F0F9FB686EFFF7F2FC01214FF4804341F6FF72084601F0E2FD85F8AA0001F070FFB8550136E7
+:4009C000402EF9D1DFF8B882002708F199039EB207930137402F14BF3A46002218F8010F22440523127E402101F08CFF314646F2475298F8000001F097FF4036402FB6B225
+:400A0000E7D1DAF86E3000269B09182231464FF0FF3B0AA8CAF800600593CAF804B0B1468AF80860B04602F00FFC0D973746012000F016FF069601F0C3FFB8F1000F0AD1BB
+:400A40004EB9012000F0EEFD012804D14022854900F0B2FE06462268834B01321340002BBCBF03F1FF3363F03F036168B8BF01338B4200F09080069B3BB1237A002B40F054
+:400A80009B806B7A002B40F097800B9BBBBBB8F1000F09D0754A7F2199540133402BFBD1724A0B930A922AE04EB3012000F0BAFD28BBDFF8B8E13F2E0EF1400CBCE80F00D9
+:400AC000AEE80F00BCE80F00AEE80F00BCE80F00AEE80F009CE80F008EE80F00AEF130030A9307F101070B9607DD059BBB4204D0012000F0B5FE464601E04FF001080B9B05
+:400B0000DBB12368079A0AA802EB83120D9BC3F1400313440C9300F0FCF90D9B6BB92A68514B01321340002BBEBF03F1FF3363F03F030133236040230D93636801332AD1B8
+:400B40002B683F2B27D14FF0000BC5F804B001F041FD85F808B06B6895F8AA002B44197E01F054FE95F8AA0001F012FE012195F8AA0001F0E5FD85F809B0637A002BFCD0A0
+:400B80004FF0000B01208AF809B001F02FFD584601F0ECFC01E0069B2BB1237A63B96B7A53B90123069363685B453FF444AF09F10109D5F804B03EE761682D482268FFF73D
+:400BC00056FB01F00DFD012001F0D0FC002001F00DFD042194F8AA0001F024FE94F8AA0001F030FE0028F9D19AF8AA0001F0BEFD9AF809309AF808200293012303920193AC
+:400C0000CDF800804B463A4605991A48FFF72FFBB8F1000F16D1059BBB420AD0012000F001FD01280646F6D10E49FFF7C0FA3F2803DC012000F028FE04E0304600F010FE01
+:400C40000137E8E7FFF7C6FA0B48FFF710FB237A0BB10220DFE0094B16E500BF97650040A081FF1F7892FF1F3F0000803892FF1FDB3B0000E63B0000163C0000EC3A000022
+:400C80009F81FF1F94F86C0001F06AFC606EFFF77BFB6648FFF7EBFA00236372637A002BFCD0012001F0A2FC00238AF80930637A002BFCD0002001F099FC5D48FFF7D7FAA4
+:400CC0005C4B19E0002084F85E00FFF75DFB5A4B12E094F8683023B195F869200AB985F86C2094F869201AB113B9012385F86C305248FFF705FB524B1B88ADF828300AA833
+:400D0000FFF7CAFA89E0FFF7E9FA02F021F9002002F0C4F82A2601F0EFFF002001F092FF324600210AA802F08FFA17238DF828308DF8296001F044FE002001F0EDFB0020D5
+:400D400002F080F9C82001F0FDFD0DEB0600FFF759FA0DF13E00FFF776FA01F031FE012002F070F9322001F0EDFD0DF12E00FFF749FA0DF14200FFF766FA012001F0CCFBAF
+:400D80004FF4967001F0DEFD01F01AFE0DF13600FFF738FA0DF14A00FFF755FA002001F0BBFB4FF4967001F0CDFD01F009FE022002F048F9322001F0C5FD0DF13200FFF7E9
+:400DC00021FA0DF14600FFF73EFA012001F0A4FB4FF4967001F0B6FD01F0F2FD0DF13A00FFF710FA0DF14E00FFF72DFA002001F093FB4FF4967001F0A5FD01F0E1FD0020DD
+:400E000002F020F9002384F85E3002F023F801F0F5FE74E70120FFF751FA032000F020FD0848FFF724FAFFF742BB00BF253C0000333C0000EE3A0000F03A0000F281FF1FD3
+:400E4000F23A0000403C000070B5002401254268002A4ED0C368002B4BD00368013A591C01601B784260802B01D145752FE013F0800F467D0269017D12D036B1D20042F0F6
+:400E800004020331026101754475026903F00103D20042F004021A43037D0261033315E046B13F2B06D9D20042F004020331026101754475026943EA0223427D036112B1DC
+:400EC00043F0C0030361037D447508330375037D072BBCD90269083B22FA03F38268511C81601370C368013BC360037D083B0375ADE770BD07B5027D42B102AA002102F86F
+:400F0000011D026001224260FFF79EFF03B05DF804FBF0B5012100244368002B43D0C268002A40D0427D4AB183685A1C8260827D1A70C3684475013BC360EDE7027D072A4D
+:400F40000BD806680769751C05603578013B45EA07250832056143600275027D0369A2F10805EB40DBB203F0C006802E07D0C02E0ED103F03F0383754175802308E0C3F34A
+:400F8000401363F07F03033A03F08103027502E00575002BC0D08268551C85601370C368013BC360B8E7F0BD2DE9F04172B6884B61221A70A3F5F06301221A801924854A2B
+:400FC0009C7092E803008033062283F8002283E80300522203F580731A707F4B7F4A1B787F4EDBB2137040F618027E4B00251A8041F2512223F8022C33784FF4F07003F08E
+:40100000010343EA450502F0B7F8013C05F003052ED0032DF0D1744B4FF480721A8007221A70724A002548211570917002221D705D7103F8032C0422DA716D4A6D4C137845
+:401040006D4E43F00103137012F8013C062743F0030302F8013C2378012243F0800323705B4B1A70654A137843F02003137000E0FEE707FB056300219A881868013502F0B3
+:40108000E3F8072DF5D15E485E4E002550F8041F05F1105303F1520221F0FF075333C9B20B4452005B0002329A4206D012F802EC12F801CC0EF807C0F5E7B0420D44E5D16D
+:4010C000514A002313609360136193614F4B504F1A68504BDFF888811A604F4B1A684F4B1A604F4A137843F002031370137C43F0020313742378A2F5863243F04003237064
+:40110000413A137843F010031370464A464B07CA03C31A80454A2833106843F8250C127903F8212C424A07CA03C31A80414AE83B07CA03C31A80404A083307CA03C31A805B
+:401140003E4A3F4BA2F5616203CBC2F8100EC2F8141E1378042043F008031370394B02F5AA521B783D78DBB298F80060EDB203F007010C321B091170F6B2537045F00303A2
+:401180003B7046F0030388F800302F4B48221A702E4A402313702E49937013729372082382F81F3220220A7048710A72294A0A20137001F0DDFB284B88F8006044223D7092
+:4011C000264D1A7094E80F0007C52B80BDE8F081004800404C0F00480F010049A146004025420040224200400440004006400040A2430040A0430040453C0000E8460040A3
+:40120000FCFFFF47A000004800760040540F0048F846004020760040580F004828760040035001400C0F0048C0510040180F0048200F00482C0F0048380F00483251004040
+:40124000440F0048CF0100491D51004001590040235B0040585B004076580040B0430040F946004008B501F0C3FF03680C2B00D1FEE7FEE7084908B50B68084A1844821A89
+:40128000802A01DC086005E001F0B2FF0C2303604FF0FF33184608BDCC80FF1FC893FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F896
+:4012C000046BF7E7114653F8046C8C1AA64202D041F8045BF9E701381033E5E701F08EFFFFF798F8FEE700BF01000000143E0000124A134B10B51A60124A134C13681348EA
+:4013000043F4007313600023032B98BF54F823204FEA830188BF0E4A0133302B4250F3D10C4B1A780C4B1A700C4B084A1A60FFF73BFEBDE8104001F0EDB900BF0004FA05AE
+:401340000CED00E014ED00E0000000000080FF1F65120000BC760040C080FF1F08ED00E0F8B501F011FF4B4A01271378022643F001031370137C484C43F001031374474BAE
+:4013800002F5E3521F700B3203F8946C1378054603F07F031370002001F0EAFA2378404A03F0F90323701378384603F0DF03137023783B43237001F0DBFA282001F0D8FAF2
+:4013C000384B30461A7802F07F021A701A7802F0BF021A7023783343237001F0C9FA2378314A43F0040323700023137053702F4AFF2199540133092BFBD1284601F0C8FE13
+:401400000721172001F0FCFA2949172001F0EAFA0721182001F0F4FA2649182001F0E2FA0721152001F0ECFA2349152001F0DAFA0721052001F0E4FA2049052001F0D2FA34
+:401440000721062001F0DCFA1D49062001F0CAFA0721084601F0D4FA1A49072001F0C2FA0721082001F0CCFA1749082001F0BAFA0021162001F0C4FA1449162001F0B2FA40
+:4014800007210C2001F0BCFABDE8F84010490C2001F0A8BAA5430040944300409D60004012600040F851004084600040ED92FF1F2F1D0000691B00002D1D0000611C00006D
+:4014C0008D1C0000BD1C0000F51C0000351D0000A91D0000214B224A10B5187000231370204A40201370204A0F2413701F4A13701F4A13701F4A13701F4A13701F4B4FF4AC
+:4015000000021A604FF080721A604FF400121A6020221A601860802018604FF480701860174804704FF480001860164B1A70933B19B91A7802F0FE0202E01A7842F00102F8
+:401540001A70114B03221A70802203F8202C012001F012FE0D4B04221A7010BD0893FF1F0E93FF1F0C93FF1F0D93FF1F0993FF1FF892FF1F0B93FF1F8093FF1F00E100E0F3
+:401580009E6000409C600040286000401260004070B5074C054623780E461BB9FFF7E0FE0123237031462846BDE87040FFF792BFB892FF1F0A4A002313700A4A13700A4A18
+:4015C00013700A4A13700A4A13700A4A13700A4A13700A4B03221A70802203F8202C70470E93FF1F0C93FF1F0D93FF1F0993FF1FF892FF1F0B93FF1F8093FF1F2860004017
+:40160000014B1878704700BF0D93FF1F044B1A7802F0FF001AB118780022C0B21A7070470C93FF1F024A0C2303FB0020407870471493FF1F431E072B0CD8074A064B0001F4
+:401640000344805C5B7800F00F0043EA0020023880B2704700207047FC5F00401A4A38B50C2303FB00231B79090C13F0800F00F1FF35044619BF8AB24FF480438BB24FF4AE
+:401680008042032D18D8DFE805F002070C110021084601F01BF80DE00021084600F0FAFF08E00021084600F0D9FF03E00021084600F0B8FF054B1855EDB2072D03D801F03A
+:4016C000EDF8034B185538BD1493FF1FE492FF1FED92FF1F431E072B2DE9F0470446894615465CD82F4F0C2202FB0072D388DFF8B8A09BB2C3F500739D424FF00C0303FB8F
+:40170000007388BFD588DB7884BFC5F50075ADB2254A43EA15230601B354B244EBB28AF80130224B1A5C9846FF2A01D1FFF796FF0C2303FB047200215170B9F1000F28D0C9
+:401740003DB31B4F385D01F011F811232946FE2218F8040001F0D6F806F5C04278321FFA89F118F8040001F0DFF8124D18F80410385D01F04BF80121385D00F0E1FF735D31
+:4017800043F002037355735D03F0FD037355BDE8F08703FB04746379DBB28AF80230BDE8F08700BF1493FF1FFC5F0040ED92FF1FE492FF1F706000402DE9F0470446154681
+:4017C0008846002940D0431E072B3FD8FFF732FFA84203D22046FFF72DFF05461D4E335DFF2B03D141462046FFF738FFDFF868A027011AF8040000F0B9FF1223FE222946E3
+:40180000305D01F07FF807F5C0411FFA88F27831305D01F089F8DFF84490315D1AF8040000F0F4FF01211AF8040000F089FF17F8093043F0020307F8093017F8093003F0A6
+:40184000FD0307F8093002E00D4600E000252846BDE8F087ED92FF1FE492FF1F70600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B200011A54704700BFA0
+:401880001493FF1FFE5F0040431E072B9FBF024B000108221A547047FE5F004030B51A4A1A491B4D0878138803449BB21380194A00231488D8B2A4B27CB1082B0CD050684F
+:4018C0000078C0B2E85450680133013050601088013880B21080ECE718460B780E4C082B0E4A00D040B10E4D2B7883F080032B700F232370022301E0022323701370094B1F
+:401900001870087030BD00BF8493FF1F8093FF1F00600040FC92FF1FF992FF1F0E93FF1F0A93FF1F8193FF1F074B02221A70074B80221A70064B0F221A70064A0023137074
+:40194000054A0120137070470E93FF1F0A93FF1FF992FF1F8093FF1F8193FF1F30B5164B16491B780A8803F00F03023BDBB21A4492B20A80124C134A0020118889B279B199
+:4019800073B15568215C013BC9B229705168DBB20131516011880130013989B21180ECE7094A1370094A137883F080031370084B0B221A7030BD00BF296000408493FF1FCC
+:4019C00000600040FC92FF1F8193FF1F0A93FF1FF992FF1F064A06231370064A01201370054B80221A70054B00221A70704700BF0E93FF1FF992FF1F0A93FF1F8193FF1FD2
+:401A0000054B9A683AB19A68044910709A680988518000229A607047FC92FF1F8493FF1F08B5124B1A78D2B21A701B78DBB21A0602D50F4A137008BD0220FFF7E1FF0D4BC0
+:401A40001B7803F06003202B05D0402B06D043B900F012FC04E001F09FFB01E000F046FD10B9034B03221A7008BD00BF28600040F992FF1F0060004008B5084A084B0120C1
+:401A8000197813880B449BB21380064B00221A70FFF7B6FF044B03221A7008BD8493FF1F8093FF1F0E93FF1FF992FF1F08B50C4B1B78DBB2042B07D0062B09D0022B0DD143
+:401AC000BDE80840FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A7008BD00BF0E93FF1FF992FF1F08B5054B002201201A70FFF785FF034B03221A7008BD00BF19
+:401B00000E93FF1FF992FF1F08B50A4B1A7832B11A78094942F080020A7000221A70074B002201201A70FFF76BFF054B03221A7008BD00BFF892FF1F086000400E93FF1FE7
+:401B4000F992FF1F074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF7C5BFFFF7D3BF70470E93FF1F38B51D4C2378DBB2DD0634D518060AD503F00F03012B2ED1D9
+:401B8000FFF74EFF174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5FFF786FF23781B061BD4104B1A78104B1B7813430F4A13701278934211D10A4A0849154609
+:401BC00013782078DBB2000605D41378DBB20B700B7803F00F0328788342F1D138BD38BD28600040F992FF1F0A93FF1F8193FF1F29600040054A00231380054A916819B1EC
+:401C000091680B7092685380704700BF8493FF1FFC92FF1F0E4808B503889BB213B9FFF783FE13E00B4B02221A700B4B00221A70FFF7E0FF094AD1799379028843EA01238C
+:401C400092B2934238BF0380FFF728FE012008BDFC92FF1F0E93FF1F0A93FF1F00600040084B01221A700F3B9B7C074B1A7B02F00302012A1EBFDA7B82F08002DA73012209
+:401C80005A7370470B6000401493FF1F094B02221A700F3B93F82230074B1A7E02F00302012A1EBFDA7E82F08002DA7601225A76704700BF0B6000401493FF1F0B4B04222D
+:401CC0001A700F3B93F83230094B93F8242002F00302012A1EBF93F8272082F0800283F82720012283F82520704700BF0B6000401493FF1F0B4B08221A700F3B93F842305F
+:401D0000094B93F8302002F00302012A1EBF93F8332082F0800283F83320012283F83120704700BF0B6000401493FF1F7047FFF741BC0000F0B5184B184E19780C27C9B2A9
+:401D400001234FF0000C31B3CA0720D5144A4FEA031E7244947850782040C5070DD507FB03652C79240608D5147804F0FE0414706D790C4CEDB204F80E50840706D507FB3F
+:401D8000036425792D0658BF84F801C090700133DBB24908D7E7F0BD9F6000401493FF1F70600040FE5F004000F0ACBC70B50446184B88B003AA03F11006154618685968B4
+:401DC000083303C5B3422A46F7D11B782B70FCB12223237001AD03232846637000F08AFE002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143CE8
+:401E00000132082AC1700371417100F10400EAD108B070BD6F3C00002DE9F0431C4D01222E460C201F274FF0800E4FF0080C194B00FB02581401234418705F70164998F850
+:401E400005902144B9F1000F07D098F8044024064CBF887081F802C001E081F802E000FB0261CC880132E4B29C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307217E
+:401E80005971D4D1054BFF221A70BDE8F08300BF1493FF1F70600040FC5F00400A600040064B074A1B7802EBC30253681A7C824286BF03EBC0035869002070470893FF1F84
+:401EC000D03C00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFA8463F4AC3681478007ADFF800C1E4B203EBC0000C2600274FF0010E834268D01A78A242A4
+:401F000063D11CF80420597891425ED19A7893F8039002F07F0206FB02FA05EB0A01CF7093F802B009F0030981F804B093F803B005F80AB0B3F804A0A1F808A093F902A066
+:401F4000BAF1000F0BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E009E0B9F1010F0CBF4FF005094FF0090981F805904F704FEA02191A4906FB0282494481F816
+:401F800002E0B2F808A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F806A011495FFA8AFA494481F806A0B2F80690C9F3072981F80790B2F806905FFA89F981F89A
+:401FC0000490D288C2F307224A71083394E7BDE8F88F00BF0D93FF1F1493FF1F0993FF1FFC5F004070600040FA92FF1F08B5064B18780138C0B2FFF753FF20B143681B7986
+:4020000000EBC300406908BD0D93FF1F00212DE9F84F0B464E4E0C2707FB01F401313219092933554FF000059370494CD3701381937253705371EFD118B1464B1D70464B83
+:402040001D70464B1A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8F8E0DB790C2713F0400F3E4B4FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB61
+:402080000541C36803EB02094B4531D093F802A00AF07F06AE4229D10E89B3F804B0B6B25E4538BFA1F808B01E7893F801B01EF80660B3451AD181F804A0DE780E7093F998
+:4020C00002A0DE78BAF1000F06F0030607DA012E0CBF07260D264E7181F8018006E0012E0CBF052609264E7181F801C00833CBE70135092DC3D1C1680A328B1C0A440C2095
+:402100000833934209D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF767FF114B0121186000230C2000FB0142D3801289013113449BB203F00102134409299BB221
+:40214000F2D1BDE8F84FFFF767BEBDE8F88F00BF1493FF1FFA92FF1F8293FF1F0D93FF1F0B93FF1F1093FF1F114B1B7903F07F035A1E072A19D80F490C2202FB031291782D
+:402180001B0141F0010191700021D170517841F002015170127912F0800F074A1A4414BF8D2389239370FFF715BC0020704700BF006000401493FF1FFC5F004030B4194B0D
+:4021C0001A7902F07F02531E072B27D8164B0C2404FB02339978154D01F0FE0199700021D97029461201505D114400F07F0050555A7802F0FD025A701A795B78120605D51F
+:40220000012B01D18C7006E00D2303E0012B0CBF082309238B7030BCFFF7DCBB002030BC704700BF006000401493FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2A1
+:40224000FFF72EFE43681B798B4201D2012909D8074A0848535CDBB24354A3780120DBB2535410BD002010BD0D93FF1F00600040FA92FF1F8293FF1F38B58A4A8A4C137857
+:402280000021DBB221801806517840F18D800A2900F20581DFE811F05D00030103010301030103010B0003017E0003018200D3787C49012B09D17D4B1A787D4B03EBC203C8
+:4022C0005B685B686360122310E0CB78022B12D18878FFF7E5FD002800F0E180436863606368DA7863689B7843EA02232380BDE83840FFF78FBCCB78032B26D16D4B0022CE
+:402300008878D5B2854209D3664A91786A4AEE2908BF1346634A917881B106E0187801320028F1D018780344EAE764499278097C914203D16248FFF739FD614B1A78002A8C
+:4023400000F0AD801A78228018E0BDE8384000F023BF13F0030313D0022B40F0A0802380504B0C211B7903F07F02564B01FB02339A78554BD2B21A7000225A706360B6E76B
+:4023800002222280514A11784F4AC9B2117053706260ACE7012323804D4BEFE70123238013794C4A1344E9E701390A2977D8DFE801F037764F76067676760A762000937848
+:4023C000454ADBB25AE0937803F0FF0153B9404B1A7891425FD01970404B01201870FFF715FE58E0481EC0B2FFF75AFD0028EED155E0FFF71DFF002851D02A4A3849137943
+:402400001279DBB2D2B20A70364A3249D25CCB5C9A4240D0314B01221A70FFF753FD3AE003F00303012B2BD009D3022B37D11D4B9B78002B33D1BDE83840FFF7BFBE194BF2
+:402440009B78012B2BD1214A137803F0FD0315E003F00303012B13D008D3022B1FD1114B9B78E3B9BDE83840FFF77EBE0D4B9B78012B14D1154A137843F0020313700AE0DE
+:40248000084B1A795AB998781B791749DBB2CA5C22EA0002CA54BDE83840FFF79BBA002038BD00BF00600040FC92FF1F0893FF1FD03C0000343D0000BC3C0000A73D0000A6
+:4024C000A093FF1F1493FF1FB992FF1F0B93FF1F0D93FF1FFA92FF1FF892FF1F0C93FF1F0993FF1F8293FF1F0F93FF1F074B1A78120609D55B78012B06D1054B054A5A601E
+:4025000012781A80FFF786BB0020704700600040FC92FF1F943C0000014B1870704700BF7F640040014B1878704700BF69640040014B1870704700BF78650040064A0123A6
+:40254000136002F688321268E0211064034A1170A2F540721360704780E100E000E400E0014B1870704700BF72640040014B1870704700BF7665004073B515461E460B4CFE
+:4025800005230022019200920A4601461846237000F064F932462946207800F01FF90221207800F009F9207802B070BDD080FF1F064A0423136002F688321268E0219064B3
+:4025C000034A1170A2F202321360704780E100E002E400E0014B04221A60704700E100E0014B04221A60704780E100E0014B1870704700BF78640040704738B505460078FF
+:40260000012428B100F060FD285D0134E4B2F8E738BD08B50D2000F057FDBDE808400A2000F052BDF7B516461F460B4C00230325019300930A4601462846257000F00EF920
+:402640003A463146207800F0C9F80221207800F0B3F8207803B0F0BDE080FF1FF7B516461F460B4C00230225019300930A4601462846257000F0F2F83A463146207800F026
+:40268000ADF82946207800F097F8207803B0F0BDE180FF1FF7B516461F460B4C00230125019300930A4601462846257000F0D6F83A463146207800F091F80221207800F039
+:4026C0007BF8207803B0F0BDE280FF1F73B515461E460B4C0023019300930A4601461846237000F0BBF832462946207800F076F80221207800F060F8207802B070BD00BF26
+:40270000E380FF1F024B1878C0F38010704700BF8F450040074A7F23802113705170064A013BDBB202F80839002BF9D1034A1370704700BFE480FF1FF87B0040007800401A
+:4027400017280FD8084B0001C25C11B142F0200201E002F0DF02C254C25C42F00102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C254C25C02F05F
+:40278000DF02C25400207047012070471070004017280DD8074900010B4603441A7942F004021A71435C43F00103435400207047012070471070004017280BD8064A000101
+:4027C000835C490003F0F10301F00E011943815400207047012070471070004041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F5EC408180E3
+:402800009ABFC280002001207047000017289FBF034B00011954002088BF0120704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120704700BFB4
+:402840001470004017289FBF034B0001185C00F0070088BFFF20704714700040172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF8082003F00F0380
+:4028800043EA0213DBB263709DF80C30002003F00F03A370E07010BD012010BD10B500F073FC0A4A5378182B0AD91478013B5370E30003F1804303F5F0431B78137000E0B3
+:4028C000FF2400F065FC204610BD00BFE480FF1F030610B5044611D400F056FC084AE300117803F1804303F5F04319705378147001335370BDE8104000F04ABC10BD00BFCB
+:40290000E480FF1F30B504060CD411F4704509D1C40004F1804404F5F0442180A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280002001203F
+:402940007047000038B50446084DB4F5004F05D9286800F011FCA4F50044F6E7034B58686043BDE8384000F007BC00BFEC80FF1F024B1B7A584300F0FFBB00BFEC80FF1FBD
+:402980000E4B00F003001A78490102F0FC02104318701A7801F0600142F080021A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF834300409B
+:4029C000014B01221A70704784430040044B00F00F021B6853F8220043F82210704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BF08ED00E027
+:402A000000F01F0000F16040490100F56440C9B2017070470F4B10B50F4900240F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72DB68B3FBC1
+:402A4000F2F3084A1360084B4FF400421C60C3F8E82010BDBC92FF1FC12A000010E000E0EC80FF1F14E000E018E000E0024A136843F002031360704710E000E008B5FFF7BF
+:402A8000F5FF034A136843F00103136008BD00BF10E000E010B5054CA3691BB9FFF7BAFF0123A361BDE81040FFF7E8BFBC92FF1F024B1868C0F30040704700BF10E000E08B
+:402AC00038B5FFF7F5FF012808D1054D002455F8243003B198470134052CF8D138BD00BFC092FF1F024B03EB8003586859607047BC92FF1F134B144A1B78DBB203601278DD
+:402B000043EA0223114A0360127843EA0243104A0360127843EA026303600E4B0E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA0263436052
+:402B4000704700BF0301004904010049EC460040020100490101004900010049050100490601004910B500F00FFB204A044613780A2043F002031370137C43F00203137421
+:402B800012F80A3C43F0010302F80A3C937943F00103937102F5AB52137843F003031370134B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2296
+:402BC00003F8062CA3F597530222183B1A70094A137843F008031370FFF7CAFE064B10222046BDE810401A6000F0D2BAAB4300400E5900402F5B004080E200E008B500F066
+:402C0000C3FA0F4A137803F0FE031370A2F5AA521D3A137803F0FD031370137C03F0FD03137412F80A3C03F0FE0302F80A3C937903F0FE039371BDE8084000F0A9BA00BF01
+:402C400008590040044A137803F03F0343EA8010C0B21070704700BF08590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF10
+:402C800033F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A8070470A590040803C00008A93FF1F8C93FF1F9093FF1F08B5102069
+:402CC00000F0A6F907210420FFF79AFE07490420FFF788FE064A0C20137843F006031370FFF7BCFF034B00221A8008BDB52D0000095900408893FF1F10B5054C23781BB9F3
+:402D0000FFF7DCFF01232370BDE81040FFF72ABFD892FF1F044B1A7802F0FB021A701A7842F001021A7070470859004010B5084B1C7814F0010403D10028F9D0002404E02A
+:402D40002046FFF715FE024B1B78204610BD00BF09590040034A044B1B881088181A00B2704700BF9093FF1FA25B00400E4A13881BB223B111880A2309B2594301E00B4BD9
+:402D800019680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270478A93FF1F8C93FF1F8893FF1F7047000010B500F0E5F9214ADE
+:402DC000044613780A2043F001031370137C43F00103137412F80A3C43F0020302F80A3C937943F00203937102F5AA521832137843F003031370144B18221A7013F8012CDE
+:402E000042F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222123B1A70094A137843F008031370FFF79FFD074B08222046BDE810401A6000F09A
+:402E4000A7B900BFAB43004006590040275B004080E200E008B500F097F90F4A137803F0FE031370A2F5AA52153A137803F0FE031370137C03F0FE03137412F80A3C03F099
+:402E8000FD0302F80A3C937903F0FD039371BDE8084000F07DB900BF00590040044A137803F03F0343EA8010C0B21070704700BF00590040082804D00A280CBF8223C2230D
+:402EC00000E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A807047E8
+:402F0000025900408A3C00009693FF1F9C93FF1F9493FF1F08B5102000F084F807210320FFF76EFD07490320FFF75CFD064A0C20137843F006031370FFF7BCFF034B0022A9
+:402F40001A8008BD0D300000015900409893FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF728BFD992FF1F044B1A7802F0FB021A701A7842F001021A70704708
+:402F80000059004010B5084B1C7814F0010403D10028F9D0002404E02046FFF7E9FC024B1B78204610BD00BF01590040034A044B1B881088181A00B2704700BF9493FF1FD3
+:402FC000A05B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B27047DF
+:403000009693FF1F9C93FF1F9893FF1F70470000034A00F0F800137803431370704700BF02410040034A00F0F800137803431370704700BF06410040014B1870704700BFAA
+:4030400076640040014B1870704700BF7C64004073B515461E460B4C04230022019200920A46014618462370FFF7F8FB324629462078FFF7B3FB02212078FFF79DFB2078AB
+:4030800002B070BDFC80FF1F074A0223136002F688321268E0215064044A11706FF440710A441360704700BF80E100E001E400E0014B1870704700BF74650040014B187076
+:4030C000704700BF77640040FEB5494652465B460EB40746244909688A46244A12682448022100F071F8030020480068C018204900F06AF8143883460121C9430C46012516
+:40310000002600F041F8814651460B7823400B705846013000F030F83800F04028400B78234003430B70584600F026F80136072EF2D9002001300138013001200B7823407E
+:4031400003430B705846043000F016F8484600F01FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F00C20100000000000230800803D000BFE7
+:4031800001380046FCD17047EFF3108072B6704780F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F02044B01FB02339B7A00E013790020704751
+:4031C000006000401493FF1F002902D0B0FBF1F0704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BF014B1868704700BF6081FF1F0E4B70B577
+:403200001E460E4C0025E41AA410A54204D056F8253098470135F8E700F0E2FD084B094C1E46E41AA4100025A54204D056F8253098470135F8E770BDEC3D0000EC3D000024
+:40324000EC3D0000F43D000003460244934202D003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF40273ADF80C300CBF234604F1FF330293F9
+:4032800005934FF6FF7300910491ADF80E3002461E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000007B5009313460A46014603480068FFF77E
+:4032C000CBFF03B05DF804FB6081FF1F2DE9F0478E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656905EB450595FBF3F57B1C43449D4238BFB3
+:403300001D4653050FD5294600F04AFB064698B13A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B92169504600F0E8FA0C23CAF80030A38945
+:403340004FF0FF3043F04003A381BDE8F08726613E44266046466561ED1BA560464528BF464649463246206800F0B3FAA36800209B1BA36023681E442660BDE8F08700009E
+:403380002DE9F04F9DB003938B8980461C060D4616460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B610023099320238DF82930DFF89CB130233F
+:4033C0008DF82A3037463C4614F8013B1BB9B7EB060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780099B4B4409933B78002B00F0A080002373
+:403400004FF0FF3204930793059206938DF853301A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F018430490EFE7D90644BF20228DF853201A07B0
+:4034400044BF2B228DF8532022782A2A03D0079A00210A200BE0039A111D12680391002A10DA524243F00200079204900BE027463B780134303B092B03D800FB023201217E
+:40348000F5E701B107923B782E2B1ED17B782A2B0AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781C0A2407463A780130303A092A03D804FB83
+:4034C00001210123F5E703B1059103223978224800F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1C8DF8281000F0D4F988B1194B33B9039B1D
+:40350000073323F007030833039314E003AB00932A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F1FF3F824603D0099B5344099342E7AB89BC
+:403540005B0601D4099801E04FF0FF301DB0BDE8F08F00BFBB3D0000C13D0000C53D000000000000CD3200002DE9F04791461F460A698B6806469342B8BF1346C9F80030AD
+:4035800091F843200C46DDF8208012B10133C9F800302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E00123524639463046C04701301AD0013598
+:4035C000E368D9F800209B1A9D42F1DB94F843302268003318BF012392060FD5E118302081F843005A1C94F845102244023382F8431003E04FF0FF30BDE8F08704F1430291
+:4036000039463046C0470130F4D02268D9F80050E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED184FF000091A344D4509D00123224639462F
+:403640003046C0470130D5D009F10109F3E70020BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8011D8632A22D009D8002A00F0BB80582A3E
+:4036800040F0CA8081F84520834955E0642A1ED0692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A603EE0752A24D0782A3AD0ADE01A6801F151
+:4036C0004205111D1960136884F84230A8E021681A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E01368002B3CDA2D225B4284F8432037E003
+:4037000021681A6811F0800F02D0111D196007E011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE078225A4984F845202268186812F0800F4B
+:4037400000F104051D6003D1550601D5038800E00368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E049490A226568002DA56008DB206820F009
+:40378000040020602BB9002D7DD175460CE0002B79D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0708D5236962689A42DEBF302305F8013C34
+:4037C00005F1FF35C5EB0E0323612EE008681A6810F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198000E0196000232361754616E01A68111D3A
+:403800001960156800216268284600F049F808B1401B6060636804E004F1420584F8422001232361002384F84330CDF800803B4603AA21463046FFF797FE013002D14FF093
+:40384000FF3026E023692A4639463046C0470130F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135E368039A9B1A9D42F2DBE068039B984219
+:40388000B8BF184605E00B7804F1420584F842308AE705B0BDE8F0836F3C0000CC3D000010B5C9B202449042034605D01C7801308C42F8D1184610BD002010BD10B5431E9F
+:4038C0000A44914204D011F8014B03F8014FF8E710BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014D01F8014DF8E710BD994204D011F8014B7E
+:4039000002F8014FF8E710BD38B50546002944D051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A3420DD92268A018834201BF18685B681218C2
+:40394000226063600C6023E0A24203D813465A68002AF9D118681918A1420BD12168014458188242196013D110685268014419605A600DE002D90C232B6009E021686018E0
+:40398000824201BF106852680918216062605C602846BDE8384000F098B838BDE092FF1F70B5CD1C25F0030508350C2D38BF0C25002D064601DBA94202D90C23336046E015
+:4039C00000F082F8234B1C681A462146A1B10B685B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4615E00C464968E9E7174C23681BB9304696
+:403A000000F052F820602946304600F04DF8431C18D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A0ED05A42E25070BD211A304600F034F8A0
+:403A40000130EBD10C233360304600F03EF8002070BD00BFE092FF1FDC92FF1FF8B5074615460E4621B91146BDE8F840FFF798BF1AB9FFF749FF2846F8BD00F027F88542C5
+:403A80000ED929463846FFF78BFF044650B131462A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C0023054608462360FDF7DEFB431C02D1236803B176
+:403AC0002B6038BDC493FF1F7047704751F8040C0028BEBF091851F8043CC0180438704700000000050209020B020D020F021102130215027265706C79203078253032787F
+:403B000000686F6D696E6700626567696E6E696E67207365656B2066726F6D20256420746F2025640066696E6973686564207365656B00796573006E6F00647269766520E7
+:403B4000303A20257320647269766520313A2025730057616974696E6720666F72205553422E2E2E0055534220726561647900636F6D6D616E64203078253032780066614C
+:403B8000696C2025642B25642B2564203D3D2025642C206E6F74202564007061737365643D256400756E64657272756E206166746572202564207061636B65747300636F25
+:403BC000756E743D256420693D256420643D256400636D645F777269746500646F6E6520256420256400703D25642063723D25642063773D256420663D256420773D2564FF
+:403C000020696E6465783D256420756E64657272756E3D25640077726974652066696E69736865640073746172742065726173696E670073746F702065726173696E670092
+:403C400069646C650000510040100040510040300000000140001000140140000800400140000A004C014000020050014020003031323334353637383941424344454600E9
+:403C8000000100000004000000100001000000040000001028000000000104000100000000000000000157494E5553420000303030303100000000000000000012034D0080
+:403CC0005300460054003100300030000100000001000000D83C000001000000A73D0000000000000000000001000000F03C000001000000793D000004000000123D000014
+:403D0000000000000000000000000000103D0000FF00000001024000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500CE
+:403D4000780045006E00670069006E0065002A0343006F0077006C00610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010036
+:403D800080320904000004FF00000107050102400000070582024000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B20AF
+:403DC00000686C4C00656667454647003031323334353637383961626364656600000000F8B500BFF8BC08BC9E46704759000000F1120000F8B500BFF8BC08BC9E467047E3
+:403E000035000000183E0000C880FF1FA0000000601200000000000000000000C893FF1FFF000000675000400C00000007000000FFFFFFFF7F8000003F0000000000007D46
+:403E400000FA0000400000000090D003FF0000000000000000000000000000000000000000000000000000000000000000000000B93D0000000000000000000000000000B0
+:403E80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000081FF1F00000000000000000000000063
 :403EC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C2
 :403F00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000081
 :403F40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041
@@ -4098,72 +4098,72 @@
 :40FF80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041
 :40FFC0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
 :0200000480007A
-:400000000145004008520040015B00400164004001650040410001403E0101404102014054030140470401404C0501404A0601404E0701404A08014051090140430A01409A
-:40004000500B0140520C0140560D0140500E01403A0F0140461401404C1501404A1601405C170140521801405F1901403D1A0140561B01400D4001400E4101400D4201408A
-:400080000C430140074401400C450140074601400F4701400A4801400D490140164C0140044D014008500140045101407E0208420901100211821901600C610A7C40272171
-:4000C0003F01290A0006010302010310050C06010703080509030A020B1C0E010F20110F12011601174019801A011E011F0F2201230A260127052A012C032D402E04300152
-:4001000033C03406353F3B203E115608580459045B045C905D905F0183018AA08C709402980E9B029C40A205A502A650AA0AB0C0B20CB303B403B630D608D80BD904DB0470
-:40014000DC99DD90DF010180020803600440070409220A110E2A10891104134016A01720188019101C401E2A1F1021382304272028022A042B402F10300131083220334088
-:400180003720388039283A013F0158405B105D4061806220668067017D0280C0823084028A108C108D448F40C0CFC2EFC47FCA4BCC2FCE8FD61CD81CDE80E040E205E40512
-:4001C000E622023F043F0A3F0E3F103F16021A101E042001243F2A202E08363F3E4058045B045F01817F820484088701880189018A088B288D318E108F029001953196024A
-:40020000974E98289D409E019F3DA008A201A501A601A714A809AC01B007B10FB218B372B420B620BA0ABE10C206C70EC810C9FFCAFFCBFFCF83D804D904DA04DB04DC9961
-:40024000DD09DF010040010803880492050408100AA20E840F1110011120130A151016801788188019441A901B2D1F8020802104220C23402A0432043340382039043A0193
-:400280003B4049105008588859216004628263206D40812082048408854889048A808D018E108F289020950C9740989099109E259F44A080A104A203A501A608A888A98090
-:4002C000AD02AE01B050B180B202B304B508B730C0FFC2FFC4FFCA02CC0ACE0FD204D60FD80FE241E408E601EA1FEE0100C0010D0440050D090D0A070C180D010E010F185B
-:400300001002110412181312150D162018181B071F0D2218230D2404250D26102804290D2A082C1F2D0D32803303343F351C36403E403F14580459045C095F0181018501E5
-:40034000870289018F019006920993019409950196069B019D01A101A501A901AD01AE03AF02B002B103B204B408B601B8AABE55BF01D804D904DB04DF0100810128080616
-:400380000A080C0A1080110812051540180219A81A021B101D411E201F10202022102440288029042B062C012D112E0430013288332036A1370A388039243B023E403F191C
-:4003C0006C0A800281018340840489408B4090809140920894529510962697119A049C019EA19FCEA0C0A104A30CA511A640A710A80CAA01AF01B040B104C00FC23EC48F76
-:40040000CAFFCCFFCEFFE004E288E681EA04EC08EE0400100101040805010601080209010C020F011002130214021704180319011A041C1C1D011E032202240225012802B9
-:4004400029012C022F01341F3507370739A03E10580459045C905F0180488210837F86498710893F8A028C408D018E308F40900193089401953F98489A209B029C499D3F71
-:40048000A204A320A449A73FAA01AB3FAE01AF04B038B407B540B640B73FBA20BF50D804D904DC09DF010061010804820528080509400B040C200D8A0F081020120113125A
-:4004C00014881584184919201B201E0822202302240425D026C0284429682D102E44311032813308340135503604380239083A813B103C043D013E803F10811882108512C5
-:40050000881289049082940195359644979399809C819EA09F8CA010A210A30CA511A6E8A722AA01AF10B201B410B504B601C0FFC2FFC4FFCA7FCCFFCEFFE081E208E60EAE
-:40054000EA0401020501062009020A180F02101F1103140215021618181819021A011E072004210222102502281829022C042E082F033503363F3F10580459045C095F01DA
-:400580008201831385138604884089038A068E028F02905691039221931096019708987F99039C069F04A007A103A208A406A678A701A806AB03AC11AD03AE26B10FB31078
-:4005C000B47FB50FBE10BF04D608D804D904DB04DC90DD90DF010004010102010308050407040A850B200E420F24111212321404158016801A081E0221052220251028111D
-:400600002B882C022F64302231013204334034013719380139403A143C083D813E1059405C085D0462C0800181028202884089418C208D40918092C09324952096209824F0
-:4006400099279A869B049C81A004A101A208A310A408A510A683AA40B005B310B661C06FC2FFC4DFCAFFCCEFCEFFD608D808E080E228E60AE820EA10000104080519080106
-:400680000B090E1010011504160219011A081C012208262029122A042C013007330334383518370438203F4056085804590B5B045C995D905F0182018301860187018904CD
-:4006C0008A018B038D038E018F04900193019601970198019B019C019F01A101A201A304A601A701AA01AB01AE01AF02B201B507B601BE44BF10D804D904DB04DF010166A1
-:400700000486078808410A240C800E400F641120122213021601171519031A841B101C211D041E201F40200221242208262029202CA02EA02F0130083120379539283C045F
-:400740003D813F3058805D045F0463016D406E407A80831087C0908691819306940196409751986499209A269B1F9D04A0A0A141A380A410A520A691A710A980AB04AC20E9
-:40078000B084B140B304C0FFC2FFC4FFCAF4CCF6CEF6D608D808DE01E004E408ECA00318051806200701081809020B180C040D040E100F10101F110413081402161817070A
-:4007C00018181A011B201C041E08211822182A072C402D1F323F333F36403E40580459045B045C995F0181228220853386188A078B028D028F20901F912893509418958288
-:400800009705981899109A019B089C409D019F80A004A122A208A344A733A802A913AA18AB20AC04AE10B170B23FB307B580B640B708BB0ABE40BF50D804D904DB04DC9924
-:40084000DF01001103100514060108040A400B050D400F6412011312140815401701181019401B041F84200C21582241230225042608280429102B502C802E4031283281A0
-:400880003618370239A03A013B063C803D013F244FC05940640867086D4081408201844088048B048D058E049082910193029680974499A09A229B1D9C049D04A060A410BC
-:4008C000A680A710A810AB14ACA0B120B401B680C0EEC2FFC4DBCA97CCEFCEFFD608E010E2A0E410E640E820EAD0EC10EE400328053807010A200B070D3F100412081418FD
-:40090000174018181A011C041D041E101F30213422072308250226182738280229082A182B102C1F337F363F580459045C995F0181608205850B87F0880D89188BC38D0210
-:400940008F04981099029B059C019E10A101A80AA9F1AB0AAF02B010B180B307B403B540B60CB738B980BB08BE01BF50C024C9FFCAFFCBFFD004D601D80BD904DA04DB0429
-:40098000DC99DD09DF01E080E240E440E56400200510068008040A800B060C100E0A106011101340160819801C801D111E421F512010252126042702280429012B102C04B8
-:4009C0002F4131043240341038123B443D123F6445204702584059806C416D016F1474A0762077097E808040822A87108E40C052C2CFC44FCAB7CC2ACEFFD0A0DE80E08003
-:400A0000E660003F013F063F073F083F0B200D010E3F10011308160217021A101B101C3F1D3F2208233F26042704293F2A202E3F2F3F333F363F3E403F04580459045F0101
-:400A4000810582028406852C86018702880689108E018F05900391139208932095059606980799059C019D0F9E069F10A105A201A401A505A60CA806A905AC06AD08AF0286
-:400A8000B13FB40FBE10BF01D804D904DF01018102200308040805860604084409400A040B500C410F28111012011309142A15011B401F202204260129822A082B0C2D11AD
-:400AC0002E4430443201331034453510380839103B413C043F6189408C088D048E208F05900491119246935196089702982399929A0D9B189C089F04A140A318A601A760CD
-:400B0000A880A966AA05AB10AC10AE80B040B111C0FFC2FFC4FFCAFFCCFFCEFFE402E640E80FEC04EE01000604060A060D020E04110112061602180619021C0120012406CE
-:400B4000250228062C06300132063302340137013A223B0C3E043F40580459045B045C995F01800181808580860289A98D808E01915695809601990C9A049B409D3D9E010B
-:400B80009FC0A001A180A401A580AB03AC01AD30B007B1FFBA02BF01C001C50CC60EC805C9FFCAFFCBFFD004D601D804D904DA04DB04DC09DD09DF01E2C00182022004800A
-:400BC00005290A280B010C240E8210011290140A1502161019021B021C041D031E201F102101258C2608281029822A102B082F203001310832903610370138883B223F80B0
-:400C00004001442045044B045340681069596A466B906F01701071507288735979807B02822083028421858087108A208C108D018F01908992209599964697979816998874
-:400C40009CC99D509EA09F8CA140A2C0A308A50BA608A702B120B210C0FDC2F7C4FDCA4FCCAFCE1FD008E00CE202E422E601EA80EE0802100301050409080D0F100411080B
-:400C800015081A081B0F1C011D031F0C21082203270229082C082F083004310F3201341836023E053F015608580459045B045C095D905F018027842788278B018C208E0CA7
-:400CC000903792C09501962798209A029C209E01A0F3A208A427A837A902AA40AC10AE87B2F0B40FB503BE14C034C620C808C9FFCAFFCBFFCD20CEF0D110D608D804D90455
-:400D0000DA04DB04DC90DD99DF01E108E240E340E480E640E7400004011002010384058006800701082009080A820C020D200E021226130216421A201B101CA01D281E0268
-:400D40001F082110274029202C212F4430403248344035013620370839203C083E5140404104501059405F80628064026A406B036C0278047A2082018310854086048709E0
-:400D800089208B808C028D018E108F109108928293209404953196359788982899209A469E019F59A004A101A22AA468A540A7A8A880B010B104B201C01FC2DFC49FCAF44B
-:400DC000CCF2CEF4D003D618D818E210E472E688E820EE09000E0270060409020A0E0E02102E124116011A011C7F1D01200F2210240E2A082C212E4E307F310235013E01EF
-:400E00003F11580459045B045F018108820885048603880389018E048F089003930F95089603980399089C039D0FA003A108A602A702A908AA01AD03AF0CB60FB70FBF40A7
-:400E4000D608D804D904DB04DC09DD90DF0100040201038805020604072108410A800B280C210D080E021024110212021428170219021E031F802040221027012C212E10D7
-:400E80002F403280344035803601371838203C283D8158805A205C105F40652066806701680A80108740888089208B208C028E408F8190249101929093A894409601982C55
-:400EC00099809A059B1A9E80A034A149A282A308A408A780A824AB2CAC01AD41B344B410C0FFC2FFC47FCAF0CCF8CEF4D63CD830E250E420E651E880EC801A401F083210ED
-:400F0000330837123A106A406B108A108E04C630CCF0CE10300431803440350839013D8085408E109620A604B702CCF0CE60E2405280570889018A80928095019C449D08FB
-:400F4000A580A604AA40D460EE80844485808A1092809C449D08A580A604AF08E210E650EE4014407B028A06C404DC01E001E6045602620296449A02A70AB040B640B708E3
-:400F8000D604D802EA09EE021B08830286809644A602A70AC6080A010B200E200F02861187108A0296449840A280A602B040C20FE404E801238026148B8092809902A6145F
-:400FC000AD08B102C8E0EE101A025A807220750286018E2092809902C640D480DC80DE20E44004100A800E400F021E045280548058405D0485048701941096449840A280E3
-:40100000A810AF01C001C20DC601D407D60182409280B480EC02010109010B010D010F0111011B011D0100FF01AB020211050000BF0000A09F001F000000000000000000E5
-:40104000100000004000000000000000C0000000FF0000B8470047000001000080000002820082000000000000010100010000002700180127001801000400000005000008
+:400000000145004008520040015B004001650040010101404D0201403D0301404C0401404D0501404D060140500701404B0801404B0901404B0A0140500B0140470C0140CB
+:40004000500D0140520E0140350F014046140140541501404B160140561701404718014044190140591A0140571B01400A400140104101400E4201400943014004440140BE
+:400080000D4501400A4601400F470140094801400F4901401B4C0140084D014008500140045101407E0208440905108011821801600C610A7C4027212A0A8C8000010109B1
+:4000C0000202040805090808090F0B100C080D010F02100F1120140416011709180819101B0E1D011E01210422082301240829092A0E2C0D320F331F35203B083E043F1020
+:400100005608580459045B045C905D905F01850287018C01900F9401960898249A089E07A008A101A222A302AA08AE10B01FB101B302B420B90ABE10BF05C202C70EC810AC
+:40014000C9FFCAFFCBFFCF83D804D904DA04DB04DC09DD09DF01030204A10620074008010A060B200C800D100E400F2010421110150416821720180419011E10202021010F
+:40018000262027202A012C042E023508376138083E583F0240045208588859215A025D4060026108621265806F0180068140874088408A088E209880C0F1C2FFC4FBCAA1EC
+:4001C000CCF0CEF2D004D61FD81FE20CE6C5EE82010D04020601070109080C010D080E0E100F130E150F161019081C201D082101220F2302240125042604270128012908CA
+:400200002A082C012F08301F3220330F3E043F045608580459045B045C095D905F01810182088302840885028A108B018C088D038F049102920194049701982099029A1FB5
+:400240009C089D02A202A302A408A501A704A808A902AC1FAD03AE20B107B43FBF01D804D904DB04DC09DF0100400108048006A0070809880A400C810E080F20100511082C
+:40028000130115251740185019011B011E081F20210827402AA02B902C052D022F20308031213208350136803728388039243B013D083E4A3F2158405C105D806180851076
+:4002C00087029102938094A195349644972099809B209C0C9D089EBAA480A602A713A908AC03B010B520B601C0F5C2FDC4FFCAFFCCFFCEFFD638D808E20AE648E880EA03A0
+:40030000EE820003010D050506010801090C0B020C010D0D1001111012021602170D1801190D1C011D0D2201230D2401250D280129092C012D012E022F02310C3510360355
+:4003400037033E403F51580459045B045F0180208102820F8404860A882F89028D028EA09204948095039640970C98049A099E10A020A102A20FA480A802AC01AD0AAF0550
+:40038000B060B108B21FB306B480B501B61FBE10BF01D804D904DB04DC99DF01000902080302048A0708082209880C800D100F9011501305158016A01710180919041A08AD
+:4003C0001BD21D80210923042440254026102B422C042D012E402F20310836843721380239803A103D203E083F825D015F0169506AA06F0178017B807D027F8080048604BE
+:4004000089108A028F01938094A19525964497219B209C0D9D0A9EA89F08A321A480A520A68AA790AD01B040B210C0FFC2FFC4FFCAF9CCF2CEFDE242E401EA01000103027E
+:4004400004E0050108010A080B020CE00F02100F1280130814481602170218201B021E071F02200422482302261027022A082B042F10311F34E0361F382039023F015804DF
+:4004800059045B045C095F0180038109840387318A018B098C038F06900391129309940395099712980399409E02A003A309A603A709A803A909AC03AD49AF24B338B40349
+:4004C000B540B707BB88BE10D804D904DB04DC90DF010080012002800320048A052008180A010B400C020D080E0610021325172918081E061F802002215423252480284155
+:4005000029202B202C872D202F203108321233013448350137A0380239883B103C803E043F115A806E408340860287048A0690029289935094019704981A99019B889C84CD
+:400540009D209F20A0C2A108A280A328A401AB10B204C0FFC2FFC47FCAFFCCF7CEFFD608E080E620EA85EE2002800404050D064808200A400C0111011210144816021A07E2
+:400580001B051C401E202608280129102A082C0F2D0A3020310C32C03303341F362037103A083E413F4056085804590B5B045C995D905F01822083018607870F88218A0825
+:4005C0008B018C218F019210930E9428964297059AC89B039F01A02FA280A301A444A628A709A90FAA20AD0FB105B21FB4E0B503B709BA20BF51D804D904DC09DF010001EA
+:400600000184030805A4078009090A060D080E881006121015141701180219811A051B481D041E081F20210422412501264027082B052C822F2432113408350137A03908B7
+:400640003C823D043F144410450858805B10630A64086610780284018601911092289358950896019704980A9B819D249F20A0C2A108A280A401A761A840AF11B040B504F1
+:40068000B702C0FFC27FC477CAFCCCF5CEF2D60CD80CDE01E202E640E880EA10EE4002080349077F08010A280B090C2F0F091001117F1408160217091A071B091E401F2962
+:4006C000221023722709280429782A282B042F19310732603348341F352837183F55580459045B045C095F01802081048440850186A088418A088C4F8E808F04920794041B
+:40070000966898689A029B019C41A208A610AA40AD02B01FB304B503B6E0BA80BF04D608D804D904DB04DC99DD90DF010128024003010521070109040A810B080D080E0633
+:400740000F80128013181608170218821A801D081E041F14221423102601271A2B012D042E012F253210341036843721380239083A403C023D1A3E0A3F54584060026240FE
+:4007800068026B016F0A831886408B048C018D089342951496019714980899019B809C109D209E0A9F21A0C0A284A402A509A74AB308B504C0DFC2FFC45ECAF8CCF4CEFBE6
+:4007C000D608D808E010E280E644EE820002012F020103800402060107070A060B200C020E010FC81002120114071528174218021A011B101C021E012121220523082544DD
+:400800002607272829212A012C0731E03207331F3B023E04580459045C905F0182698502861988198E198F119019924493049419962298229A199B089C19A20EA306A61923
+:40084000A702A910AA19AB01AD01AE19AF10B070B208B301B407B510B607B70EB928BAA2BB80BE04BF14D804D904DB04DC99DF010082012402400521060207200810094941
+:400880000B200C020D090E010F04104213141514164017801A201C821D011E281F012010210423C025442680270829202A082B402C802F1A30803108329034483614378162
+:4008C000390A3B503D403F046D408C10C0FFC2FFC4FFCAF7CCA6CE5FE210010E04080508060409080C0D0E020F08110812091504180819081A021D081E04200423012702A7
+:4009000029082D08300C320C330F34033A0A3F045608580459045B045C095D905F01801382048402871088028B1F8C088E018F1F901991019202951F96099A089B049C0273
+:400940009D1FA001A20CA308A602A720A802AB02AC1BAD1FB210B40FB73FBB80BE14D804D904DC90DF010108021104020540060807200A040B810D110F2211021405161004
+:400980001702190A1A041E201F20210425402680270229442A212C802E202F2130803120320433113545371039163A803B033D843F2058806002680D6A508101821084A1C0
+:4009C000880289028B048E5090029134922893859508980599459AA99B219C229D0AA080A121A311A40CA690AA88AD80AF10B111B504B648C0F5C2FBC4F8CAFFCCFFCE7FAE
+:400A0000D608D808E248E401E602E809EE030001062008010A7E0D010E08107F167F1A041E1020022101247E26012A402C7F3501367F3B303E40580459045B045C905F0179
+:400A4000804484118708881189078C078E088F109211941195A5974298119B429C119F21A011A307A433A5C6A644A721A878AA02AC20AD84AE02B3E0B51FB67FB71FB9A0BC
+:400A8000BE40C004C5E0C6C0C80AC9FFCAFFCBFFD004D601D804D904DA04DB04DC90DD09DF01E2C001160201030204020540071409A80B400C810D200F2010041141130440
+:400AC00015A016A019801F80214023152510270428222B402F8030083250384039083B103D8041014B025210688069756B116C016E406F02705071E972A07348810A8204C4
+:400B00008404850487048A108C509040910292A8938094A295A496409733980199049B209C269D0A9EB89F18A141A351A484A530A68CA808B210B540C0FFC2FFC4FFCA8B79
+:400B4000CC0ECE1ED001E003E208E402EA40EE060601083109100D0C0E080F021040130116021702180319011A101E0420382304240325082608290A2B042C022E2130400E
+:400B8000310F3207351036383A803E013F10580459045B045C995F018001830C8401870188018A028B078C018F019001930194019701980199079E019F01A001A108A302BA
+:400BC000A601A701A801AB01AC01AE02AF01B507B603B708BE40BF50D804D904DF0100820201032A05480608081909800B400D080E461002128013241501174818011D4E2B
+:400C00001E01218022102408260228082BA22C082E022F103011328436063710380239A83D103F806D5080048280850186058C208D01900291A89248934494019620981A26
+:400C40009A029B609C809D20A043A284A328AB80B604C0EFC2FFC4BFCAEFCCEFCE3FE080E451E8C0EE02000801010201050108040B010C010D010E081101130217011901F5
+:400C80001A011D01210123022401250129012A022D01300332043303340836083A023E543F0440434502480149FF4AFF4BFF4D204EF05110580459045A045C095D095F017F
+:400CC0006108624063406480664067408004840885CC86018722881F8C048D01900493119401961E9722980499F19C019E10A004A344A588A604A824A9AAAA19AB44AC0134
+:400D0000AE22B020B30FB50EB61FB7F0BE41BF10D804D90BDC90DF01002001020301058907080B040C200D090E011010120816801764181019221A0A1B801D021E0222083E
+:400D400025602711280929022B202C082E022F10301232843606371039A83A013D884010410248107C0283408520881089088B308C088D448F4091EA920193049602972033
+:400D8000981B99819A839B0C9D209F10A022A108A286A320A408A601A7C0A904AB04AD01AE01B080B18AB608B708C0FBC2F2C4F6CAEFCCEFCE5FD003DE80E0A0E240E47094
+:400DC000E602E890ECC01B011F0231203302368037083B40C630CCF0CE103088364037043A023C2088108F0893809F08A520AE80AF41B340CCF0CE60EE4053405640840897
+:400E00008C8093809A409E029F04A488A520A6C0B2C0D460E2408E0292029E02A520A6C0AB04AE01EA80EE4015027B02C404DC015940670882108E4191029720AF10B7020E
+:400E4000D401D801E008E602EC021A4085408D049102966097289D40A201C608E60209440F4191029420962097299C409D40A201A544A810AB01B040C20FEA0126809202EF
+:400E8000A320A520A680AE40B720C820EE405280572079407E01828085208D409202A320A520D460DC80DE20E210E62004200A200C400F401F1050805B405E025F8083408D
+:400EC000894091029420962097209C409D40A201AF40B304C001C20DC601D405D605E001E801850188809102A480B3C0E401EA04EC04010109010B010D010F0111011B01BF
+:400F00001D0100FF01AB020211050000BF0000A09F001F000000000000000000100000004000000000000000C0000000FF0000B847004700000100008000000282008200D5
+:400F400000000000000303000300000027001801270018010004000000050000000000000000000000000000000000000000000000000000000000000000000000000000DF
+:400F80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031
+:400FC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F1
+:4010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B0
+:401040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070
 :401080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030
 :4010C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F0
 :4011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000AF
@@ -4615,12 +4615,12 @@
 :0200000490105A
 :04000000BC90ACAF55
 :0200000490303A
-:020000006F2D62
+:0200000009CD28
 :0200000490402A
 :4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C0
 :400040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080
 :400080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040
 :4000C0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 :0200000490501A
-:0C00000000012E16106900002E317F96C2
+:0C00000000012E16106900002E321A3686
 :00000001FF
--- a/FluxEngine.cydsn/FIFOout/FIFOout.v
+++ b/FluxEngine.cydsn/FIFOout/FIFOout.v
@@ -20,33 +20,34 @@ module FIFOout (
 wire [7:0] po;
 assign d = po;

-localparam STATE_WAIT = 1'b0;
-localparam STATE_READ = 1'b1;
+localparam STATE_WAITFORREQ = 0;
+localparam STATE_READFROMFIFO = 1;
+localparam STATE_WAITFORNREQ = 2;

-reg state;
-reg oldreq;
+reg [1:0] state;
+wire readfromfifo;

-assign ack = (state != STATE_READ);
+assign ack = (state == STATE_WAITFORNREQ);
+assign readfromfifo = (state == STATE_READFROMFIFO);

 always @(posedge clk)
 begin
    case (state)
-        STATE_WAIT:
+        /* opcode is not valid; req is low; wait for req to go high. */
+        STATE_WAITFORREQ:
        begin
-            if (!empty)
-            begin
-                if (req && !oldreq)
-                begin
-                    state <= STATE_READ;
-                end
-                oldreq <= req;
-            end
+            if (!empty && req)
+                state <= STATE_READFROMFIFO;
        end
        
-        STATE_READ:
-        begin
-            state <= STATE_WAIT;
-        end
+        /* Fetch a single value from the FIFO. */
+        STATE_READFROMFIFO:
+            state <= STATE_WAITFORNREQ;
+            
+        /* opcode is valid; ack is high. Wait for req to go low. */
+        STATE_WAITFORNREQ:
+            if (!req)
+                state <= STATE_WAITFORREQ;
    endcase
 end
            
@@ -55,11 +56,11 @@ cy_psoc3_dp #(.cy_dpconfig(
    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
-    `CS_CMP_SEL_CFGA, /*CFGRAM0: STATE_WAITFORREQ*/
+    `CS_CMP_SEL_CFGA, /*CFGRAM0: idle */
    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
    `CS_SHFT_OP_PASS, `CS_A0_SRC___F0, `CS_A1_SRC_NONE,
    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
-    `CS_CMP_SEL_CFGA, /*CFGRAM1: STATE_LOAD*/
+    `CS_CMP_SEL_CFGA, /*CFGRAM1: read from fifo */
    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
@@ -102,7 +103,7 @@ cy_psoc3_dp #(.cy_dpconfig(
 )) dp(
        /*  input                   */  .reset(1'b0),
        /*  input                   */  .clk(clk),
-        /*  input   [02:00]         */  .cs_addr({2'b0, state}),
+        /*  input   [02:00]         */  .cs_addr({2'b0, readfromfifo}),
        /*  input                   */  .route_si(1'b0),
        /*  input                   */  .route_ci(1'b0),
        /*  input                   */  .f0_load(1'b0),
--- a/FluxEngine.cydsn/FluxEngine.cydwr
+++ b/FluxEngine.cydsn/FluxEngine.cydwr
@@ -851,6 +851,7 @@
      <Data key="4a398466-709f-4228-9500-96178658e13e" value="RDATA" />
      <Data key="5a3407c1-b434-4438-a7b4-b9dfd2280495" value="MOTEA" />
      <Data key="8d318d8b-cf7b-4b6b-b02c-ab1c5c49d0ba" value="SW1" />
+      <Data key="8fc20a4f-e4d1-44b3-a5d4-546e8628d61e" value="LED" />
      <Data key="12e00eac-69b5-4717-85c8-25ef6b224d4c" value="DEBUG_PINS" />
      <Data key="41e2d8ed-5494-4d8c-8ff7-f4f789cece51" value="REDWC" />
      <Data key="264be2d3-9481-494b-8d9c-c1905a45e9cc" value="FDD" />
@@ -3977,6 +3978,11 @@
        <Data key="Port Format" value="2,2" />
      </Group>
    </Group>
+    <Group key="8fc20a4f-e4d1-44b3-a5d4-546e8628d61e">
+      <Group key="0">
+        <Data key="Port Format" value="2,1" />
+      </Group>
+    </Group>
    <Group key="12e00eac-69b5-4717-85c8-25ef6b224d4c">
      <Group key="0">
        <Data key="Port Format" value="2,2" />
--- a/FluxEngine.cydsn/FluxEngine.cyprj
+++ b/FluxEngine.cydsn/FluxEngine.cyprj
@@ -2555,20 +2555,20 @@
 <CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFolderSerialize" version="3">
 <CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtBaseContainerSerialize" version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="CLOCK8" persistent="">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <CyGuid_0820c2e7-528d-4137-9a08-97257b946089 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemListSerialize" version="2">
 <dependencies>
 <CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="CLOCK8.c" persistent="Generated_Source\PSoC5\CLOCK8.c">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <build_action v="SOURCE_C;CortexM3;;;" />
 <PropertyDeltas />
 </CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
 <CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="CLOCK8.h" persistent="Generated_Source\PSoC5\CLOCK8.h">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <build_action v="HEADER;;;;" />
 <PropertyDeltas />
@@ -2614,20 +2614,20 @@
 <CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFolderSerialize" version="3">
 <CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtBaseContainerSerialize" version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="RPM300" persistent="">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <CyGuid_0820c2e7-528d-4137-9a08-97257b946089 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemListSerialize" version="2">
 <dependencies>
 <CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="RPM300.c" persistent="Generated_Source\PSoC5\RPM300.c">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <build_action v="SOURCE_C;CortexM3;;;" />
 <PropertyDeltas />
 </CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
 <CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="RPM300.h" persistent="Generated_Source\PSoC5\RPM300.h">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <build_action v="HEADER;;;;" />
 <PropertyDeltas />
@@ -2640,20 +2640,20 @@
 <CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFolderSerialize" version="3">
 <CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtBaseContainerSerialize" version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="RPM360" persistent="">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <CyGuid_0820c2e7-528d-4137-9a08-97257b946089 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemListSerialize" version="2">
 <dependencies>
 <CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="RPM360.c" persistent="Generated_Source\PSoC5\RPM360.c">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <build_action v="SOURCE_C;CortexM3;;;" />
 <PropertyDeltas />
 </CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
 <CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
 <CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="RPM360.h" persistent="Generated_Source\PSoC5\RPM360.h">
-<Hidden v="False" />
+<Hidden v="True" />
 </CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
 <build_action v="HEADER;;;;" />
 <PropertyDeltas />
@@ -2696,6 +2696,105 @@
 </CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8>
 <filters />
 </CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0>
+<CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFolderSerialize" version="3">
+<CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtBaseContainerSerialize" version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="INDEX_REG" persistent="">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<CyGuid_0820c2e7-528d-4137-9a08-97257b946089 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemListSerialize" version="2">
+<dependencies>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="INDEX_REG.h" persistent="Generated_Source\PSoC5\INDEX_REG.h">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="HEADER;;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="INDEX_REG.c" persistent="Generated_Source\PSoC5\INDEX_REG.c">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="SOURCE_C;CortexM3;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="INDEX_REG_PM.c" persistent="Generated_Source\PSoC5\INDEX_REG_PM.c">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="SOURCE_C;CortexM3;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+</dependencies>
+</CyGuid_0820c2e7-528d-4137-9a08-97257b946089>
+</CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8>
+<filters />
+</CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0>
+<CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFolderSerialize" version="3">
+<CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtBaseContainerSerialize" version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="FAKE_INDEX_GENERATOR_REG" persistent="">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<CyGuid_0820c2e7-528d-4137-9a08-97257b946089 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemListSerialize" version="2">
+<dependencies>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="FAKE_INDEX_GENERATOR_REG.h" persistent="Generated_Source\PSoC5\FAKE_INDEX_GENERATOR_REG.h">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="HEADER;;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="FAKE_INDEX_GENERATOR_REG.c" persistent="Generated_Source\PSoC5\FAKE_INDEX_GENERATOR_REG.c">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="SOURCE_C;CortexM3;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="FAKE_INDEX_GENERATOR_REG_PM.c" persistent="Generated_Source\PSoC5\FAKE_INDEX_GENERATOR_REG_PM.c">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="SOURCE_C;CortexM3;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+</dependencies>
+</CyGuid_0820c2e7-528d-4137-9a08-97257b946089>
+</CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8>
+<filters />
+</CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0>
+<CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFolderSerialize" version="3">
+<CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtBaseContainerSerialize" version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="LED" persistent="">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<CyGuid_0820c2e7-528d-4137-9a08-97257b946089 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemListSerialize" version="2">
+<dependencies>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="LED_aliases.h" persistent="Generated_Source\PSoC5\LED_aliases.h">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="HEADER;;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="LED.c" persistent="Generated_Source\PSoC5\LED.c">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="SOURCE_C;CortexM3;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+<CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtFileSerialize" version="3" xml_contents_version="1">
+<CyGuid_31768f72-0253-412b-af77-e7dba74d1330 type_name="CyDesigner.Common.ProjMgmt.Model.CyPrjMgmtItemSerialize" version="2" name="LED.h" persistent="Generated_Source\PSoC5\LED.h">
+<Hidden v="False" />
+</CyGuid_31768f72-0253-412b-af77-e7dba74d1330>
+<build_action v="HEADER;;;;" />
+<PropertyDeltas />
+</CyGuid_8b8ab257-35d3-4473-b57b-36315200b38b>
+</dependencies>
+</CyGuid_0820c2e7-528d-4137-9a08-97257b946089>
+</CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8>
+<filters />
+</CyGuid_ebc4f06d-207f-49c2-a540-72acf4adabc0>
 </dependencies>
 </CyGuid_0820c2e7-528d-4137-9a08-97257b946089>
 </CyGuid_2f73275c-45bf-46ba-b3b1-00a2fe0c8dd8>
@@ -3281,6 +3380,6 @@
 </ignored_deps>
 </CyGuid_495451fe-d201-4d01-b22d-5d3f5609ac37>
 <boot_component v="" />
-<current_generation v="84" />
+<current_generation v="138" />
 </CyGuid_fec8f9e8-2365-4bdb-96d3-a4380222e01b>
 </CyXmlSerializer>
--- a/FluxEngine.cydsn/Sampler/Sampler.v
+++ b/FluxEngine.cydsn/Sampler/Sampler.v
@@ -21,27 +21,10 @@ module Sampler (

 localparam STATE_RESET = 0;
 localparam STATE_WAITING = 1;
-localparam STATE_INTERVAL = 2;
-localparam STATE_DISPATCH = 3;
-localparam STATE_OPCODE = 4;
-localparam STATE_COUNTING = 5;
+localparam STATE_OPCODE = 2;

-reg [2:0] state;
-wire [6:0] counter;
-
-wire countnow;
-assign countnow = (state == STATE_COUNTING);
-
-wire counterreset;
-assign counterreset = (state == STATE_INTERVAL) || (state == STATE_OPCODE);
-
-SuperCounter #(.Delta(1), .ResetValue(0)) Counter
-(
-    /* input */ .clk(clock),
-    /* input */ .reset(counterreset),
-    /* input */ .count(countnow),
-    /* output */ .d(counter)
-);
+reg [1:0] state;
+reg [6:0] counter;

 reg oldsampleclock;
 wire sampleclocked;
@@ -55,7 +38,7 @@ wire rdataed;
 reg oldrdata;
 assign rdataed = !oldrdata && rdata;

-assign req = (state == STATE_INTERVAL) || (state == STATE_OPCODE);
+assign req = (state == STATE_OPCODE);

 always @(posedge clock)
 begin
@@ -66,6 +49,7 @@ begin
        oldsampleclock <= 0;
        oldindex <= 0;
        oldrdata <= 0;
+        counter <= 0;
    end
    else
        case (state)
@@ -74,10 +58,23 @@ begin
            
            STATE_WAITING:
            begin
-                if (rdataed || indexed)
+                /* If something has happened, emit any necessary interval byte. */
+                if ((rdataed || indexed) && (counter != 0))
                begin
                    opcode <= {0, counter};
-                    state <= STATE_INTERVAL;
+                    state <= STATE_OPCODE;
+                end
+                else if (indexed)
+                begin
+                    oldindex <= 1;
+                    opcode <= 8'h81;
+                    state <= STATE_OPCODE;
+                end
+                else if (rdataed)
+                begin
+                    oldrdata <= 1;
+                    opcode <= 8'h80;
+                    state <= STATE_OPCODE;
                end
                else if (sampleclocked)
                begin
@@ -87,10 +84,11 @@ begin
                        opcode <= {0, counter};
                        state <= STATE_OPCODE;
                    end
-                    else
-                        state <= STATE_COUNTING;
+                    counter <= counter + 1;
                end
                
+                /* Reset state once we've done the thing. */
+                
                if (oldrdata && !rdata)
                    oldrdata <= 0;
                if (oldindex && !index)
@@ -99,32 +97,11 @@ begin
                    oldsampleclock <= 0;
            end
            
-            STATE_INTERVAL: /* interval byte sent here; counter reset */
-                state <= STATE_DISPATCH;
-                
-            STATE_DISPATCH: /* relax after interval byte, dispatch for opcode */
+            STATE_OPCODE: /* opcode or interval byte sent here */
            begin
-                if (rdataed)
-                begin
-                    oldrdata <= 1;
-                    opcode <= 8'h80;
-                    state <= STATE_OPCODE;
-                end
-                else if (indexed)
-                begin
-                    oldindex <= 1;
-                    opcode <= 8'h81;
-                    state <= STATE_OPCODE;
-                end
-                else
-                    state <= STATE_WAITING;
+                state <= STATE_WAITING;
+                counter <= 0;
            end
-            
-            STATE_OPCODE: /* opcode byte sent here */
-                state <= STATE_WAITING;
-                            
-            STATE_COUNTING:
-                state <= STATE_WAITING;
        endcase
 end

--- a/FluxEngine.cydsn/Sequencer/Sequencer.v
+++ b/FluxEngine.cydsn/Sequencer/Sequencer.v
@@ -18,19 +18,18 @@ module Sequencer (

 //`#start body` -- edit after this line, do not edit this line

-localparam STATE_IDLE = 0;
-localparam STATE_LOAD = 1;
-localparam STATE_WAITING = 2;
-localparam STATE_PULSING = 3;
-localparam STATE_INDEXING = 4;
+localparam STATE_LOAD = 0;
+localparam STATE_WAITING = 1;
+localparam STATE_PULSING = 2;
+localparam STATE_INDEXING = 3;

 localparam OPCODE_PULSE = 8'h80;
 localparam OPCODE_INDEX = 8'h81;

-reg [2:0] state;
+reg [1:0] state;
 reg [6:0] countdown;

-assign req = (state == STATE_LOAD);
+assign req = (!reset && (state == STATE_LOAD));
 assign wdata = (state == STATE_PULSING);
 assign debug_state = state;

@@ -40,9 +39,7 @@ always @(posedge clock) olddataclock <= dataclock;
 assign dataclocked = !olddataclock && dataclock;

 reg oldsampleclock;
-wire sampleclocked;
-always @(posedge clock) oldsampleclock <= sampleclock;
-assign sampleclocked = !oldsampleclock && sampleclock;
+reg sampleclocked;

 reg oldindex;
 wire indexed;
@@ -53,15 +50,19 @@ always @(posedge clock)
 begin
    if (reset)
    begin
-        state <= STATE_IDLE;
+        state <= STATE_LOAD;
        countdown <= 0;
    end
    else
+    begin
+        if (!oldsampleclock && sampleclock)
+            sampleclocked <= 1;
+        oldsampleclock <= sampleclock;
+        
        case (state)
-            STATE_IDLE:
-                state <= STATE_LOAD;
-            
            STATE_LOAD:
+                /* Wait for a posedge on dataclocked, indicating an opcode has
+                 * arrived. */
                if (dataclocked)
                    case (opcode)
                        OPCODE_PULSE:
@@ -80,10 +81,12 @@ begin
            STATE_WAITING:
                if (sampleclocked)
                begin
-                    if (countdown == 0)
+                    sampleclocked <= 0;
+                    countdown <= countdown - 1;
+                    /* Nasty fudge factor here to account for one to two
+                     * sample ticks lost per pulse. */
+                    if (countdown <= 2)
                        state <= STATE_LOAD;
-                    else
-                        countdown <= countdown - 1;
                end
            
            STATE_PULSING:
@@ -92,9 +95,8 @@ begin
            STATE_INDEXING:
                if (indexed)
                    state <= STATE_LOAD;
-                else
-                    state <= STATE_INDEXING;
        endcase
+    end
 end

 //`#end` -- edit above this line, do not edit this line
--- a/FluxEngine.cydsn/TopDesign/TopDesign.cysch
+++ b/FluxEngine.cydsn/TopDesign/TopDesign.cysch
--- a/FluxEngine.cydsn/main.c
+++ b/FluxEngine.cydsn/main.c
@@ -17,20 +17,24 @@
 #define STEP_TOWARDS0 1
 #define STEP_AWAYFROM0 0

-static volatile uint32_t clock = 0;
+static bool drive0_present;
+static bool drive1_present;
+
+static volatile uint32_t clock = 0; /* ms */
 static volatile bool index_irq = false;

 static bool motor_on = false;
 static uint32_t motor_on_time = 0;
 static bool homed = false;
 static int current_track = 0;
-static uint8_t current_drive_flags = 0;
+static struct set_drive_frame current_drive_flags;

-#define BUFFER_COUNT 16
+#define BUFFER_COUNT 64 /* the maximum */
 #define BUFFER_SIZE 64
 static uint8_t td[BUFFER_COUNT];
 static uint8_t dma_buffer[BUFFER_COUNT][BUFFER_SIZE] __attribute__((aligned()));
 static uint8_t usb_buffer[BUFFER_SIZE] __attribute__((aligned()));
+static uint8_t xfer_buffer[BUFFER_SIZE] __attribute__((aligned()));
 static uint8_t dma_channel;
 #define NEXT_BUFFER(b) (((b)+1) % BUFFER_COUNT)

@@ -41,10 +45,27 @@ static volatile bool dma_underrun = false;
 #define DECLARE_REPLY_FRAME(STRUCT, TYPE) \
    STRUCT r = {.f = { .type = TYPE, .size = sizeof(STRUCT) }}

+static void stop_motor(void);
+
 static void system_timer_cb(void)
 {
    CyGlobalIntDisable;
    clock++;
+    
+    static int counter300rpm = 0;
+    counter300rpm++;
+    if (counter300rpm == 200)
+        counter300rpm = 0;
+    
+    static int counter360rpm = 0;
+    counter360rpm++;
+    if (counter360rpm == 167)
+        counter360rpm = 0;
+    
+    FAKE_INDEX_GENERATOR_REG_Write(
+        ((counter300rpm == 0) ? 1 : 0)
+        | ((counter360rpm == 0) ? 2 : 0));
+    
    CyGlobalIntEnable;
 }

@@ -85,21 +106,25 @@ static void print(const char* msg, ...)
    UART_PutCRLF();
 }

-static void set_drive_flags(uint8_t flags)
+static void set_drive_flags(struct set_drive_frame* flags)
 {
-    if (current_drive_flags != flags)
+    if (current_drive_flags.drive != flags->drive)
+    {
+        stop_motor();
        homed = false;
+    }
    
-    current_drive_flags = flags;
-    DRIVESELECT_REG_Write((flags & 1) ? 2 : 1); /* select drive 1 or 0 */
-    DENSITY_REG_Write(flags >> 1); /* density bit */
+    current_drive_flags = *flags;
+    DRIVESELECT_REG_Write(flags->drive ? 2 : 1); /* select drive 1 or 0 */
+    DENSITY_REG_Write(flags->high_density); /* density bit */
+    INDEX_REG_Write(flags->index_mode);
 }

 static void start_motor(void)
 {
    if (!motor_on)
    {
-        set_drive_flags(current_drive_flags);
+        set_drive_flags(&current_drive_flags);
        MOTOR_REG_Write(1);
        CyDelay(1000);
        homed = false;
@@ -167,19 +192,19 @@ static void step(int dir)
    CyDelay(STEP_INTERVAL_TIME);
 }

-static void home(void)
+/* returns true if it looks like a drive is attached */
+static bool home(void)
 {
    for (int i=0; i<100; i++)
    {
        /* Don't keep stepping forever, because if a drive's
         * not connected bad things happen. */
        if (TRACK0_REG_Read())
-            break;
+            return true;
        step(STEP_TOWARDS0);
    }
    
-    /* Step to -1, which should be a nop, to reset the disk on disk change. */
-    step(STEP_TOWARDS0);
+    return false;
 }

 static void seek_to(int track)
@@ -236,26 +261,40 @@ static void cmd_measure_speed(struct any_frame* f)
 {
    start_motor();
    
-    index_irq = false;
-    while (!index_irq)
-        ;
    index_irq = false;
    int start_clock = clock;
+    int elapsed = 0;
    while (!index_irq)
-        ;
-    int end_clock = clock;
+    {
+        elapsed = clock - start_clock;
+        if (elapsed > 1000)
+        {
+            elapsed = 0;
+            break;
+        }
+    }
+
+    if (elapsed != 0)
+    {
+        index_irq = false;
+        start_clock = clock;
+        while (!index_irq)
+            elapsed = clock - start_clock;
+    }
    
    DECLARE_REPLY_FRAME(struct speed_frame, F_FRAME_MEASURE_SPEED_REPLY);
-    r.period_ms = end_clock - start_clock;
+    r.period_ms = elapsed;
    send_reply((struct any_frame*) &r);    
 }

-static void cmd_bulk_test(struct any_frame* f)
+static void cmd_bulk_write_test(struct any_frame* f)
 {
    uint8_t buffer[64];
    
    wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
    for (int x=0; x<64; x++)
+    {
+        CyWdtClear();
        for (int y=0; y<256; y++)
        {
            for (unsigned z=0; z<sizeof(buffer); z++)
@@ -264,11 +303,50 @@ static void cmd_bulk_test(struct any_frame* f)
            wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
            USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, buffer, sizeof(buffer));
        }
+    }
    
-    DECLARE_REPLY_FRAME(struct any_frame, F_FRAME_BULK_TEST_REPLY);
+    DECLARE_REPLY_FRAME(struct any_frame, F_FRAME_BULK_WRITE_TEST_REPLY);
    send_reply(&r);
 }

+static void cmd_bulk_read_test(struct any_frame* f)
+{
+    uint8_t buffer[64];
+    
+    bool passed = true;
+    for (int x=0; x<64; x++)
+    {
+        CyWdtClear();
+        for (int y=0; y<256; y++)
+        {
+            USBFS_EnableOutEP(FLUXENGINE_DATA_OUT_EP_NUM);
+            while (USBFS_GetEPState(FLUXENGINE_DATA_OUT_EP_NUM) != USBFS_OUT_BUFFER_FULL)
+                ;
+            USBFS_ReadOutEP(FLUXENGINE_DATA_OUT_EP_NUM, buffer, sizeof(buffer));
+            while (USBFS_GetEPState(FLUXENGINE_DATA_OUT_EP_NUM) != USBFS_OUT_BUFFER_EMPTY)
+                ;
+            
+            for (unsigned z=0; z<sizeof(buffer); z++)
+            {
+                if (buffer[z] != (uint8)(x+y+z))
+                {
+                    print("fail %d+%d+%d == %d, not %d", x, y, z, buffer[z], (uint8)(x+y+z));
+                    passed = false;
+                }
+            }
+        }
+    }
+
+    print("passed=%d", passed);
+    if (passed)
+    {
+        DECLARE_REPLY_FRAME(struct any_frame, F_FRAME_BULK_READ_TEST_REPLY);
+        send_reply(&r);
+    }
+    else
+        send_error(F_ERROR_INVALID_VALUE);
+}
+
 static void deinit_dma(void)
 {
    for (int i=0; i<BUFFER_COUNT; i++)
@@ -306,7 +384,7 @@ static void cmd_read(struct read_frame* f)
    
    {
        uint8_t i = CyEnterCriticalSection();
-        SAMPLER_FIFO_SET_LEVEL_MID;
+        SAMPLER_FIFO_SET_LEVEL_NORMAL;
        SAMPLER_FIFO_CLEAR;
        SAMPLER_FIFO_SINGLE_BUFFER_UNSET;
        CyExitCriticalSection(i);
@@ -315,15 +393,18 @@ static void cmd_read(struct read_frame* f)
    wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
    init_capture_dma();

-    /* Wait for the beginning of a rotation. */
+    /* Wait for the beginning of a rotation, if requested. */
        
-    index_irq = false;
-    while (!index_irq)
-        ;
-    index_irq = false;
+    if (f->synced)
+    {
+        index_irq = false;
+        while (!index_irq)
+            ;
+        index_irq = false;
+    }
    
    crunch_state_t cs = {};
-    cs.outputptr = usb_buffer;
+    cs.outputptr = xfer_buffer;
    cs.outputlen = BUFFER_SIZE;
    
    dma_writing_to_td = 0;
@@ -337,75 +418,100 @@ static void cmd_read(struct read_frame* f)
    /* Wait for the first DMA transfer to complete, after which we can start the
     * USB transfer. */

-    while ((dma_writing_to_td == 0) && !index_irq)
+    while (dma_writing_to_td == 0)
        ;
    dma_reading_from_td = 0;
+    bool dma_running = true;
    
    /* Start transferring. */

-    int revolutions = f->revolutions;
-    while (!dma_underrun)
+    uint32_t start_time = clock;
+    for (;;)
    {
        CyWdtClear();

-        /* Have we reached the index pulse? */
-        if (index_irq)
-        {
-            index_irq = false;
-            revolutions--;
-            if (revolutions == 0)
-                break;
-        }
+        /* If the sample session is over, stop reading but continue processing until
+         * the DMA chain is empty. */
        
-        /* Wait for the next block to be read. */
-        while (dma_reading_from_td == dma_writing_to_td)
+        if ((clock - start_time) >= f->milliseconds)
        {
-            /* On an underrun, give up immediately. */
-            if (dma_underrun)
-                goto abort;
-        }
-
-        uint8_t dma_buffer_usage = 0;
-        while (dma_buffer_usage < BUFFER_SIZE)
-        {
-            cs.inputptr = dma_buffer[dma_reading_from_td] + dma_buffer_usage;
-            cs.inputlen = BUFFER_SIZE - dma_buffer_usage;
-            crunch(&cs);
-            dma_buffer_usage += BUFFER_SIZE - cs.inputlen;
-            count++;
-            if (cs.outputlen == 0)
+            if (dma_running)
            {
-                while (USBFS_GetEPState(FLUXENGINE_DATA_IN_EP_NUM) != USBFS_IN_BUFFER_EMPTY)
-                {
-                    if (index_irq || dma_underrun)
-                        goto abort;
-                }
-
-                USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, usb_buffer, BUFFER_SIZE);
-                cs.outputptr = usb_buffer;
-                cs.outputlen = BUFFER_SIZE;
+                CyDmaChSetRequest(dma_channel, CY_DMA_CPU_TERM_CHAIN);
+                while (CyDmaChGetRequest(dma_channel))
+                    ;
+                dma_running = false;
+                dma_underrun = false;
            }
        }
-        dma_reading_from_td = NEXT_BUFFER(dma_reading_from_td);
+        
+        /* If there's an underrun event, stop immediately. */
+        
+        if (dma_underrun)
+            goto abort;
+        
+        /* If there are no more blocks to be read, check to see if we've finished. */
+        
+        if (dma_reading_from_td == dma_writing_to_td)
+        {
+            /* Also if we've run out of blocks to send. */
+            
+            if (!dma_running)
+                goto abort;
+        }
+        else
+        {
+            /* Otherwise, there's a block waiting, so attempt to send it. */
+            
+            uint8_t dma_buffer_usage = 0;
+            while (dma_buffer_usage < BUFFER_SIZE)
+            {
+                cs.inputptr = dma_buffer[dma_reading_from_td] + dma_buffer_usage;
+                cs.inputlen = BUFFER_SIZE - dma_buffer_usage;
+                crunch(&cs);
+                dma_buffer_usage += BUFFER_SIZE - cs.inputlen;
+                count++;
+                
+                /* If there is no available space in the output buffer, flush the buffer via
+                 * USB and go again. */
+                if (cs.outputlen == 0)
+                {
+                    wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
+                    memcpy(usb_buffer, xfer_buffer, FRAME_SIZE);
+                    USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, usb_buffer, BUFFER_SIZE);
+                    
+                    cs.outputptr = xfer_buffer;
+                    cs.outputlen = BUFFER_SIZE;
+                }
+            }
+            dma_reading_from_td = NEXT_BUFFER(dma_reading_from_td);
+        }
    }
 abort:;
-    CyDmaChSetRequest(dma_channel, CY_DMA_CPU_TERM_CHAIN);
-    while (CyDmaChGetRequest(dma_channel))
-        ;
+    bool saved_dma_underrun = dma_underrun;

    donecrunch(&cs);
    wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
-    if (!dma_underrun)
+    /* If there's a complete packet waiting, send it. */
+    if (cs.outputlen != BUFFER_SIZE)
    {
-        if (cs.outputlen != BUFFER_SIZE)
-            USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, usb_buffer, BUFFER_SIZE-cs.outputlen);
+        USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, usb_buffer, BUFFER_SIZE);
        wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
    }
-    if ((cs.outputlen == BUFFER_SIZE) || (cs.outputlen == 0))
+    if ((cs.outputlen != 0) && (cs.outputlen != BUFFER_SIZE))
+    {
+        /* If there's a partial packet waiting, send it; this will also terminate the transfer. */
+        USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, usb_buffer, BUFFER_SIZE-cs.outputlen);
+    }
+    else
+    {
+        /* Otherwise just terminate the transfer. */
        USBFS_LoadInEP(FLUXENGINE_DATA_IN_EP_NUM, NULL, 0);
+    }
+    wait_until_writeable(FLUXENGINE_DATA_IN_EP_NUM);
    deinit_dma();

-    if (dma_underrun)
+    if (saved_dma_underrun)
    {
        print("underrun after %d packets");
        send_error(F_ERROR_UNDERRUN);
@@ -455,7 +561,7 @@ static void cmd_write(struct write_frame* f)
    SIDE_REG_Write(f->side);
    {
        uint8_t i = CyEnterCriticalSection();        
-        REPLAY_FIFO_SET_LEVEL_NORMAL;
+        REPLAY_FIFO_SET_LEVEL_MID;
        REPLAY_FIFO_CLEAR;
        REPLAY_FIFO_SINGLE_BUFFER_UNSET;
        CyExitCriticalSection(i);
@@ -468,6 +574,7 @@ static void cmd_write(struct write_frame* f)
    int packets = f->bytes_to_write / FRAME_SIZE;
    int count_written = 0;
    int count_read = 0;
+    int packetwaiting = 0;
    dma_writing_to_td = 0;
    dma_reading_from_td = -1;
    dma_underrun = false;
@@ -479,6 +586,22 @@ static void cmd_write(struct write_frame* f)
    int old_reading_from_td = -1;
    for (;;)
    {
+        CyWdtClear();
+
+        /* Make sure that we always have a USB read in progress whenever possible. */
+        
+        if (!finished && !packetwaiting)
+        {
+            /* There is no read in progress; has data arrived in the external USB buffer? */
+            
+            if (USBFS_GetEPState(FLUXENGINE_DATA_OUT_EP_NUM) == USBFS_OUT_BUFFER_FULL)
+            {
+                /* Yes, data has arrived, so initiate the copy. */
+                
+                packetwaiting = USBFS_ReadOutEP(FLUXENGINE_DATA_OUT_EP_NUM, usb_buffer, FRAME_SIZE);
+            }
+        }
+
        /* Read data from USB into the buffers. */
        
        if (NEXT_BUFFER(dma_writing_to_td) != dma_reading_from_td)
@@ -495,26 +618,33 @@ static void cmd_write(struct write_frame* f)
                    /* There's no more data to read, so fake some. */
                    
                    for (int i=0; i<BUFFER_SIZE; i++)
-                        usb_buffer[i+0] = 0x7f;
-                    cs.inputptr = usb_buffer;
+                        xfer_buffer[i+0] = 0x7f;
+                    cs.inputptr = xfer_buffer;
                    cs.inputlen = BUFFER_SIZE;
                }
-                else
+                else if (packetwaiting)
                {
-                    while (USBFS_GetEPState(FLUXENGINE_DATA_OUT_EP_NUM) != USBFS_OUT_BUFFER_FULL)
+                    /* There's a USB read into usb_buffer in progress, so check if it's finished. */
+                    
+                    if (USBFS_GetEPState(FLUXENGINE_DATA_OUT_EP_NUM) == USBFS_OUT_BUFFER_EMPTY)
                    {
-                        if (writing && (dma_underrun || index_irq))
-                            goto abort;
+                        /* It's done, so copy out the data. */
+                        
+                        memcpy(xfer_buffer, usb_buffer, FRAME_SIZE);
+                        cs.inputptr = xfer_buffer;
+                        cs.inputlen = packetwaiting;
+
+                        count_read++;
+                        if ((packetwaiting < FRAME_SIZE) || (count_read == packets))
+                            finished = true;
+                        else
+                        {
+                            /* Wait for more USB data to show up. */
+                            
+                            packetwaiting = 0;
+                            USBFS_EnableOutEP(FLUXENGINE_DATA_OUT_EP_NUM);
+                        }
                    }
-
-                    int length = usb_read(FLUXENGINE_DATA_OUT_EP_NUM, usb_buffer);
-                    cs.inputptr = usb_buffer;
-                    cs.inputlen = length;
-                    USBFS_EnableOutEP(FLUXENGINE_DATA_OUT_EP_NUM);
-
-                    count_read++;
-                    if ((length < FRAME_SIZE) || (count_read == packets))
-                        finished = true;
                }
            }
            
@@ -533,7 +663,8 @@ static void cmd_write(struct write_frame* f)
                }
            }
            
-            /* If we have a full buffer, start writing. */
+            /* Once all the buffers are full, start writing. */
+            
            if ((dma_reading_from_td == -1) && (dma_writing_to_td == BUFFER_COUNT-1))
            {
                dma_reading_from_td = old_reading_from_td = 0;
@@ -548,7 +679,7 @@ static void cmd_write(struct write_frame* f)

                /* Wait for the index marker. While this happens, the DMA engine
                 * will prime the FIFO. */
-                
+
                index_irq = false;
                while (!index_irq)
                    ;
@@ -559,7 +690,7 @@ static void cmd_write(struct write_frame* f)
                SEQUENCER_CONTROL_Write(0); /* start writing! */
            }
        }
-        
+
        if (writing && (dma_underrun || index_irq))
            goto abort;

@@ -570,6 +701,7 @@ static void cmd_write(struct write_frame* f)
        }
    }
 abort:
+    print("done %d %d", dma_reading_from_td, dma_writing_to_td);
    SEQUENCER_DMA_FINISHED_IRQ_Disable();

    SEQUENCER_CONTROL_Write(1); /* reset */
@@ -585,7 +717,9 @@ abort:
    print("p=%d cr=%d cw=%d f=%d w=%d index=%d underrun=%d", packets, count_read, count_written, finished, writing, index_irq, dma_underrun);
    if (!finished)
    {
-        while (count_read < packets)
+        /* There's still some data to read, so just read and blackhole it ---
+         * easier than trying to terminate the connection. */
+        while (count_read != packets)
        {
            if (USBFS_GetEPState(FLUXENGINE_DATA_OUT_EP_NUM) == USBFS_OUT_BUFFER_FULL)
            {
@@ -635,7 +769,11 @@ static void cmd_erase(struct erase_frame* f)

 static void cmd_set_drive(struct set_drive_frame* f)
 {
-    set_drive_flags(f->drive_flags);
+    if (drive0_present && !drive1_present)
+        f->drive = 0;
+    if (drive1_present && !drive0_present)
+        f->drive = 1;
+    set_drive_flags(f);
    
    DECLARE_REPLY_FRAME(struct any_frame, F_FRAME_SET_DRIVE_REPLY);
    send_reply((struct any_frame*) &r);
@@ -751,8 +889,12 @@ static void handle_command(void)
            cmd_measure_speed(f);
            break;
            
-        case F_FRAME_BULK_TEST_CMD:
-            cmd_bulk_test(f);
+        case F_FRAME_BULK_WRITE_TEST_CMD:
+            cmd_bulk_write_test(f);
+            break;
+            
+        case F_FRAME_BULK_READ_TEST_CMD:
+            cmd_bulk_read_test(f);
            break;
            
        case F_FRAME_READ_CMD:
@@ -784,6 +926,21 @@ static void handle_command(void)
    }
 }

+static void detect_drives(void)
+{
+    current_drive_flags.drive = 0;
+    start_motor();
+    drive0_present = home();
+    stop_motor();
+    
+    current_drive_flags.drive = 1;
+    start_motor();
+    drive1_present = home();
+    stop_motor();
+    
+    print("drive 0: %s drive 1: %s", drive0_present ? "yes" : "no", drive1_present ? "yes" : "no");
+}
+
 int main(void)
 {
    CyGlobalIntEnable;
@@ -798,10 +955,9 @@ int main(void)
    UART_Start();
    USBFS_Start(0, USBFS_DWR_VDDD_OPERATION);
    
+    detect_drives();
    CyWdtStart(CYWDT_1024_TICKS, CYWDT_LPMODE_DISABLED);
    
-    /* UART_PutString("GO\r"); */
-
    for (;;)
    {
        CyWdtClear();
@@ -817,14 +973,14 @@ int main(void)
        {
            print("Waiting for USB...");
            while (!USBFS_GetConfiguration())
-                ;
+                CyWdtClear();
            print("USB ready");
            USBFS_EnableOutEP(FLUXENGINE_CMD_OUT_EP_NUM);
        }
        
        if (USBFS_GetEPState(FLUXENGINE_CMD_OUT_EP_NUM) == USBFS_OUT_BUFFER_FULL)
        {
-            set_drive_flags(current_drive_flags);
+            set_drive_flags(&current_drive_flags);
            handle_command();
            USBFS_EnableOutEP(FLUXENGINE_CMD_OUT_EP_NUM);
            print("idle");
--- a/11
+++ b/11
@@ -1,8 +1,13 @@
 PACKAGES = zlib sqlite3 libusb-1.0

-export CFLAGS = -Os -g --std=c++14 \
-	-ffunction-sections -fdata-sections
-export LDFLAGS = -Os
+export CFLAGS = --std=c++14 -ffunction-sections -fdata-sections
+export LDFLAGS =
+
+export COPTFLAGS = -Os
+export LDOPTFLAGS = -Os -s
+
+export CDBGFLAGS = -O0 -g
+export LDDBGFLAGS = -O0 -g

 ifeq ($(OS), Windows_NT)
 export CXX = /mingw32/bin/g++
--- a/README.md
+++ b/README.md
@@ -79,10 +79,10 @@ people who've had it work).

 | Format                                   | Read? | Write? | Notes |
 |:-----------------------------------------|:-----:|:------:|-------|
-| IBM PC compatible                        |  🦄   |        | 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)  |  🦖   |        |                                     |
+| [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](doc/disk-c64.md)     |  🦖   |        | and probably the other GCR formats  |
@@ -90,9 +90,13 @@ people who've had it work).
 | [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 |
+| [TRS-80](doc/disk-trs80.md)              |  🦖   |   🦖*  | a minor variation of the IBM scheme |
 {: .datatable }

+`*`: 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
--- a/arch/amiga/amiga.cc
+++ b/arch/amiga/amiga.cc
@@ -0,0 +1,101 @@
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "amiga.h"
+#include "bytes.h"
+#include "fmt/format.h"
+
+uint32_t amigaChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint32_t checksum = 0;
+
+    assert((bytes.size() & 3) == 0);
+    while (!br.eof())
+        checksum ^= br.read_be32();
+
+    return checksum & 0x55555555;
+}
+
+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;
+}
+
+Bytes amigaInterleave(const Bytes& input)
+{
+	Bytes output;
+	ByteWriter bw(output);
+
+	/* 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);
+		}
+	}
+
+	/* 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);
+		}
+	}
+
+	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];
+    Bytes output;
+    ByteWriter bw(output);
+
+    for (size_t i=0; i<len/2; i++)
+    {
+        uint8_t o = *odds++;
+        uint8_t e = *evens++;
+
+        /* This is the 'Interleave bits with 64-bit multiply' technique from
+         * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
+         */
+        uint16_t result =
+            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL)
+                * 0x0102040810204081ULL >> 49) & 0x5555) |
+            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL)
+                * 0x0102040810204081ULL >> 48) & 0xAAAA);
+        
+        bw.write_be16(result);
+    }
+
+    input += len;
+    return output;
+}
+
+Bytes amigaDeinterleave(const Bytes& input)
+{
+	const uint8_t* ptr = input.cbegin();
+	return amigaDeinterleave(ptr, input.size());
+}
--- a/arch/amiga/amiga.h
+++ b/arch/amiga/amiga.h
@@ -1,12 +1,17 @@
 #ifndef AMIGA_H
 #define AMIGA_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 0x21f

 class Sector;
 class Fluxmap;
+class SectorSet;

 class AmigaDecoder : public AbstractDecoder
 {
@@ -15,6 +20,24 @@ public:

    RecordType advanceToNextRecord();
    void decodeSectorRecord();
+
+	std::set<unsigned> requiredSectors(Track& track) const;
 };

+class AmigaEncoder : public AbstractEncoder
+{
+public:
+	virtual ~AmigaEncoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+};
+
+extern FlagGroup amigaEncoderFlags;
+
+extern uint32_t amigaChecksum(const Bytes& bytes);
+extern Bytes amigaInterleave(const Bytes& input);
+extern Bytes amigaDeinterleave(const uint8_t*& input, size_t len);
+extern Bytes amigaDeinterleave(const Bytes& input);
+
 #endif
--- a/arch/amiga/decoder.cc
+++ b/arch/amiga/decoder.cc
@@ -21,47 +21,6 @@
         
 static const FluxPattern SECTOR_PATTERN(48, AMIGA_SECTOR_RECORD);

-static Bytes deinterleave(const uint8_t*& input, size_t len)
-{
-    assert(!(len & 1));
-    const uint8_t* odds = &input[0];
-    const uint8_t* evens = &input[len/2];
-    Bytes output;
-    ByteWriter bw(output);
-
-    for (size_t i=0; i<len/2; i++)
-    {
-        uint8_t o = *odds++;
-        uint8_t e = *evens++;
-
-        /* This is the 'Interleave bits with 64-bit multiply' technique from
-         * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
-         */
-        uint16_t result =
-            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL)
-                * 0x0102040810204081ULL >> 49) & 0x5555) |
-            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL)
-                * 0x0102040810204081ULL >> 48) & 0xAAAA);
-        
-        bw.write_be16(result);
-    }
-
-    input += len;
-    return output;
-}
-
-static uint32_t checksum(const Bytes& bytes)
-{
-    ByteReader br(bytes);
-    uint32_t checksum = 0;
-
-    assert((bytes.size() & 3) == 0);
-    while (!br.eof())
-        checksum ^= br.read_be32();
-
-    return checksum & 0x55555555;
-}
-
 AbstractDecoder::RecordType AmigaDecoder::advanceToNextRecord()
 {
    _sector->clock = _fmr->seekToPattern(SECTOR_PATTERN);
@@ -78,22 +37,29 @@ void AmigaDecoder::decodeSectorRecord()

    const uint8_t* ptr = bytes.begin() + 3;

-    Bytes header = deinterleave(ptr, 4);
-    Bytes recoveryinfo = deinterleave(ptr, 16);
+    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 = deinterleave(ptr, 4).reader().read_be32();
-    uint32_t gotheaderchecksum = checksum(rawbytes.slice(6, 40));
+    uint32_t wantedheaderchecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
+    uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(6, 40));
    if (gotheaderchecksum != wantedheaderchecksum)
        return;

-    uint32_t wanteddatachecksum = deinterleave(ptr, 4).reader().read_be32();
-    uint32_t gotdatachecksum = checksum(rawbytes.slice(62, 1024));
+    uint32_t wanteddatachecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
+    uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(62, 1024));

    _sector->data.clear();
-    _sector->data.writer().append(deinterleave(ptr, 512)).append(recoveryinfo);
+    _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
@@ -0,0 +1,129 @@
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "amiga.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
+
+FlagGroup amigaEncoderFlags;
+
+static DoubleFlag clockRateUs(
+	{ "--clock-rate" },
+	"Encoded data clock rate (microseconds).",
+	2.00);
+
+static DoubleFlag postIndexGapMs(
+	{ "--post-index-gap" },
+	"Post-index gap before first sector header (milliseconds).",
+	0.5);
+
+static bool lastBit;
+
+static int charToInt(char c)
+{
+	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)
+{
+	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)
+{
+	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_interleaved_bytes(std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
+{
+	assert(!(bytes.size() & 3));
+	Bytes interleaved = amigaInterleave(bytes);
+	encodeMfm(bits, cursor, interleaved, lastBit);
+}
+
+static void write_interleaved_bytes(std::vector<bool>& bits, unsigned& cursor, uint32_t data)
+{
+	Bytes b(4);
+	ByteWriter bw(b);
+	bw.write_be32(data);
+	write_interleaved_bytes(bits, cursor, b);
+}
+
+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";
+
+    write_bits(bits, cursor, AMIGA_SECTOR_RECORD, 6*8);
+
+	std::vector<bool> headerBits(20*16);
+	unsigned headerCursor = 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(headerBits, headerCursor, header);
+	Bytes recoveryInfo(16);
+	if (sector->data.size() == 528)
+		recoveryInfo = sector->data.slice(512, 16);
+	write_interleaved_bytes(headerBits, headerCursor, recoveryInfo);
+
+	std::vector<bool> dataBits(512*16);
+	unsigned dataCursor = 0;
+	write_interleaved_bytes(dataBits, dataCursor, sector->data);
+
+	write_bits(bits, cursor, headerBits);
+	uint32_t headerChecksum = amigaChecksum(toBytes(headerBits));
+	write_interleaved_bytes(bits, cursor, headerChecksum);
+	uint32_t dataChecksum = amigaChecksum(toBytes(dataBits));
+	write_interleaved_bytes(bits, cursor, dataChecksum);
+	write_bits(bits, cursor, dataBits);
+}
+
+std::unique_ptr<Fluxmap> AmigaEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+	if ((physicalTrack < 0) || (physicalTrack >= AMIGA_TRACKS_PER_DISK))
+		return std::unique_ptr<Fluxmap>();
+
+	int bitsPerRevolution = 200000.0 / clockRateUs;
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;
+
+    fillBitmapTo(bits, cursor, postIndexGapMs * 1000 / clockRateUs, { 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);
+    }
+
+	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, clockRateUs*1e3);
+	return fluxmap;
+}
+
--- a/arch/brother/encoder.cc
+++ b/arch/brother/encoder.cc
@@ -154,7 +154,7 @@ std::unique_ptr<Fluxmap> BrotherEncoder::encode(
 		write_sector_data(bits, cursor, sectorData->data);
 	}

-	if (cursor > bits.size())
+	if (cursor >= bits.size())
 		Error() << "track data overrun";
 	fillBitmapTo(bits, cursor, bits.size(), { true, false });

--- a/arch/ibm/decoder.cc
+++ b/arch/ibm/decoder.cc
@@ -73,8 +73,10 @@ const FluxPattern FM_TRS80DAM2_PATTERN(16, 0xf56c);
 * 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(16, 0x4489);
+const FluxPattern MFM_PATTERN(48, 0x448944894489LL);

 const FluxMatchers ANY_RECORD_PATTERN(
    {
@@ -100,7 +102,8 @@ AbstractDecoder::RecordType IbmDecoder::advanceToNextRecord()
    if (_currentHeaderLength > 0)
        readRawBits(_currentHeaderLength*16);
    auto idbits = readRawBits(16);
-    uint8_t id = decodeFmMfm(idbits).slice(0, 1)[0];
+    const Bytes idbytes = decodeFmMfm(idbits);
+    uint8_t id = idbytes.slice(0, 1)[0];
    seek(here);
    
    switch (id)
--- a/arch/ibm/encoder.cc
+++ b/arch/ibm/encoder.cc
@@ -0,0 +1,235 @@
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "ibm.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
+#include "fmt/format.h"
+#include <ctype.h>
+
+/* IAM record separator:
+ * 0xC2 is:
+ * data:    1  1  0  0  0  0  1  0  = 0xc2
+ * mfm:     01 01 00 10 10 10 01 00 = 0x5254
+ * special: 01 01 00 10 00 10 01 00 = 0x5224
+ */
+#define MFM_IAM_SEPARATOR 0x5224
+
+/* FM IAM record:
+ * flux:   XXXX-XXX-XXXX-X- = 0xf77a
+ * clock:  X X - X - X X X  = 0xd7
+ * data:    X X X X X X - - = 0xfc
+ */
+#define FM_IAM_RECORD 0xf77a
+
+/* MFM IAM record:
+ * data:   1  1  1  1  1  1  0  0  = 0xfc
+ * flux:   01 01 01 01 01 01 00 10 = 0x5552
+ */
+#define MFM_IAM_RECORD 0x5552
+
+/* MFM record separator:
+ * 0xA1 is:
+ * data:    1  0  1  0  0  0  0  1  = 0xa1
+ * mfm:     01 00 01 00 10 10 10 01 = 0x44a9
+ * special: 01 00 01 00 10 00 10 01 = 0x4489
+ *                       ^^^^^
+ * 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
+#define MFM_RECORD_SEPARATOR_BYTE 0xa1
+
+/* MFM IDAM byte:
+ * data:    1  1  1  1  1  1  1  0  = 0xfe
+ * mfm:     01 01 01 01 01 01 01 00 = 0x5554
+ */
+
+/* MFM DAM byte:
+ * data:    1  1  1  1  1  0  1  1  = 0xfb
+ * 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;
+	}
+}
+
+void IbmEncoder::writeBytes(const Bytes& bytes)
+{
+	if (_parameters.useFm)
+		encodeFm(_bits, _cursor, bytes);
+	else
+		encodeMfm(_bits, _cursor, bytes, _lastBit);
+}
+
+void IbmEncoder::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];
+}
+
+std::unique_ptr<Fluxmap> IbmEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+	double clockRateUs = 1e3 / _parameters.clockRateKhz;
+	if (!_parameters.useFm)
+		clockRateUs /= 2.0;
+	int bitsPerRevolution = (_parameters.trackLengthMs * 1000.0) / clockRateUs;
+	_bits.resize(bitsPerRevolution);
+	_cursor = 0;
+
+	uint8_t idamUnencoded = decodeUint16(_parameters.idamByte);
+	uint8_t damUnencoded = decodeUint16(_parameters.damByte);
+
+	uint8_t sectorSize = 0;
+	{
+		int s = _parameters.sectorSize >> 7;
+		while (s > 1)
+		{
+			s >>= 1;
+			sectorSize += 1;
+		}
+	}
+
+	uint8_t gapFill = _parameters.useFm ? 0x00 : 0x4e;
+
+	writeBytes(_parameters.gap0, gapFill);
+	if (_parameters.emitIam)
+	{
+		writeBytes(_parameters.useFm ? 6 : 12, 0x00);
+		if (!_parameters.useFm)
+		{
+			for (int i=0; i<3; i++)
+				writeRawBits(MFM_IAM_SEPARATOR, 16);
+		}
+		writeRawBits(_parameters.useFm ? FM_IAM_RECORD : MFM_IAM_RECORD, 16);
+		writeBytes(_parameters.gap1, gapFill);
+	}
+
+	bool first = true;
+	for (char sectorChar : _parameters.sectorSkew)
+	{
+		int sectorId = charToInt(sectorChar);
+		if (!first)
+			writeBytes(_parameters.gap3, gapFill);
+		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(_parameters.useFm ? 6 : 12, 0x00);
+			if (!_parameters.useFm)
+			{
+				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 + _parameters.startSectorId);
+			bw.write_8(sectorSize);
+			uint16_t crc = crc16(CCITT_POLY, header);
+			bw.write_be16(crc);
+
+			int conventionalHeaderStart = 0;
+			if (!_parameters.useFm)
+			{
+				for (int i=0; i<3; i++)
+					writeRawBits(MFM_RECORD_SEPARATOR, 16);
+				conventionalHeaderStart += 3;
+
+			}
+			writeRawBits(_parameters.idamByte, 16);
+			conventionalHeaderStart += 1;
+
+			writeBytes(header.slice(conventionalHeaderStart));
+		}
+
+		writeBytes(_parameters.gap2, gapFill);
+
+		{
+			Bytes data;
+			ByteWriter bw(data);
+
+			writeBytes(_parameters.useFm ? 6 : 12, 0x00);
+			if (!_parameters.useFm)
+			{
+				for (int i=0; i<3; i++)
+					bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
+			}
+			bw.write_8(damUnencoded);
+
+			Bytes truncatedData = sectorData->data.slice(0, _parameters.sectorSize);
+			bw += truncatedData;
+			uint16_t crc = crc16(CCITT_POLY, data);
+			bw.write_be16(crc);
+
+			int conventionalHeaderStart = 0;
+			if (!_parameters.useFm)
+			{
+				for (int i=0; i<3; i++)
+					writeRawBits(MFM_RECORD_SEPARATOR, 16);
+				conventionalHeaderStart += 3;
+
+			}
+			writeRawBits(_parameters.damByte, 16);
+			conventionalHeaderStart += 1;
+
+			writeBytes(data.slice(conventionalHeaderStart));
+		}
+    }
+
+	if (_cursor >= _bits.size())
+		Error() << "track data overrun";
+	while (_cursor < _bits.size())
+		writeBytes(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
@@ -2,6 +2,7 @@
 #define IBM_H

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

 /* IBM format (i.e. ordinary PC floppies). */

@@ -31,68 +32,68 @@ struct IbmIdam
 class IbmDecoder : public AbstractDecoder
 {
 public:
-    IbmDecoder(unsigned sectorBase, bool ignoreSideByte=false):
+    IbmDecoder(unsigned sectorBase, bool ignoreSideByte=false,
+			const std::set<unsigned> requiredSectors=std::set<unsigned>()):
        _sectorBase(sectorBase),
-        _ignoreSideByte(ignoreSideByte)
+        _ignoreSideByte(ignoreSideByte),
+		_requiredSectors(requiredSectors)
    {}

    RecordType advanceToNextRecord();
    void decodeSectorRecord();
    void decodeDataRecord();

+	std::set<unsigned> requiredSectors(Track& track) const
+	{ return _requiredSectors; }
+
 private:
    unsigned _sectorBase;
    bool _ignoreSideByte;
+	std::set<unsigned> _requiredSectors;
    unsigned _currentSectorSize;
    unsigned _currentHeaderLength;
 };

-#if 0
-class AbstractIbmDecoder : public AbstractSoftSectorDecoder
+struct IbmParameters
+{
+	int trackLengthMs;
+	int sectorSize;
+	bool emitIam;
+	int startSectorId;
+	int clockRateKhz;
+	bool useFm;
+	uint16_t idamByte;
+	uint16_t damByte;
+	int gap0;
+	int gap1;
+	int gap2;
+	int gap3;
+	std::string sectorSkew;
+};
+
+class IbmEncoder : public AbstractEncoder
 {
 public:
-    AbstractIbmDecoder(unsigned sectorIdBase):
-        _sectorIdBase(sectorIdBase)
-    {}
-    virtual ~AbstractIbmDecoder() {}
+	IbmEncoder(const IbmParameters& parameters):
+		_parameters(parameters)
+	{}

-    SectorVector decodeToSectors(const RawRecordVector& rawRecords, unsigned physicalTrack, unsigned physicalSide);
+	virtual ~IbmEncoder() {}

-protected:
-    virtual int skipHeaderBytes() const = 0;
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);

 private:
-    unsigned _sectorIdBase;
+	void writeRawBits(uint32_t data, int width);
+	void writeBytes(const Bytes& bytes);
+	void writeBytes(int count, uint8_t value);
+	void writeSync();
+	
+private:
+	IbmParameters _parameters;
+	std::vector<bool> _bits;
+	unsigned _cursor;
+	bool _lastBit;
 };

-class IbmFmDecoder : public AbstractIbmDecoder
-{
-public:
-    IbmFmDecoder(unsigned sectorIdBase):
-        AbstractIbmDecoder(sectorIdBase)
-    {}
-
-    int recordMatcher(uint64_t fifo) const;
-
-protected:
-    int skipHeaderBytes() const
-    { return 0; }
-};
-
-class IbmMfmDecoder : public AbstractIbmDecoder
-{
-public:
-    IbmMfmDecoder(unsigned sectorIdBase):
-        AbstractIbmDecoder(sectorIdBase)
-    {}
-
-    nanoseconds_t guessClock(Fluxmap& fluxmap) const;
-    int recordMatcher(uint64_t fifo) const;
-
-protected:
-    int skipHeaderBytes() const
-    { return 3; }
-};
-#endif
-
 #endif
--- a/arch/macintosh/decoder.cc
+++ b/arch/macintosh/decoder.cc
@@ -184,3 +184,25 @@ void MacintoshDecoder::decodeDataRecord()
    _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/macintosh.h
+++ b/arch/macintosh/macintosh.h
@@ -18,6 +18,8 @@ public:
    RecordType advanceToNextRecord();
    void decodeSectorRecord();
    void decodeDataRecord();
+
+	std::set<unsigned> requiredSectors(Track& track) const;
 };

 #endif
--- a/doc/building.md
+++ b/doc/building.md
@@ -25,6 +25,8 @@ This is the physical stuff you'll need.
    connector](https://eu.mouser.com/ProductDetail/Amphenol-FCI/86130342114345E1LF?qs=%2Fha2pyFadug%252BpMTyxmFhglPPVKuWXYuFpPNgq%252BsrzhDnXxo8B28k7UCGc7F%2FXjsi)
    (or one of the other myriad compatible connectors; there's a billion).

+  - A floppy drive cable, preferably one with two connectors and a twist.
+
  - A suitable power supply. 3.5" floppy drives use 5V at about an amp
    (usually less) --- sadly, too much to power from USB. 5.25" floppy drives
    also require 12V. An old but decent quality PC power supply is ideal, as
@@ -48,7 +50,7 @@ All you need to do is attach your chosen connector to the board. You'll need
 to make sure that pin 2 on the cable is connected to pin 2.7 on the board,
 and pin 34 to pin 1.7 on the board (and of course all the ones in between).
 Apart from grounding the board (see below), this is literally all there is to
-it.
+it. The actual pinout is described in detail below.

 The pads are small, but soldering them isn't too bad with a needle-nosed
 soldering iron tip.
@@ -173,6 +175,7 @@ pattern. Press and hold the little button near the light for five seconds
 until the light stays solidly on. Now you should be able to acquire
 the port and proceed normally.

+
 ## Building the client

 The client software is where the intelligence, such as it is, is. It's pretty
@@ -181,12 +184,12 @@ well, although on Windows it'll need MSYS2 and mingw32. You'll need to
 install some support packages.

  - For Linux (this is Ubuntu, but this should apply to Debian too):
-  `ninja-build`, `libusb-1.0-0-dev`, `libsqlite3-dev`.
+	`ninja-build`, `libusb-1.0-0-dev`, `libsqlite3-dev`.
  - For OSX with Homebrew: `ninja`, `libusb`, `pkg-config`, `sqlite`.
  - For Windows with MSYS2: `make`, `ninja`, `mingw-w64-i686-libusb`,
-  `mingw-w64-i686-sqlite3`, `mingw-w64-i686-zlib`, `mingw-w64-i686-gcc`.
+	`mingw-w64-i686-sqlite3`, `mingw-w64-i686-zlib`, `mingw-w64-i686-gcc`.

-These lists are not necessarily exhaustive --- plaese [get in
+These lists are not necessarily exhaustive --- please [get in
 touch](https://github.com/davidgiven/fluxengine/issues/new) if I've missed
 anything.

@@ -197,11 +200,176 @@ dependencies and you should be able to put it anywhere.
 If it doesn't build, please [get in
 touch](https://github.com/davidgiven/fluxengine/issues/new).

+
+## Connecting it up
+
+You should now have a working board, so it's time to test it.
+
+  1. Plug the motherboard end of your floppy disk cable into the FluxEngine.
+     
+     The **red stripe goes on the right**. The **lower set of
+     holes connect to the board**. See the pinout below.
+
+     If you're using header pins, the upper row of holes in the connector
+     should overhang the edge of the board. If you're using a floppy drive
+     motherboard connector, you're golden, of course (unless you have one of
+     those annoying unkeyed cables, or have accidentally soldered the
+     connector on in the wrong place --- don't laugh, I've done it.)
+
+  2. Plug the drive end of your floppy disk cable into the drive (or drives).
+
+     Floppy disk cables typically have [two pairs of floppy disk drive
+     connectors with a twist between
+     them](http://www.nullmodem.com/Floppy.htm). (Each pair has one connector
+     for a 3.5" drive and a different one for a 5.25" drive.) (Some cables
+     are cheap and just have the 3.5" connectors. Some are _very_ cheap and
+     have a single 3.5" connector, after the twist.)
+     
+     If you have **two** drives, plug them into both connectors. FluxEngine,
+     sadly, non-standard disk numbering (there are reasons). Drive 0 is the
+     one nearest the motherboard; that is, before the twist. Drive 1 is the
+     one at the end of the cable; that is, after the twist. Drive 0 is the
+     default. You can tell the client to select drive 1 by using `-s :d=1`.
+
+     If you have **one** drive, you may plug it into _either_ connector.
+     FluxEngine will autodetect it and treat it as drive 0. However, you'll
+     get the most reliable electrical signal if you plug it in at the end of
+     the cable.
+
+     **A note on termination:** some 5.25" drives require jumper configuration
+     to tell them whether they're at the end of the cable or in the middle of
+     the cable. 3.5" drives don't, and my 5.25" drives don't, so I can't
+     advise there. Consult your drive datasheet for details.
+
+  3. **Important.** Make sure that no disk you care about is in the drive.
+	 (Because if your wiring is wrong and a disk is inserted, you'll corrupt
+	 it.)
+
+  4. Connect the floppy drive to power. Nothing should happen. If you've
+	 connected something in backwards, you'll see the drive light up, the motor
+	 start, and if you didn't take the disk out, one track has just been wiped.
+	 If this happens, check your wiring.
+
+  5. Strip off the little piece of protective plastic on the USB socket on the
+	 board --- the little socket at the end, not the big programmer plug.
+
+  6. Connect the FluxEngine to your PC via USB.
+
+  7. Insert a scratch disk and do `fluxengine rpm` from the shell. The motor
+     should work and it'll tell you that the disk is spinning at about 300
+     rpm for a 3.5" disk, or 360 rpm for a 5.25" disk. If it doesn't, please
+     [get in touch](https://github.com/davidgiven/fluxengine/issues/new).
+
+  8. Do `fluxengine test bandwidth` from the shell. It'll measure your USB
+	 bandwidth. Ideally you should be getting above 900kB/s in both directions.
+	 FluxEngine needs about 400kB/s for a DD disk and about 850kB/s for a HD
+	 disk, so if you're getting less than this, try a different USB port.
+
+  9. Insert a standard PC formatted floppy disk into the drive (probably a good
+     idea to remove the old disk first). Then do `fluxengine read ibm`. It
+     should read the disk, emitting copious diagnostics, and spit out an
+     `ibm.img` file containing the decoded disk image (either 1440kB or 720kB
+     depending).
+
+ 10. Profit!
+
+## Technical details
+
+The board pinout and the way it's connected to the floppy bus is described
+below.
+
+```ditaa
+:-E -s 0.75
+                 +-----+
+                 |||||||
+            +----+-----+----+
+            +cAAA           +
+            +  Debug board  +
+            +----+-----+----+
+            + GND|cDDD | VDD+  
+            +----+     +----+
+INDEX300 ---+ 3.0|     | GND+--------------------------+
+            +----+     +----+                 +--+--+  |
+INDEX360 ---+ 3.1|     | 1.7+------ DISKCHG --+34+33+--+
+            +----+     +----+                 +--+--+
+            + 3.2|     | 1.6+------- SIDE1 ---+32+31+
+            +----+     +----+                 +--+--+
+            + 3.3|     | 1.5+------- RDATA ---+30+29+
+            +----+     +----+                 +--+--+
+            + 3.4|     | 1.4+-------- WPT ----+28+27+
+            +----+     +----+                 +--+--+
+            + 3.5|     | 1.3+------- TRK00 ---+26+25+
+            +----+     +----+                 +--+--+
+            + 3.6|     | 1.2+------- WGATE ---+24+23+
+            +----+     +----+                 +--+--+
+            + 3.7|     | 1.1+------- WDATA ---+22+21+
+            +----+     +----+                 +--+--+
+            +15.0|     | 1.0+------- STEP ----+20+19+
+            +----+     +----+                 +--+--+
+            +15.1|     |12.0+-------- DIR ----+18+17+
+            +----+     +----+                 +--+--+
+            +15.2|     |12.1+------- MOTEB ---+16+15+
+            +----+     +----+                 +--+--+
+            +15.3|     |12.2+------- DRVSA ---+14+13+
+            +----+     +----+                 +--+--+
+            +15.4|     |12.3+------- DRVSB ---+12+11+
+            +----+     +----+                 +--+--+
+            +15.5|     |12.4+------- MOTEA ---+10+9 +
+            +----+     +----+                 +--+--+
+            + 0.0|     |12.5+------- INDEX ---+8 +7 +
+            +----+     +----+                 +--+--+
+            + 0.1|     |12.6+-------- n/c ----+6 +5 +
+            +----+     +----+                 +--+--+
+            + 0.2|     |12.7+- TX --- n/c ----+4 +3 +
+            +----+     +----+                 +--+--+
+            + 0.3|     | 2.7+------- REDWC ---+2 +1 +
+            +----+     +----+                 +--+--+
+            + 0.4|     | 2.6+  
+            +----+     +----+                FDD socket
+            + 0.5|     | 2.5+  
+            +----+     +----+
+            + 0.6|     | 2.4+    TX: debug UART from board
+            +----+     +----+
+            + 0.7|     | 2.3+
+            +----+     +----+
+            + RST|     | 2.2+  
+            +----+     +----+
+            + GND|     | 2.1+  
+            +----+ USB +----+
+            + VDD+-----+ 2.0+  
+            +----+-----+----+
+               PSoC5 board
+```
+
+Notes:
+
+  - `TX` is the debug UART port. It's on pin 12.7 because the board routes it
+  to the USB serial port on the programmer, so you can get debug information
+  from the FluxEngine by just plugging the programming end into a USB port
+  and using a serial terminal at 115200 baud. If you solder a floppy drive
+  connector on, then it'll end up connected to pin 4 of the floppy drive bus,
+  which is usually not connected. It's possible that some floppy drives do,
+  in fact, use this pin. You may wish to remove pin 4 from the floppy drive
+  socket before attaching it to the FluxEngine to make sure that this pin is
+  not connected; however, so far I have not found any drives for which this
+  is necessary. If you do find one, _please_ [get in
+  touch](https://github.com/davidgiven/fluxengine/issues/new) so I can
+  document it.
+
+  - The `GND` pin only really needs to be connected to one of the floppy bus
+  ground pins; pin 33 is the closest. For extra safety, you can bridge all
+  the odd numbered pins together and ground them all if you like.
+
+  - `INDEX300` and `INDEX360` are optional output pins which generate fake
+  timing pulses for 300 and 360 RPM drives. These are useful for certain
+  rather exotic things. See the section on flippy disks [in the FAQ](faq.md)
+  for more details; you can normally ignore these.
+
 ## Next steps

-The board's now assembled and programmed. Plug it into your drive, strip the
-plastic off the little USB connector and plug that into your computer, and
-you're ready to start using it.
+You should now be ready to go. You'll want to read [the client
+documentation](using.md) for information about how to actually do interesting
+things.

 I _do_ make updates to the firmware whenever necessary, so you may need to
 reprogram it at intervals; you may want to take this into account if you
--- a/doc/disk-amiga.md
+++ b/doc/disk-amiga.md
@@ -10,7 +10,7 @@ Bizarrely, the data in each sector is stored with all the odd bits first, and
 then all the even bits. This is tied into the checksum algorithm, which is
 distinctly subpar and not particularly good at detecting errors.

-Reading discs
+Reading disks
 -------------

 Just do:
@@ -34,6 +34,28 @@ You will end up with a 929280 byte long image which you probably _can't_ use
 in an emulator; each sector will contain the 512 bytes of user payload
 followed by the 16 bytes of metadata.

+Writing disks
+-------------
+
+Just do:
+
+```
+fluxengine write amiga -i amiga.adf
+```
+
+This will rake a normal 901120 byte long ADF file and write it to a DD disk.
+Note that writing to an HD disk will probably not work (this will depend on
+your drive and disk and potential FluxEngine bugs I'm still working on ---
+please [get in touch](https://github.com/davidgiven/fluxengine/issues/new) if
+you have any insight here).
+
+If you want to write the metadata as well, specify a 528 byte sector size for
+the output image and supply a 929280 byte long file as described above.
+
+```
+fluxengine write amiga -i amiga.adf:b=528
+```
+
 Useful references
 -----------------

--- a/doc/disk-brother.md
+++ b/doc/disk-brother.md
@@ -14,10 +14,12 @@ Apparently about 20% of Brother word processors have alignment issues which
 means that the disks can't be read by FluxEngine (because the tracks on the
 disk don't line up with the position of the head in a PC drive). The word
 processors themselves solved this by microstepping until they found where the
-real track is, but normal PC drives aren't capable of doing this.
-Particularly with the 120kB disks, you might want to fiddle with the start
-track (e.g. `:t=0-79x2`) to get a clean read. Keep an eye on the bad sector
-map that's dumped at the end of a read.
+real track is, but normal PC drives aren't capable of doing this.  Particularly
+with the 120kB disks, you might want to fiddle with the start track (e.g.
+`:t=0-79x2`) to get a clean read. Keep an eye on the bad sector map that's
+dumped at the end of a read. My word processor likes to put logical track 0 on
+physical track 3, which means that logical track 77 is on physical track 80;
+luckily my PC drive can access track 80.

 Using FluxEngine to *write* disks isn't a problem, so the
 simplest solution is to use FluxEngine to create a new disk, with the tracks
@@ -30,7 +32,7 @@ If you find one of these misaligned disks then *please* [get in
 touch](https://github.com/davidgiven/fluxengine/issues/new); I want to
 investigate.

-Reading discs
+Reading disks
 -------------

 Just do:
@@ -41,7 +43,7 @@ fluxengine read brother

 You should end up with a `brother.img` which is 239616 bytes long.

-Writing discs
+Writing disks
 -------------

 Just do:
@@ -53,6 +55,27 @@ fluxengine write brother
 ...and it'll write a `brother.img` file which is 239616 bytes long to the
 disk. (Use `-i` to specify a different input filename.)

+Dealing with misaligned disks
+-----------------------------
+
+While FluxEngine can't read misaligned disks directly, Brother word processors
+_can_. If you have access to a compatible word processor, there's a fairly
+simple workaround to allow you to extract the data:
+
+  1. Format a disk using FluxEngine (by simply writing a blank filesystem image
+	 to a disk). This will have the correct alignment to work on a PC drive.
+
+  2. Use a word processor to copy the misaligned disk to the newly formatted
+	 disk. The machine will happily adjust itself to both sets of alignments.
+
+  3. Use FluxEngine to read the data off the correctly aligned disk.
+
+I realise this is rather unsatisfactory, as the Brother hardware is becoming
+rarer and they cope rather badly with damaged disks, but this is a limitation
+of the hardware of normal PC drives. (It _is_ possible to deliberately misalign
+a drive to make it match up with a bad disk, but this is for experts only --- I
+wouldn't dare.)
+
 Low level format
 ----------------

@@ -60,14 +83,6 @@ The drive is a single-sided 3.5" drive spinning at not 300 rpm (I don't know
 the precise speed yet but FluxEngine doesn't care). The 240kB disks have 78
 tracks and the 120kB disks have 39.

-The Brother drive alignment is kinda variable; when you put the disk in the
-drive it seeks all the way to physical track 0 and then starts searching for
-something which looks like data. My machine likes to put logical track 0 on
-physical track 3. FluxEngine puts logical track 0 on physical track 0 for
-simplicity, which works fine (at least on my machine). If this doesn't work
-for you, [get in touch](https://github.com/davidgiven/fluxengine/issues/new);
-there are potential workarounds.
-
 Each track has 12 256-byte sectors. The drive ignores the index hole so they're
 lined up all anyhow. As FluxEngine can only read from index to index, it
 actually reads two complete revolutions and reassembles the sectors from that.
@@ -138,7 +153,8 @@ mcopy -i brother.img ::brother.doc linux.doc
 ```

 The word processor checks the media byte, unfortunately, so you'll need to
-change it back to 0x58 before writing an image to disk.
+change it back to 0x58 before writing an image to disk. Just run
+`brother240tool` on the image again and it will flip it back.

 The file format is not WP-1, and currently remains completely unknown,
 although it's probably related. If anyone knows anything about this, please
--- a/doc/disk-ibm.md
+++ b/doc/disk-ibm.md
@@ -0,0 +1,152 @@
+Disk: Generic IBM
+=================
+
+IBM scheme disks are _the_ most common disk format, ever. They're used by a
+huge variety of different systems, and they come in a huge variety of different
+forms, but they're all fundamentally the same: either FM or MFM, either single
+or double sided, with distinct sector header and data records and no sector
+metadata. Systems which use IBM scheme disks include but are not limited to:
+
+  - IBM PCs (naturally)
+  - Atari ST
+  - late era Apple machines
+  - Acorn machines
+  - the TRS-80
+  - late era Commodore machines (the 1571 and so on)
+  - most CP/M machines
+  - etc
+
+FluxEngine supports reading these. However, some variants are more peculiar
+than others, and as a result there are specific decoders which set the defaults
+correctly for certain formats (for example: on PC disks the sector numbers
+start from 1, but on [Acorn](disk-acorndfs.md) disks they start from 0). The
+IBM decoder described here is the generic one, and is suited for 'conventional'
+PC disks. While you can read all the variant formats with it if you use the
+right set of arguments, it's easier to use the specific decoder.
+
+The generic decoder is mostly self-configuring, and will detect the format of
+your disk for you.
+
+
+Reading disks
+-------------
+
+Just do:
+
+    fluxengine read ibm
+
+...and you'll end up with an `ibm.img` file. This should work on most PC disks
+(including FM 360kB disks, 3.5" 1440kB disks, 5.25" 1200kB disks, etc.) The size
+of the disk image will vary depending on the format.
+
+Configuration options you'll want include:
+
+  - `--ibm-sector-id-base=N`: specifies the ID of the first sector; this defaults
+	to 1. Some formats (like the Acorn ones) start at 0. This can't be
+	autodetected because FluxEngine can't distinguish between a disk which
+	starts at sector 1 and a disk which starts at sector 0 but all the sector
+	0s are missing.
+
+  - `--ibm-ignore-side-byte=true|false`: each sector header describes the location of the
+	sector: sector ID, track and side. Some formats use the wrong side ID, so
+	the sectors on side 1 are labelled as belonging to side 0. This causes
+	FluxEngine to see duplicate sectors (as it can't distinguish between the
+	two sides). This option tells FluxEngine to ignore the side byte completely
+	and use the physical side instead.
+
+  - `--ibm-required-sectors=range`: if you know how many sectors to expect per
+	track, you can improve reads by telling FluxEngine what to expect here. If
+	a track is read and a sector on this list is _not_ present, then FluxEngine
+	assumes the read failed and will retry. This avoids the situation where
+	FluxEngine can't tell the difference between a sector missing because it's
+	bad or a sector missing because it was never written in the first place. If
+	sectors are seen outside the range here, it will still be read. You can use
+	the same syntax as for track specifiers: e.g. `0-9`, `0,1,2,3`, etc.
+
+
+Writing disks
+-------------
+
+FluxEngine can also write IBM scheme disks. Unfortunately the format is
+incredibly flexible and you need to specify every single parameter, which
+makes things slightly awkward.
+
+The syntax is:
+
+    fluxengine write ibm -i input.img <options>
+
+The format of `input.img` will vary depending on the kind of disk you're
+writing, which is configured by the options. There are some presets, which
+you will almost certainly want to use if possible:
+
+  - `--ibm-preset-720`: a standard 720kB DS DD 3.5" disk, with 80 cylinders,
+  2 sides, and 9 sectors per track.
+  - `--ibm-preset-1440`: a standard 1440kB DS HD 3.5" disk, with 80
+  cylinders, 2 sides, and 18 sectors per track.
+
+These options simply preset the following, lower-level options. Note that
+options are processed left to right, so it's possible to use a preset and
+then change some settings. To see the values for a preset, simply append
+`--help`.
+
+  - `--ibm-track-length-ms=N`: one disk rotation, in milliseconds. This is used
+  to determine whether all the data will fit on a track or not. `fluxengine
+  rpm` will tell you this; it'll be 200 for a normal 3.5" drive and 166 for a
+  normal 5.25" drive.
+  - `--ibm-sector-size=N`: the size of a sector, in bytes. Must be a power of
+  two.
+  - `--ibm-emit-iam=true|false`: whether to emit the IAM record at the top of
+  the track. The standard format requires it, but it's ignored by absolutely
+  everyone and you can fit a bit more data on the disk without it.
+  - `--ibm-start-sector-id=N`: the sector ID of the first sector. Normally 1,
+  except for non-standard formats like Acorn's, which use 0.
+  - `--ibm-use-fm=true|false`: uses FM rather than MFM.
+  - `--ibm-idam-byte=N`: the sixteen-bit raw bit pattern used for the IDAM ID
+  byte. Big-endian, clock bit first.
+  - `--ibm-dam-byte-N`: the sixteen-bit raw bit pattern used for the DAM ID
+  byte. Big-endian, clock bit first.
+  - `--ibm-gap0-bytes=N`: the size of gap 0 in bytes (between the start of
+  the track and the IAM record).
+  - `--ibm-gap1-bytes=N`: the size of gap 1 in bytes (between the IAM record
+  and the first sector record).
+  - `--ibm-gap2-bytes=N`: the size of gap 2 in bytes (between each sector
+  record and the data record).
+  - `--ibm-gap3-bytes=N`: the size of gap 3 in bytes (between the data record
+  and the next sector record).
+  - `--ibm-sector-skew=0123...`: a string representing the order in which to
+  write sectors: each character represents on sector, with `0` being the
+  first (always, regardless of `--ibm-start-sector-id` above). Sectors 10 and
+  above are represented as latters from `A` up.
+
+Mixed-format disks
+------------------
+
+Some disks, usually those belonging to early CP/M machines, have more than one
+format on the disk at once. Typically, the first few tracks will be low-density
+FM encoded and will be read by the machine's ROM; those tracks contain new
+floppy drive handling code capable of coping with MFM data, and so the rest of
+the disk will use that, allowing them to store more data.
+
+FluxEngine copes with these fine, but the disk images are a bit weird. If track
+0 is FM and contains five sectors, but track 1 is MFM with nine sectors (MFM is
+more efficient and the sectors are physically smaller, allowing you to get more
+on), then the resulting image will have nine sectors per track... but track 0
+will only contain data in the first five.
+
+This is typically what you want as it makes locating the sectors in the image
+easier, but emulators will typically require a different format. Please [get
+in touch](https://github.com/davidgiven/fluxengine/issues/new) if you have
+specific requirements (nothing's come up yet). Alternatively, you can tell
+FluxEngine to write a [`.ldbs`
+file](http://www.seasip.info/Unix/LibDsk/ldbs.html) and then use
+[libdsk](http://www.seasip.info/Unix/LibDsk/) to convert it to something
+useful.
+
+One easy option when reading these is to simply read the two sections of the
+disk into two different image files.
+
+FluxEngine can write these too, but in two different passes with different
+options. It's possible to assemble a flux file by judicious use of `-D
+something.flux --merge`, which can then be written in a single pass with
+`fluxengine writeflux`, but it's usually not worth the bother: just write the
+boot tracks, then write the data tracks, possibly with a script for automation.
--- a/doc/faq.md
+++ b/doc/faq.md
@@ -84,6 +84,11 @@ contributed](Index_sensor_mod_FDD_1.1.pdf) on how to do this. I've never done
 it myself; if you try this and it works/doesn't work, as always, [get in
 touch](https://github.com/davidgiven/fluxengine/issues/new).

+Another option is to fake the index signal to the drive completely. The
+FluxEngine emits suitable pulses for a 300RPM drive on pin 3[0] and the
+equivalent pulses for a 360RPM drive on pin 3[1]. Disclaimer: I have never used
+these.
+
 **Q.** Is this like Supercard Pro / KryoFlux / Catweasel / DiskFerret? Do you
 *support KryoFlux
 stream files?
--- a/doc/technical.md
+++ b/doc/technical.md
@@ -59,53 +59,42 @@ Some useful and/or interesting numbers:

 ## Why don't I use an Arduino / STM32 / ESP32 / Raspberry Pi / etc?

-I've got a _lot_ of questions on this, and multiple Github issues of people
+-I've got a _lot_ of questions on this, and multiple Github issues of people
 debating it. It's complicated, but it's essentially a tradeoff between speed
-and complexity.
+and complexity.-

-FluxEngine's read process involves generating a lot of data using a fairly
-brute force sampling approach --- about 150kB per disk revolution, and
-sometimes it needs to record multiple revolutions. Most microcontrollers
-don't have enough RAM to buffer this, so instead I have to stream it over USB
-back to the host PC in real time. The disk won't wait, so I need to stream data faster
-than the disk is producing it: the total is about 800kB/s.
+**Update as of 2020-01-08:**

-Handling USB is pretty CPU-hungry, so my candidate microntroller has to be
-able to cope with the ruinously strict real-time requirements of the
-sampler's 12MHz clock as well as keeping up with 13,000 USB interrupts a
-second (one for each 64-byte frame) in order to transfer the data.
+Right. Well.

-The Atmels and STM32s I found were perfectly capable of doing the real-time
-sampling, using hand-tool assembly, but I very much doubt whether they could
-do the USB streaming as well (although I want to move away from the Cypress
-onto something less proprietary and easier to source, so I'd like to be
-proven wrong here).
+This section used to have a long explanation as to why these other platforms
+were unsuitable --- essentially, they're generally missing out on either the
+realtimeness to sample the data correctly (Raspberry Pi) or enough CPU to
+stream the data over USB while also sampling it (Arduino).

-The Raspberry Pi easily has enough processing power and memory, but it's also
-got terrible GPIO pin read performance --- [about
-1kHz](https://raspberrypi.stackexchange.com/questions/9646/how-fast-is-gpiodma-multi-i2s-input/10197#10197).
-That's a long way from the 12MHz I need.
+This is correct, but it turns out that the STM32 has some built-in features
+which support the FluxEngine's use case almost exactly: you can configure the
+DMA engine to sample the interval between pulses and write them directly into
+memory, and you can configure the PWM engine the read samples from memory and
+use them to time pulses to the output. There's a bit less functionality, so you
+can't do things like measure the signal voltages, and they're less convenient
+as you need an adapter cable or board, but this will allow you to replicate the
+FluxEngine hardware on a $2 Blue Pill.

-The PSoC5LP part I'm using has enough CPU to handle the USB side of things,
-and it _also_ has a whole set of FPGA-like soft programmable features,
-including 24 mini-ALU systems that are ideally suited to exactly this kind of
-sampling. I can read the disk and generate the byte stream describing the
-flux pattern entirely in 'hardware', without involving the main CPU at all.
-This is then DMAed directly into a set of ring buffers read for the USB
-system to pick up and relay back to the PC. It's incredibly simple and works
-well. (The same applies to writing flux back onto the disk.)
+I am _not_ planning on replacing the PSoC5 with a Blue Pill, because someone
+already has: [the GreaseWeazle](https://github.com/keirf/Greaseweazle/wiki) is
+a completely open source firmware package which will read and write Supercard
+Pro files via a standard Blue Pill. The GreaseWeazle's USB protocol is
+different from the FluxEngine's so they're not directly interchangeable. You
+can, however, read a Supercard Pro file with a GreaseWeazle and then use the
+FluxEngine client to decode it. It should work the other way around, too, but
+FluxEngine's SCP export [is curently
+broken](https://github.com/davidgiven/fluxengine/issues/134).

-The development board I'm using, the
-[CY8CKIT-059](https://www.cypress.com/documentation/development-kitsboards/cy8ckit-059-psoc-5lp-prototyping-kit-onboard-programmer-and),
-also has another big advantage: it's the right shape. It's got 17 holes in a
-row connected to GPIO pins, and it's a native 5V part, which means I can just
-connect a floppy drive connector directly to the board without needing to
-build any hardware. No adapter board, no level shifting, no special cable,
-nothing. This makes the FluxEngine hardware incredibly easy to assemble,
-which therefore means cheap.
+I _am_ considering adding direct support for the GreaseWeazle to the FluxEngine
+client, which will let you just plug one in and make it go as a direct
+replacement to the FluxEngine hardware.

-Speaking of which, the CY8CKIT-059 is $10. (Before shipping, which is
-admittedly expensive.)

 ### Some useful links

--- a/doc/using.md
+++ b/doc/using.md
@@ -1,68 +1,8 @@
 Using a FluxEngine
 ==================

-So you've [built the hardware](building.md)! What now?
-
-## Connecting it up
-
-In order to do anything useful, you have to plug it in to a floppy disk drive (or two).
-
-  1. Plug the motherboard end of your floppy disk cable into the FluxEngine.
-     
-     The **red stripe goes on the right**. The **lower set of
-     holes connect to the board**. (Pin 2 of the connector needs to connect
-     to pin 2.7 on the board.)
-
-     If you're using header pins, the upper row of holes in the connector
-     should overhang the edge of the board. If you're using a floppy drive
-     motherboard connector, you're golden, of course (unless you have one of
-     those annoying unkeyed cables, or have accidentally soldered the
-     connector on in the wrong place --- don't laugh, I've done it.)
-
-  2. Plug the drive end of your floppy disk cable into the drive (or drives).
-
-     Floppy disk cables typically have [two pairs of floppy disk drive
-     connectors with a twist between
-     them](http://www.nullmodem.com/Floppy.htm). (Each pair has one connector
-     for a 3.5" drive and a different one for a 5.25" drive.) (Some cables
-     are cheap and just have the 3.5" connectors. Some are _very_ cheap and
-     have a single 3.5" connector, after the twist.)
-     
-     FluxEngine uses, sadly, non-standard disk numbering (there are reasons).
-     Drive 0 is the one nearest the motherboard; that is, before the twist.
-     Drive 1 is the one at the end of the cable; that is, after the twist.
-     Drive 0 is the default. If you only have one drive, remember to plug the
-     drive into the connector _before_ the twist. (Or use `-s :d=1` to select
-     drive 1 when working with disks.)
-
-  3. **Important.** Make sure that no disk you care about is in the drive.
-     (Because if your wiring is wrong and a disk is inserted, you'll corrupt it.)
-
-  4. Connect the floppy drive to power. Nothing should happen. If you've
-     connected something in backwards, you'll see the drive light up, the
-     motor start, and if you didn't take the disk out, one track has just
-     been wiped. If this happens, check your wiring.
-
-  5. Connect the FluxEngine to your PC via USB --- using the little socket on
-     the board, not the big programmer plug.
-
-  6. Insert a scratch disk and do `fluxengine rpm` from the shell. The motor
-     should work and it'll tell you that the disk is spinning at about 300
-     rpm for a 3.5" disk, or 360 rpm for a 5.25" disk. If it doesn't, please
-     [get in touch](https://github.com/davidgiven/fluxengine/issues/new).
-
-  7. Do `fluxengine test bulktransport` from the shell. It'll measure your USB
-     bandwidth. Ideally you should be getting above 900kB/s. FluxEngine needs
-     about 850kB/s, so if you're getting less than this, try a different USB
-     port.
-
-  8. Insert a standard PC formatted floppy disk into the drive (probably a good
-     idea to remove the old disk first). Then do `fluxengine read ibm`. It
-     should read the disk, emitting copious diagnostics, and spit out an
-     `ibm.img` file containing the decoded disk image (either 1440kB or 720kB
-     depending).
-
-  9. Profit!
+So you've [built the hardware](building.md), programmed and tested it! What
+now?

 ## The programs

@@ -71,10 +11,33 @@ moving too quickly for the documentation to keep up. It does respond to
 `--help` or `help` depending on context. There are some common properties,
 described below.

+### Core concepts
+
+FluxEngine fundamentally takes file system images and puts them on disk; or
+reads the disk and produces a file system image.
+
+A file system image typically has the extension `.img`. It contains a
+sector-by-sector record of the _decoded_ data on the disk. For example, on a
+disk with 512 byte sectors, one sector will occupy 512 bytes. These are
+typically what you want in everyday life.
+
+FluxEngine can also record the raw magnetic data on the disk into a file, which
+we call a _flux file_. This contains all the low-level data which the drive
+produced as the disk rotated. These are continuous streams of samples from the
+disk and are completely useless in day-to-day life. FluxEngine uses its own
+format for this, `.flux`, although it's capable of limited interchange with
+Kryoflux, Supercard Pro and Catweasel files. A flux file will typically contain
+from 80 to 150 kilobytes of data per track.
+
+In general, FluxEngine can use either a real disk or a flux file
+interchangeably: you can specify either at (very nearly) any time. A very
+common workflow is to read a disk to a flux file, and then reread from the flux
+file while changing the decoder options, to save disk wear. It's also much faster.
+
 ### Source and destination specifiers

-When reading from or writing to _a disk_ (or a file pretending to be a disk),
-use the `--source` (`-s`) and `--dest` (`-d`) options to tell FluxEngine
+When reading from or writing _flux_ (either from or to a real disk, or a flux
+file), use the `--source` (`-s`) and `--dest` (`-d`) options to tell FluxEngine
 which bits of the disk you want to access. These use a common syntax:

 ```
@@ -84,7 +47,7 @@ fluxengine read ibm -s fakedisk.flux:t=0-79:s=0
  - To access a real disk, leave out the filename (so `:t=0-79:s=0`).

  - To access only some tracks, use the `t=` modifier. To access only some
-    sides, use the `s=` modifier. To change drives, use `d=`.
+    sides, use the `s=` modifier.

  - Inside a modifier, you can use a comma separated list of ranges. So
    `:t=0-3` and `:t=0,1,2,3` are equivalent.
@@ -110,18 +73,15 @@ If you _don't_ specify a modifier, you'll get the default, which should be
 sensible for the command you're using.

 **Important note:** FluxEngine _always_ uses zero-based units (even if the
-*disk format says otherwise).
+disk format says otherwise).

 ### Input and output specifiers

-These use a very similar syntax to the source and destination specifiers
-(because they're based on the same microformat library!) but are used for
-input and output _images_: i.e. nicely lined up arrays of sectors which you
-can actually do something with.
-
-Use `--input` (`-i`) or `--output` (`-o`) as appropriate to tell FluxEngine
-where you want to read from or write to. The actual format is autodetected
-based on the extension:
+When reading or writing _file system images_, use the `--input` (`-i`) and
+`--output` (`-o`) options to specify the file and file format. These use a very
+similar syntax to the source and destination specifiers (because they're based
+on the same microformat library!) but with different specifiers. Also, the
+exact format varies according to the extension:

  - `.img` or `.adf`: raw sector images in CHS order. Append
    `:c=80:h=2:s=9:b=512` to set the geometry; that specifies 80 cylinders, 2
@@ -176,6 +136,29 @@ case, and reading the disk label is much more reliable.
 [Lots more information on high density vs double density disks can be found
 here.](http://www.retrotechnology.com/herbs_stuff/guzis.html)

+### Other important flags
+
+These flags apply to many operations and are useful for modifying the overall
+behaviour.
+
+  - `--revolutions=X`: when reading, spin the disk X times. X can be a floating
+	point number. The default is usually 1.25. Some formats default to 1.
+	Increasing the number will sample more data, and can be useful on dubious
+	disks to try and get a better read.
+
+  - `--sync-with-index=true|false`: wait for an index pulse before starting to
+	read the disk. (Ignored for write operations.) By default FluxEngine
+	doesn't, as it makes reads faster, but when diagnosing disk problems it's
+	helpful to have all your data start at the same place each time.
+
+  - `--index-source=X`, `--write-index-source=X`: set the source of index
+	pulses when reading or writing respectively. This is for use with drives
+	which don't produce index pulse data. Use 0 to get index pulses from the
+	drive, 1 to fake 300RPM pulses, or 2 to fake 360RPM pulses. Note this has
+	no effect on the _drive_, so it doesn't help with flippy disks, but is
+	useful for using very old drives with FluxEngine itself. If you use this
+	option, then any index marks in the sampled flux are, of course, garbage.
+
 ### The commands

 The FluxEngine client software is a largely undocumented set of small tools.
@@ -184,59 +167,61 @@ installed anywhere and after building you'll find them in the `.obj`
 directory.

  - `fluxengine erase`: wipes (all or part of) a disk --- erases it without
-  writing a pulsetrain.
+	writing a pulsetrain.

  - `fluxengine inspect`: dumps the raw pulsetrain / bitstream to stdout.
-  Mainly useful for debugging.
+	Mainly useful for debugging.

-  - `fluxengine read*`: reads various formats of disk. See the per-format
-  documentation linked from the table above. These all take an optional
-  `--write-flux` option which will cause the raw flux to be written to the
-  specified file.
+  - `fluxengine read *`: reads various formats of disk. See the per-format
+	documentation linked from the table [in the index page](../README.md).
+	These all take an optional `--write-flux` option which will cause the raw
+	flux to be written to the specified file as well as the normal decode.
+	There are various `--dump` options for showing raw data during the decode
+	process.

-  - `fluxengine write*`: writes various formats of disk. Again, see the
-  per-format documentation above.
+  - `fluxengine write *`: writes various formats of disk. Again, see the
+	per-format documentation [in the index page](../README.md).

  - `fluxengine writeflux`: writes raw flux files. This is much less useful
-  than you might think: you can't write flux files read from a disk to
-  another disk. (See the [FAQ](faq.md) for more information.) It's mainly
-  useful for flux files synthesised by the other `fluxengine write` commands.
+	than you might think: you can't reliably write flux files read from a disk
+	to another disk. (See the [FAQ](faq.md) for more information.) It's mainly
+	useful for flux files synthesised by the other `fluxengine write` commands.

  - `fluxengine writetestpattern`: writes regular pulses (at a configurable
-  interval) to the disk. Useful for testing drive jitter, erasing disks in a
-  more secure fashion, or simply debugging. Goes well with `fluxengine
-  inspect`.
+	interval) to the disk. Useful for testing drive jitter, erasing disks in a
+	more secure fashion, or simply debugging. Goes well with `fluxengine
+	inspect`.

  - `fluxengine rpm`: measures the RPM of the drive (requires a disk in the
-  drive). Mainly useful for testing.
+	drive). Mainly useful for testing.

  - `fluxengine seek`: moves the head. Mainly useful for finding out whether
-  your drive can seek to track 82. (Mine can't.)
+	your drive can seek to track 82. (Mine can't.)

-  - `fluxengine test bulktransport`: measures your USB throughput. You need
-  about 600kB/s for FluxEngine to work. You don't need a disk in the drive
-  for this one.
+  - `fluxengine test bandwidth`: measures your USB throughput.  You don't need
+	a disk in the drive for this one.

-  - `fluxengine test voltages`: measures your FDD bus signal voltages, which
-  is useful for testing for termination issues.
+  - `fluxengine test voltages`: measures your FDD bus signal voltages, which is
+	useful for testing for termination issues.

-  - `fluxengine upgradefluxfile`: occasionally I need to upgrade the flux
-  file format in a non-backwards-compatible way; this tool will upgrade flux
-  files to the new format.
+  - `fluxengine upgradefluxfile`: occasionally I need to upgrade the flux file
+	format in a non-backwards-compatible way; this tool will upgrade flux files
+	to the new format.

  - `fluxengine convert`: converts flux files from various formats to various
-  other formats. You can use this to convert Catweasel flux files to
-  FluxEngine's native format, FluxEngine flux files to various other formats
-  useful for debugging (including VCD which can be loaded into
-  [sigrok](http://sigrok.org)), and bidirectional conversion to and from
-  Supercard Pro `.scp` format.
+	other formats. You can use this to convert Catweasel flux files to
+	FluxEngine's native format, FluxEngine flux files to various other formats
+	useful for debugging (including VCD which can be loaded into
+	[sigrok](http://sigrok.org)), and bidirectional conversion to and from
+	Supercard Pro `.scp` format.

-  **Important SCP note:** import (`fluxengine convert scptoflux`) should be
-  fairly robust, but export (`fluxengine convert fluxtoscp`) should only be
-  done with great caution as FluxEngine files contain features which can't be
-  represented very well in `.scp` format and they're probably pretty dubious.
-  As ever, please [get in
-  touch](https://github.com/davidgiven/fluxengine/issues/new) with any reports.
+	**Important SCP note:** import (`fluxengine convert scptoflux`) should be
+	fairly robust, but export (`fluxengine convert fluxtoscp`) should only be
+	done with great caution as FluxEngine files contain features which can't be
+	represented very well in `.scp` format and they're probably pretty dubious.
+	As ever, please [get in
+	touch](https://github.com/davidgiven/fluxengine/issues/new) with any
+	reports.

 Commands which normally take `--source` or `--dest` get a sensible default if
 left unspecified. `fluxengine read ibm` on its own will read drive 0 and
@@ -262,8 +247,10 @@ disk). For a 5.25" disk, use `--visualiser-period=166`.
 Supplied with FluxEngine, but not part of FluxEngine, are some little tools I
 wrote to do useful things. These are built alongside FluxEngine.

-  - `brother120tool`: extracts files from a 120kB Brother filesystem image.
-
+  - `brother120tool`, `brother240tool`: does things to Brother word processor
+	disks. These are [documented on the Brother disk format
+	page](disk-brother.md).
+  
 ## The recommended workflow

 So you've just received, say, a huge pile of old Brother word processor disks
@@ -272,13 +259,13 @@ containing valuable historical data, and you want to read them.
 Typically I do this:

 ```
-$ fluxengine read brother -s :d=0 -o brother.img --write-flux=brother.flux --write-svg=brother.svg
+$ fluxengine read brother -s :d=0 -o brother.img --write-flux=brother.flux --overwrite --write-svg=brother.svg
 ```

-This will read the disk in drive 0 and write out a filesystem image. It'll
-also copy the flux to brother.flux and write out an SVG visualisation. If I
-then need to tweak the settings, I can rerun the decode without having to
-physically touch the disk like this:
+This will read the disk in drive 0 and write out a filesystem image. It'll also
+copy the flux to `brother.flux` (replacing any old one) and write out an SVG
+visualisation. If I then need to tweak the settings, I can rerun the decode
+without having to physically touch the disk like this:

 ```
 $ fluxengine read brother -s brother.flux -o brother.img --write-svg=brother.svg
--- a/lib/bytes.cc
+++ b/lib/bytes.cc
@@ -147,6 +147,28 @@ Bytes Bytes::slice(unsigned start, unsigned len) const
    }
 }

+Bytes Bytes::slice(unsigned start) const
+{
+	int len = 0;
+	if (start < size())
+		len = size() - start;
+	return slice(start, len);
+}
+
+std::vector<bool> Bytes::toBits() const
+{
+	std::vector<bool> bits;
+	for (uint8_t byte : *this)
+	{
+		for (int i=0; i<8; i++)
+		{
+			bits.push_back(byte & 0x80);
+			byte <<= 1;
+		}
+	}
+	return bits;
+}
+
 uint8_t toByte(
    std::vector<bool>::const_iterator start,
    std::vector<bool>::const_iterator end)
--- a/lib/bytes.h
+++ b/lib/bytes.h
@@ -47,11 +47,13 @@ public:
    { resize(0); return *this; }

    Bytes slice(unsigned start, unsigned len) const;
+    Bytes slice(unsigned start) const;
    Bytes swab() const;
    Bytes compress() const;
    Bytes decompress() const;
    Bytes crunch() const;
    Bytes uncrunch() const;
+	std::vector<bool> toBits() const;

    ByteReader reader() const;
    ByteWriter writer();
--- a/lib/common/crunch.c
+++ b/lib/common/crunch.c
@@ -9,14 +9,37 @@ void crunch(crunch_state_t* state)
        uint8_t data = *state->inputptr++;
        state->inputlen--;

-        if (data & 0x80)
+		if (data == 0x80)
+		{
+			/* Multiple 0x80s in a row get swallowed as they're
+			 * meaningless. */
+			state->haspending = true;
+		}
+        else if (data & 0x80)
        {
-            state->fifo = (state->fifo << 2) | 2 | (data & 1);
-            state->fifolen += 2;
+			if (state->haspending)
+			{
+				state->fifo = (state->fifo << 3) | 4;
+				state->fifolen += 3;
+				state->haspending = false;
+			}
+
+            state->fifo = (state->fifo << 3) | 4 | (data & 1);
+            state->fifolen += 3;
        }
        else
        {
-            state->fifo = (state->fifo << 8) | data;
+			if (state->haspending && (data >= 0x40))
+			{
+				state->fifo = (state->fifo << 3) | 4;
+				state->fifolen += 3;
+				state->haspending = false;
+			}
+				
+			state->fifo = (state->fifo << 8) | data;
+			if (state->haspending)
+				state->fifo |= 0xc0;
+			state->haspending = false;
            state->fifolen += 8;
        }

@@ -45,6 +68,14 @@ void uncrunch(crunch_state_t* state)
 {
    while (state->inputlen && state->outputlen)
    {
+		if (state->haspending)
+		{
+			*state->outputptr++ = state->pendingbyte;
+			state->outputlen--;
+			state->haspending = false;
+			continue;
+		}
+
        if (state->fifolen < 8)
        {
            if (state->inputlen)
@@ -58,13 +89,21 @@ void uncrunch(crunch_state_t* state)
        }

        uint8_t data = state->fifo >> (state->fifolen - 8);
-        if (data & 0x80)
-        {
-            data = ((data >> 6) & 0x01) | 0x80;
-            state->fifolen -= 2;
-        }
-        else
-            state->fifolen -= 8;
+		switch (data & 0xc0)
+		{
+			case 0x80:
+				data = ((data >> 5) & 0x01) | 0x80;
+				state->fifolen -= 3;
+				break;
+
+			case 0xc0:
+				state->haspending = true;
+				state->pendingbyte = data & 0x3f;
+				data = 0x80;
+				/* fall through */
+			default:
+				state->fifolen -= 8;
+		}

        if (data)
        {
--- a/lib/common/crunch.h
+++ b/lib/common/crunch.h
@@ -11,7 +11,8 @@ extern "C" {
 * sending it over USB. The encoding used is:
 * 
 * 0nnn.nnnn: value 0x00..0x7f
- * 1n       : value 0x80|n
+ * 11nn.nnnn: value 0x80 then 0x00..0x3f
+ * 10n      : value 0x80|n
 *
 * The end of the buffer is terminated with zeroes, which are ignored
 * (not written to the output).
@@ -25,8 +26,10 @@ typedef struct crunch_state_t
    uint32_t inputlen;
    uint8_t* outputptr;
    uint32_t outputlen;
-    uint16_t fifo;
+    uint32_t fifo;
    uint8_t fifolen;
+	bool haspending;
+	uint8_t pendingbyte;
 }
 crunch_state_t;

--- a/lib/dataspec.cc
+++ b/lib/dataspec.cc
@@ -15,34 +15,31 @@ std::vector<std::string> DataSpec::split(
 {
    std::vector<std::string> ret;

-    size_t start = 0;
-    size_t end = 0;
-    size_t len = 0;
-    do
-    {
-        end = s.find(delimiter,start); 
-        len = end - start;
-        std::string token = s.substr(start, len);
-        ret.emplace_back( token );
-        start += len + delimiter.length();
-    }
-    while (end != std::string::npos);
+	if (!s.empty())
+	{
+		size_t start = 0;
+		size_t end = 0;
+		size_t len = 0;
+		do
+		{
+			end = s.find(delimiter,start); 
+			len = end - start;
+			std::string token = s.substr(start, len);
+			ret.emplace_back( token );
+			start += len + delimiter.length();
+		}
+		while (end != std::string::npos);
+	}
+
    return ret;
 }

-DataSpec::Modifier DataSpec::parseMod(const std::string& spec)
+std::set<unsigned> DataSpec::parseRange(const std::string& data)
 {
-    static const std::regex MOD_REGEX("([a-z]*)=([-x+0-9,]*)");
-    static const std::regex DATA_REGEX("([0-9]+)(?:(?:-([0-9]+))|(?:\\+([0-9]+)))?(?:x([0-9]+))?");
+	static const std::regex DATA_REGEX("([0-9]+)(?:(?:-([0-9]+))|(?:\\+([0-9]+)))?(?:x([0-9]+))?");

-    std::smatch match;
-    if (!std::regex_match(spec, match, MOD_REGEX))
-        Error() << "invalid data modifier syntax '" << spec << "'";
-    
-    Modifier m;
-    m.name = match[1];
-    m.source = spec;
-    for (auto& data : split(match[2], ","))
+	std::set<unsigned> result;
+    for (auto& data : split(data, ","))
    {
        int start = 0;
        int count = 1;
@@ -64,9 +61,24 @@ DataSpec::Modifier DataSpec::parseMod(const std::string& spec)
            Error() << "mod '" << data << "' specifies an illegal quantity";

        for (int i = start; i < (start+count); i += step)
-            m.data.insert(i);
+            result.insert(i);
    }

+    return result;
+}
+
+DataSpec::Modifier DataSpec::parseMod(const std::string& spec)
+{
+	static const std::regex MOD_REGEX("([a-z]*)=([-x+0-9,]*)");
+
+    std::smatch match;
+    if (!std::regex_match(spec, match, MOD_REGEX))
+        Error() << "invalid data modifier syntax '" << spec << "'";
+    
+    Modifier m;
+    m.name = match[1];
+    m.source = spec;
+	m.data = parseRange(match[2]);
    return m;
 }

@@ -74,7 +86,7 @@ void DataSpec::set(const std::string& spec)
 {
    std::vector<std::string> words = split(spec, ":");
    if (words.size() == 0)
-        Error() << "empty data specification (you have to specify *something*)";
+		return;

    filename = words[0];
    if (words.size() > 1)
--- a/lib/dataspec.h
+++ b/lib/dataspec.h
@@ -34,6 +34,8 @@ public:
 public:
    static std::vector<std::string> split(
        const std::string& s, const std::string& delimiter);
+	static std::set<unsigned> parseRange(const std::string& spec);
+
    static Modifier parseMod(const std::string& spec);

 public:
@@ -117,4 +119,34 @@ private:
    DataSpec _value;
 };

+class RangeFlag : public Flag
+{
+public:
+    RangeFlag(const std::vector<std::string>& names, const std::string helptext,
+            const std::string& defaultValue):
+        Flag(names, helptext),
+		_stringValue(defaultValue),
+        _value(DataSpec::parseRange(defaultValue))
+    {}
+
+    const std::set<unsigned>& get() const
+    { checkInitialised(); return _value; }
+
+    operator const std::set<unsigned>& () const
+    { return get(); }
+
+    bool hasArgument() const { return true; }
+    const std::string defaultValueAsString() const { return _stringValue; }
+
+    void set(const std::string& value)
+	{
+		_stringValue = value;
+		_value = DataSpec::parseRange(value);
+	}
+
+private:
+	std::string _stringValue;
+    std::set<unsigned> _value;
+};
+
 #endif
--- a/lib/decoders/decoders.cc
+++ b/lib/decoders/decoders.cc
@@ -25,7 +25,7 @@ void AbstractDecoder::decodeToSectors(Track& track)
    beginTrack();
    for (;;)
    {
-        Fluxmap::Position recordStart = sector.position = fmr.tell();
+        Fluxmap::Position recordStart = fmr.tell();
        sector.clock = 0;
        sector.status = Sector::MISSING;
        sector.data.clear();
@@ -41,7 +41,7 @@ void AbstractDecoder::decodeToSectors(Track& track)

        /* Read the sector record. */

-        recordStart = fmr.tell();
+        sector.position = recordStart = fmr.tell();
        decodeSectorRecord();
        Fluxmap::Position recordEnd = fmr.tell();
        pushRecord(recordStart, recordEnd);
@@ -51,14 +51,19 @@ void AbstractDecoder::decodeToSectors(Track& track)

            sector.headerStartTime = recordStart.ns();
            sector.headerEndTime = recordEnd.ns();
-            r = advanceToNextRecord();
+			for (;;)
+			{
+				r = advanceToNextRecord();
+				if (r != UNKNOWN_RECORD)
+					break;
+				if (fmr.readNextMatchingOpcode(F_OP_PULSE) == 0)
+                    break;
+			}
+            recordStart = fmr.tell();
            if (r == DATA_RECORD)
-            {
-                recordStart = fmr.tell();
                decodeDataRecord();
-                recordEnd = fmr.tell();
-                pushRecord(recordStart, recordEnd);
-            }
+            recordEnd = fmr.tell();
+            pushRecord(recordStart, recordEnd);
        }
        sector.dataStartTime = recordStart.ns();
        sector.dataEndTime = recordEnd.ns();
@@ -83,3 +88,10 @@ void AbstractDecoder::pushRecord(const Fluxmap::Position& start, const Fluxmap::
    _track->rawrecords.push_back(record);
    _fmr->seek(here);
 }
+
+std::set<unsigned> AbstractDecoder::requiredSectors(Track& track) const
+{
+	static std::set<unsigned> empty;
+	return empty;
+}
+
--- a/lib/decoders/decoders.h
+++ b/lib/decoders/decoders.h
@@ -20,6 +20,8 @@ extern void setDecoderManualClockRate(double clockrate_us);

 extern Bytes decodeFmMfm(std::vector<bool>::const_iterator start,
    std::vector<bool>::const_iterator end);
+extern void encodeMfm(std::vector<bool>& bits, unsigned& cursor, const Bytes& input, bool& lastBit);
+extern void encodeFm(std::vector<bool>& bits, unsigned& cursor, const Bytes& input);

 static inline Bytes decodeFmMfm(const std::vector<bool> bits)
 { return decodeFmMfm(bits.begin(), bits.end()); }
@@ -50,6 +52,11 @@ public:
    void seek(const Fluxmap::Position& pos)
    { return _fmr->seek(pos); } 

+	/* Returns a set of sectors required to exist on this track. If the reader
+	 * sees any missing, it will consider this to be an error and will retry
+	 * the read. */
+	virtual std::set<unsigned> requiredSectors(Track& track) const;
+
 protected:
    virtual void beginTrack() {};
    virtual RecordType advanceToNextRecord() = 0;
--- a/lib/decoders/fluxmapreader.cc
+++ b/lib/decoders/fluxmapreader.cc
@@ -18,13 +18,18 @@ DoubleFlag pulseDebounceThreshold(
 static DoubleFlag clockDecodeThreshold(
    { "--bit-error-threshold" },
    "Amount of error to tolerate in pulse timing, in fractions of a clock.",
-    0.20);
+    0.40);

 static DoubleFlag clockIntervalBias(
    { "--clock-interval-bias" },
    "Adjust intervals between pulses by this many clocks before decoding.",
    -0.02);

+static DoubleFlag minimumClockUs(
+    { "--minimum-clock-us" },
+    "Refuse to detect clocks shorter than this, to avoid false positives.",
+    0.75);
+
 int FluxmapReader::readOpcode(unsigned& ticks)
 {
    ticks = 0;
@@ -222,7 +227,9 @@ nanoseconds_t FluxmapReader::seekToPattern(const FluxMatcher& pattern, const Flu
            seek(positions[intervalCount-match.intervals]);
            _pos.zeroes = match.zeroes;
            matching = match.matcher;
-            return match.clock * NS_PER_TICK;
+            nanoseconds_t detectedClock = match.clock * NS_PER_TICK;
+            if (detectedClock > (minimumClockUs*1000))
+                return match.clock * NS_PER_TICK;
        }

        for (unsigned i=0; i<intervalCount; i++)
--- a/lib/decoders/fmmfm.cc
+++ b/lib/decoders/fmmfm.cc
@@ -51,3 +51,48 @@ Bytes decodeFmMfm(

    return bytes;
 }
+
+void encodeFm(std::vector<bool>& bits, unsigned& cursor, const Bytes& input)
+{
+	if (bits.size() == 0)
+		return;
+    unsigned len = bits.size()-1;
+
+    for (uint8_t b : input)
+    {
+        for (int i=0; i<8; i++)
+        {
+            bool bit = b & 0x80;
+            b <<= 1;
+
+            if (cursor >= len)
+                return;
+            
+            bits[cursor++] = true;
+            bits[cursor++] = bit;
+        }
+    }
+}
+
+void encodeMfm(std::vector<bool>& bits, unsigned& cursor, const Bytes& input, bool& lastBit)
+{
+	if (bits.size() == 0)
+		return;
+    unsigned len = bits.size()-1;
+
+    for (uint8_t b : input)
+    {
+        for (int i=0; i<8; i++)
+        {
+            bool bit = b & 0x80;
+            b <<= 1;
+
+            if (cursor >= len)
+                return;
+            
+            bits[cursor++] = !lastBit && !bit;
+            bits[cursor++] = bit;
+            lastBit = bit;
+        }
+    }
+}
--- a/lib/flags.cc
+++ b/lib/flags.cc
@@ -1,5 +1,6 @@
 #include "globals.h"
 #include "flags.h"
+#include "fmt/format.h"

 static FlagGroup* currentFlagGroup;
 static std::vector<Flag*> all_flags;
@@ -157,6 +158,8 @@ Flag::Flag(const std::vector<std::string>& names, const std::string helptext):
    _names(names),
    _helptext(helptext)
 {
+    if (!currentFlagGroup)
+        Error() << "no flag group defined for " << *names.begin();
    _group.addFlag(this);
 }

@@ -170,6 +173,11 @@ void BoolFlag::set(const std::string& value)
 		Error() << "can't parse '" << value << "'; try 'true' or 'false'";
 }

+const std::string HexIntFlag::defaultValueAsString() const
+{
+	return fmt::format("0x{:x}", _defaultValue);
+}
+
 static void doHelp()
 {
    std::cout << "FluxEngine options:" << std::endl;
--- a/lib/flags.h
+++ b/lib/flags.h
@@ -135,6 +135,17 @@ public:
    void set(const std::string& value) { _value = std::stoi(value); }
 };

+class HexIntFlag : public IntFlag
+{
+public:
+    HexIntFlag(const std::vector<std::string>& names, const std::string helptext,
+            int defaultValue = 0):
+        IntFlag(names, helptext, defaultValue)
+    {}
+
+    const std::string defaultValueAsString() const;
+};
+
 class DoubleFlag : public ValueFlag<double>
 {
 public:
@@ -147,7 +158,7 @@ public:
    void set(const std::string& value) { _value = std::stod(value); }
 };

-class BoolFlag : public ValueFlag<double>
+class BoolFlag : public ValueFlag<bool>
 {
 public:
    BoolFlag(const std::vector<std::string>& names, const std::string helptext,
--- a/lib/fluxsink/fluxsink.h
+++ b/lib/fluxsink/fluxsink.h
@@ -1,6 +1,11 @@
 #ifndef FLUXSINK_H
 #define FLUXSINK_H

+#include "flags.h"
+
+extern FlagGroup hardwareFluxSinkFlags;
+extern FlagGroup sqliteFluxSinkFlags;
+
 class Fluxmap;
 class FluxSpec;

@@ -9,11 +14,9 @@ class FluxSink
 public:
    virtual ~FluxSink() {}

-private:
    static std::unique_ptr<FluxSink> createSqliteFluxSink(const std::string& filename);
    static std::unique_ptr<FluxSink> createHardwareFluxSink(unsigned drive);

-public:
    static std::unique_ptr<FluxSink> create(const FluxSpec& spec);

 public:
--- a/lib/fluxsink/hardwarefluxsink.cc
+++ b/lib/fluxsink/hardwarefluxsink.cc
@@ -4,8 +4,15 @@
 #include "usb.h"
 #include "fluxsink/fluxsink.h"

+FlagGroup hardwareFluxSinkFlags;
+
 static bool high_density = false;

+static IntFlag indexMode(
+    { "--write-index-mode" },
+    "index pulse source (0=drive, 1=300 RPM fake source, 2=360 RPM fake source",
+    0);
+
 void setHardwareFluxSinkDensity(bool high_density)
 {
 	::high_density = high_density;
@@ -26,7 +33,7 @@ public:
 public:
    void writeFlux(int track, int side, Fluxmap& fluxmap)
    {
-        usbSetDrive(_drive, high_density);
+        usbSetDrive(_drive, high_density, indexMode);
        usbSeek(track);

        Bytes crunched = fluxmap.rawBytes().crunch();
--- a/lib/fluxsink/sqlitefluxsink.cc
+++ b/lib/fluxsink/sqlitefluxsink.cc
@@ -2,14 +2,37 @@
 #include "fluxmap.h"
 #include "sql.h"
 #include "fluxsink/fluxsink.h"
+#include "flags.h"
 #include "fmt/format.h"
+#include <unistd.h>
+
+FlagGroup sqliteFluxSinkFlags;
+
+static SettableFlag mergeFlag(
+	{ "--merge" },
+	"merge new data into existing flux file");
+
+static SettableFlag overwriteFlag(
+	{ "--overwrite" },
+	"overwrite existing flux file");

 class SqliteFluxSink : public FluxSink
 {
 public:
    SqliteFluxSink(const std::string& filename)
    {
+		if (mergeFlag && overwriteFlag)
+			Error() << "you can't specify --merge and --overwrite";
+
+		if (!mergeFlag)
+		{
+			if (!overwriteFlag && (access(filename.c_str(), F_OK) == 0))
+				Error() << "cowardly refusing to overwrite flux file without --merge or --overwrite specified";
+			if ((access(filename.c_str(), F_OK) == 0) && (remove(filename.c_str()) != 0))
+				Error() << fmt::format("failed to overwrite flux file");
+		}
 		_outdb = sqlOpen(filename, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
+
 		int oldVersion = sqlReadIntProperty(_outdb, "version");
 		if ((oldVersion != 0) && (oldVersion != FLUX_VERSION_CURRENT))
            Error() << fmt::format("that flux file is version {}, but this client is for version {}",
--- a/lib/fluxsource/fluxsource.h
+++ b/lib/fluxsource/fluxsource.h
@@ -27,8 +27,9 @@ public:
    virtual bool retryable() { return false; }
 };

-extern void setHardwareFluxSourceRevolutions(int revolutions);
+extern void setHardwareFluxSourceRevolutions(double revolutions);
 extern void setHardwareFluxSourceDensity(bool high_density);
+extern void setHardwareFluxSourceSynced(bool synced);

 #endif

--- a/lib/fluxsource/hardwarefluxsource.cc
+++ b/lib/fluxsource/hardwarefluxsource.cc
@@ -3,13 +3,24 @@
 #include "fluxmap.h"
 #include "usb.h"
 #include "fluxsource/fluxsource.h"
+#include "fmt/format.h"

 FlagGroup hardwareFluxSourceFlags;

-static IntFlag revolutions(
+static DoubleFlag revolutions(
    { "--revolutions" },
    "read this many revolutions of the disk",
-    1);
+    1.25);
+
+static BoolFlag synced(
+    { "--sync-with-index" },
+    "whether to wait for an index pulse before started to read",
+    false);
+
+static IntFlag indexMode(
+    { "--index-mode" },
+    "index pulse source (0=drive, 1=300 RPM fake source, 2=360 RPM fake source",
+    0);

 static bool high_density = false;

@@ -24,6 +35,10 @@ public:
    HardwareFluxSource(unsigned drive):
        _drive(drive)
    {
+        usbSetDrive(_drive, high_density, indexMode);
+        std::cerr << "Measuring rotational speed... " << std::flush;
+        _oneRevolution = usbGetRotationalPeriod();
+        std::cerr << fmt::format("{}ms\n", _oneRevolution / 1e6);
    }

    ~HardwareFluxSource()
@@ -33,9 +48,9 @@ public:
 public:
    std::unique_ptr<Fluxmap> readFlux(int track, int side)
    {
-        usbSetDrive(_drive, high_density);
+        usbSetDrive(_drive, high_density, indexMode);
        usbSeek(track);
-        Bytes crunched = usbRead(side, revolutions);
+        Bytes crunched = usbRead(side, synced, revolutions * _oneRevolution);
        auto fluxmap = std::make_unique<Fluxmap>();
        fluxmap->appendBytes(crunched.uncrunch());
        return fluxmap;
@@ -54,13 +69,19 @@ public:
 private:
    unsigned _drive;
    unsigned _revolutions;
+    nanoseconds_t _oneRevolution;
 };

-void setHardwareFluxSourceRevolutions(int revolutions)
+void setHardwareFluxSourceRevolutions(double revolutions)
 {
    ::revolutions.setDefaultValue(revolutions);
 }

+void setHardwareFluxSourceSynced(bool synced)
+{
+    ::synced.setDefaultValue(synced);
+}
+
 std::unique_ptr<FluxSource> FluxSource::createHardwareFluxSource(unsigned drive)
 {
    return std::unique_ptr<FluxSource>(new HardwareFluxSource(drive));
--- a/lib/reader.cc
+++ b/lib/reader.cc
@@ -2,6 +2,7 @@
 #include "flags.h"
 #include "usb.h"
 #include "fluxsource/fluxsource.h"
+#include "fluxsink/fluxsink.h"
 #include "reader.h"
 #include "fluxmap.h"
 #include "sql.h"
@@ -18,7 +19,13 @@
 #include "imagewriter/imagewriter.h"
 #include "fmt/format.h"

-FlagGroup readerFlags { &hardwareFluxSourceFlags, &fluxmapReaderFlags, &visualiserFlags };
+FlagGroup readerFlags
+{
+	&hardwareFluxSourceFlags,
+	&sqliteFluxSinkFlags,
+	&fluxmapReaderFlags,
+	&visualiserFlags
+};

 static DataSpecFlag source(
    { "--source", "-s" },
@@ -46,7 +53,11 @@ static SettableFlag justRead(

 static SettableFlag dumpRecords(
 	{ "--dump-records" },
-	"Dump the parsed records.");
+	"Dump the parsed but undecoded records.");
+
+static SettableFlag dumpSectors(
+	{ "--dump-sectors" },
+	"Dump the decoded sectors.");

 static IntFlag retries(
 	{ "--retries" },
@@ -57,7 +68,7 @@ static SettableFlag highDensityFlag(
 	{ "--high-density", "--hd" },
 	"set the drive to high density mode");

-static sqlite3* outdb;
+static std::unique_ptr<FluxSink> outputFluxSink;

 void setReaderDefaultSource(const std::string& source)
 {
@@ -82,8 +93,8 @@ void Track::readFluxmap()
 		"{0} ms in {1} bytes\n",
            int(fluxmap->duration()/1e6),
            fluxmap->bytes());
-	if (outdb)
-		sqlWriteFlux(outdb, physicalTrack, physicalSide, *fluxmap);
+	if (outputFluxSink)
+		outputFluxSink->writeFlux(physicalTrack, physicalSide, *fluxmap);
 }

 std::vector<std::unique_ptr<Track>> readTracks()
@@ -96,17 +107,8 @@ std::vector<std::unique_ptr<Track>> readTracks()

 	if (!destination.get().empty())
 	{
-		outdb = sqlOpen(destination, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
 		std::cout << "Writing a copy of the flux to " << destination.get() << std::endl;
-		sqlPrepareFlux(outdb);
-		sqlStmt(outdb, "BEGIN;");
-        sqlWriteIntProperty(outdb, "version", FLUX_VERSION_CURRENT);
-		atexit([]()
-			{
-				sqlStmt(outdb, "COMMIT;");
-				sqlClose(outdb);
-			}
-		);
+		outputFluxSink = FluxSink::createSqliteFluxSink(destination.get());
 	}

 	std::shared_ptr<FluxSource> fluxSource = FluxSource::create(spec);
@@ -174,8 +176,6 @@ void readDiskCommand(AbstractDecoder& decoder)
 			decoder.decodeToSectors(*track);

 			std::cout << "       ";
-			if (!track->sectors.empty())
-			{
 				std::cout << fmt::format("{} records, {} sectors; ",
 					track->rawrecords.size(),
 					track->sectors.size());
@@ -191,9 +191,12 @@ void readDiskCommand(AbstractDecoder& decoder)
 				}

 				bool hasBadSectors = false;
+				std::set<unsigned> requiredSectors = decoder.requiredSectors(*track);
 				for (const auto& i : readSectors)
 				{
 					const auto& sector = i.second;
+					requiredSectors.erase(sector->logicalSector);
+
 					if (sector->status != Sector::OK)
 					{
 						std::cout << std::endl
@@ -202,6 +205,12 @@ void readDiskCommand(AbstractDecoder& decoder)
 						hasBadSectors = true;
 					}
 				}
+				for (unsigned logicalSector : requiredSectors)
+				{
+					std::cout << "\n"
+					          << "       Required sector " << logicalSector << " missing; ";
+					hasBadSectors = true;
+				}

 				if (hasBadSectors)
 					failures = false;
@@ -211,7 +220,6 @@ void readDiskCommand(AbstractDecoder& decoder)

 				if (!hasBadSectors)
 					break;
-			}

 			if (!track->fluxsource->retryable())
 				break;
@@ -219,10 +227,7 @@ void readDiskCommand(AbstractDecoder& decoder)
                std::cout << "giving up" << std::endl
                          << "       ";
            else
-            {
 				std::cout << retry << " retries remaining" << std::endl;
-                track->fluxsource->recalibrate();
-            }
 		}

 		if (dumpRecords)
@@ -230,13 +235,27 @@ void readDiskCommand(AbstractDecoder& decoder)
 			std::cout << "\nRaw (undecoded) records follow:\n\n";
 			for (auto& record : track->rawrecords)
 			{
-				std::cout << fmt::format("I+{:.2f}us", record.position.ns() / 1000.0)
-						<< std::endl;
+				std::cout << fmt::format("I+{:.2f}us with {:.2f}us clock\n",
+                            record.position.ns() / 1000.0, record.clock / 1000.0);
 				hexdump(std::cout, record.data);
 				std::cout << std::endl;
 			}
 		}

+        if (dumpSectors)
+        {
+            std::cout << "\nDecoded sectors follow:\n\n";
+            for (auto& i : readSectors)
+            {
+                auto& sector = i.second;
+				std::cout << fmt::format("{}.{:02}.{:02}: I+{:.2f}us with {:.2f}us clock\n",
+                            sector->logicalTrack, sector->logicalSide, sector->logicalSector,
+                            sector->position.ns() / 1000.0, sector->clock / 1000.0);
+				hexdump(std::cout, sector->data);
+				std::cout << std::endl;
+            }
+        }
+
        int size = 0;
 		bool printedTrack = false;
        for (auto& i : readSectors)
--- a/lib/usb.cc
+++ b/lib/usb.cc
@@ -44,6 +44,10 @@ static void usb_init()
    if (i < 0)
        Error() << "could not claim interface: " << usberror(i);

+	i = libusb_reset_device(device);
+	if (i < 0)
+		Error() << "could not reset device: " << usberror(i);
+
    int version = usbGetVersion();
    if (version != FLUXENGINE_VERSION)
        Error() << "your FluxEngine firmware is at version " << version
@@ -149,7 +153,7 @@ nanoseconds_t usbGetRotationalPeriod(void)
    usb_cmd_send(&f, f.f.size);

    auto r = await_reply<struct speed_frame>(F_FRAME_MEASURE_SPEED_REPLY);
-    return r->period_ms * 1000;
+    return r->period_ms * 1000000;
 }

 static int large_bulk_transfer(int ep, Bytes& bytes)
@@ -161,11 +165,11 @@ static int large_bulk_transfer(int ep, Bytes& bytes)
    return len;
 }

-void usbTestBulkTransport()
+void usbTestBulkWrite()
 {
    usb_init();

-    struct any_frame f = { .f = {.type = F_FRAME_BULK_TEST_CMD, .size = sizeof(f)} };
+    struct any_frame f = { .f = {.type = F_FRAME_BULK_WRITE_TEST_CMD, .size = sizeof(f)} };
    usb_cmd_send(&f, f.f.size);

    /* These must match the device. */
@@ -180,9 +184,9 @@ void usbTestBulkTransport()

    std::cout << "Transferred "
              << bulk_buffer.size()
-              << " bytes in "
+              << " bytes from FluxEngine -> PC in "
              << int(elapsed_time * 1000.0)
-              << " ("
+              << " ms ("
              << int((bulk_buffer.size() / 1024.0) / elapsed_time)
              << " kB/s)"
              << std::endl;
@@ -199,16 +203,56 @@ void usbTestBulkTransport()
                            << x << '.' << y << '.' << z << '.';
            }

-    await_reply<struct any_frame>(F_FRAME_BULK_TEST_REPLY);
+    await_reply<struct any_frame>(F_FRAME_BULK_WRITE_TEST_REPLY);
 }

-Bytes usbRead(int side, int revolutions)
+void usbTestBulkRead()
+{
+    usb_init();
+
+    struct any_frame f = { .f = {.type = F_FRAME_BULK_READ_TEST_CMD, .size = sizeof(f)} };
+    usb_cmd_send(&f, f.f.size);
+
+    /* These must match the device. */
+    const int XSIZE = 64;
+    const int YSIZE = 256;
+    const int ZSIZE = 64;
+
+    Bytes bulk_buffer(XSIZE*YSIZE*ZSIZE);
+    for (int x=0; x<XSIZE; x++)
+        for (int y=0; y<YSIZE; y++)
+            for (int z=0; z<ZSIZE; z++)
+            {
+                int offset = x*XSIZE*YSIZE + y*ZSIZE + z;
+                bulk_buffer[offset] = uint8_t(x+y+z);
+            }
+
+    double start_time = getCurrentTime();
+    large_bulk_transfer(FLUXENGINE_DATA_OUT_EP, bulk_buffer);
+    double elapsed_time = getCurrentTime() - start_time;
+
+    std::cout << "Transferred "
+              << bulk_buffer.size()
+              << " bytes from PC -> FluxEngine in "
+              << int(elapsed_time * 1000.0)
+              << " ms ("
+              << int((bulk_buffer.size() / 1024.0) / elapsed_time)
+              << " kB/s)"
+              << std::endl;
+
+    await_reply<struct any_frame>(F_FRAME_BULK_READ_TEST_REPLY);
+}
+
+Bytes usbRead(int side, bool synced, nanoseconds_t readTime)
 {
    struct read_frame f = {
        .f = { .type = F_FRAME_READ_CMD, .size = sizeof(f) },
        .side = (uint8_t) side,
-        .revolutions = (uint8_t) revolutions
+        .synced = (uint8_t) synced
    };
+    uint16_t milliseconds = readTime / 1e6;
+    ((uint8_t*)&f.milliseconds)[0] = milliseconds;
+    ((uint8_t*)&f.milliseconds)[1] = milliseconds >> 8;
    usb_cmd_send(&f, f.f.size);

    auto fluxmap = std::unique_ptr<Fluxmap>(new Fluxmap);
@@ -253,13 +297,15 @@ void usbErase(int side)
    await_reply<struct any_frame>(F_FRAME_ERASE_REPLY);
 }

-void usbSetDrive(int drive, bool high_density)
+void usbSetDrive(int drive, bool high_density, int index_mode)
 {
    usb_init();

    struct set_drive_frame f = {
        { .type = F_FRAME_SET_DRIVE_CMD, .size = sizeof(f) },
-        .drive_flags = (uint8_t)((drive ? DRIVE_1 : DRIVE_0) | (high_density ? DRIVE_HD : DRIVE_DD)),
+        .drive = (uint8_t) drive,
+        .high_density = high_density,
+        .index_mode = (uint8_t) index_mode
    };
    usb_cmd_send(&f, f.f.size);
    await_reply<struct any_frame>(F_FRAME_SET_DRIVE_REPLY);
--- a/lib/usb.h
+++ b/lib/usb.h
@@ -8,11 +8,12 @@ extern int usbGetVersion();
 extern void usbRecalibrate();
 extern void usbSeek(int track);
 extern nanoseconds_t usbGetRotationalPeriod();
-extern void usbTestBulkTransport();
-extern Bytes usbRead(int side, int revolutions);
+extern void usbTestBulkWrite();
+extern void usbTestBulkRead();
+extern Bytes usbRead(int side, bool synced, nanoseconds_t readTime);
 extern void usbWrite(int side, const Bytes& bytes);
 extern void usbErase(int side);
-extern void usbSetDrive(int drive, bool high_density);
+extern void usbSetDrive(int drive, bool high_density, int index_mode);
 extern void usbMeasureVoltages(struct voltages_frame* voltages);

 #endif
--- a/lib/writer.cc
+++ b/lib/writer.cc
@@ -15,7 +15,7 @@
 #include "sector.h"
 #include "sectorset.h"

-FlagGroup writerFlags { &hardwareFluxSourceFlags };
+FlagGroup writerFlags { &hardwareFluxSourceFlags, &hardwareFluxSinkFlags };

 static DataSpecFlag dest(
    { "--dest", "-d" },
@@ -84,7 +84,9 @@ void writeTracks(
        }
        else
        {
-            fluxmap->precompensate(PRECOMPENSATION_THRESHOLD_TICKS, 2);
+            /* Precompensation actually seems to make things worse, so let's leave
+             * it disabled for now. */
+            //fluxmap->precompensate(PRECOMPENSATION_THRESHOLD_TICKS, 2);
            if (outdb)
                sqlWriteFlux(outdb, location.track, location.side, *fluxmap);
            else
--- a/mkninja.sh
+++ b/mkninja.sh
@@ -44,18 +44,27 @@ buildlibrary() {
        esac
    done

-    local objs
-    objs=
+    local oobjs
+	local dobjs
+    oobjs=
+	dobjs=
    for src in "$@"; do
        local obj
-        obj="$OBJDIR/${src%%.c*}.o"
-        objs="$objs $obj"
+        obj="$OBJDIR/opt/${src%%.c*}.o"
+        oobjs="$oobjs $obj"

        echo build $obj : cxx $src
-        echo "    flags=$flags"
+        echo "    flags=$flags $COPTFLAGS"
+
+        obj="$OBJDIR/dbg/${src%%.c*}.o"
+        dobjs="$dobjs $obj"
+
+        echo build $obj : cxx $src
+        echo "    flags=$flags $CDBGFLAGS"
    done

-    echo build $OBJDIR/$lib : library $objs
+    echo build $OBJDIR/opt/$lib : library $oobjs
+    echo build $OBJDIR/dbg/$lib : library $dobjs
 }

 buildprogram() {
@@ -77,16 +86,21 @@ buildprogram() {
        esac
    done

-    local objs
-    objs=
+    local oobjs
+	local dobjs
+    oobjs=
+	dobjs=
    for src in "$@"; do
-        objs="$objs $OBJDIR/$src"
+        oobjs="$oobjs $OBJDIR/opt/$src"
+        dobjs="$dobjs $OBJDIR/dbg/$src"
    done

-    echo build $prog-debug$EXTENSION : link $objs
-    echo "    flags=$flags"
+    echo build $prog-debug$EXTENSION : link $dobjs
+    echo "    flags=$flags $LDDBGFLAGS"
+
+    echo build $prog$EXTENSION : link $oobjs
+    echo "    flags=$flags $LDOPTFLAGS"

-    echo build $prog$EXTENSION : strip $prog-debug$EXTENSION
 }

 buildsimpleprogram() {
@@ -145,6 +159,8 @@ buildlibrary libbackend.a \
 	lib/imagewriter/ldbsimagewriter.cc \
    arch/aeslanier/decoder.cc \
    arch/amiga/decoder.cc \
+    arch/amiga/encoder.cc \
+    arch/amiga/amiga.cc \
    arch/apple2/decoder.cc \
    arch/brother/decoder.cc \
    arch/brother/encoder.cc \
@@ -152,6 +168,7 @@ buildlibrary libbackend.a \
    arch/f85/decoder.cc \
    arch/fb100/decoder.cc \
    arch/ibm/decoder.cc \
+    arch/ibm/encoder.cc \
    arch/macintosh/decoder.cc \
    arch/mx/decoder.cc \
    arch/victor9k/decoder.cc \
@@ -211,10 +228,12 @@ buildlibrary libfrontend.a \
    src/fe-rpm.cc \
    src/fe-scptoflux.cc \
    src/fe-seek.cc \
-    src/fe-testbulktransport.cc \
+    src/fe-testbandwidth.cc \
    src/fe-testvoltages.cc \
    src/fe-upgradefluxfile.cc \
+    src/fe-writeamiga.cc \
    src/fe-writebrother.cc \
+    src/fe-writeibm.cc \
    src/fe-writeflux.cc \
    src/fe-writetestpattern.cc \
    src/fluxengine.cc \
@@ -251,3 +270,4 @@ runtest fluxpattern-test    tests/fluxpattern.cc
 runtest fmmfm-test          tests/fmmfm.cc
 runtest kryoflux-test       tests/kryoflux.cc
 runtest ldbs-test           tests/ldbs.cc
+runtest amiga-test          tests/amiga.cc
--- a/protocol.h
+++ b/protocol.h
@@ -3,7 +3,7 @@

 enum 
 {
-    FLUXENGINE_VERSION = 8,
+    FLUXENGINE_VERSION = 12,

    FLUXENGINE_VID = 0x1209,
    FLUXENGINE_PID = 0x6e00,
@@ -50,8 +50,10 @@ enum
    F_FRAME_SEEK_REPLY,           /* any_frame */
    F_FRAME_MEASURE_SPEED_CMD,    /* any_frame */
    F_FRAME_MEASURE_SPEED_REPLY,  /* speed_frame */
-    F_FRAME_BULK_TEST_CMD,        /* any_frame */
-    F_FRAME_BULK_TEST_REPLY,      /* any_frame */
+    F_FRAME_BULK_WRITE_TEST_CMD,   /* any_frame */
+    F_FRAME_BULK_WRITE_TEST_REPLY, /* any_frame */
+    F_FRAME_BULK_READ_TEST_CMD,   /* any_frame */
+    F_FRAME_BULK_READ_TEST_REPLY, /* any_frame */
    F_FRAME_READ_CMD,             /* read_frame */
    F_FRAME_READ_REPLY,           /* any_frame */
    F_FRAME_WRITE_CMD,            /* write_frame */
@@ -75,6 +77,13 @@ enum
    F_ERROR_INTERNAL,
 };

+enum
+{
+    F_INDEX_REAL,
+    F_INDEX_300,
+    F_INDEX_360
+};
+
 enum
 {
    F_OP_PULSE = 0x80,
@@ -126,7 +135,8 @@ struct read_frame
 {
    struct frame_header f;
    uint8_t side;
-    uint8_t revolutions;
+    uint8_t synced;
+    uint16_t milliseconds;
 };

 struct write_frame
@@ -145,7 +155,9 @@ struct erase_frame
 struct set_drive_frame
 {
    struct frame_header f;
-    uint8_t drive_flags;
+    uint8_t drive;
+    uint8_t high_density;
+    uint8_t index_mode;
 };

 struct voltages
--- a/src/fe-readaeslanier.cc
+++ b/src/fe-readaeslanier.cc
@@ -12,11 +12,6 @@

 static FlagGroup flags { &readerFlags };

-static StringFlag outputFilename(
-    { "--output", "-o" },
-    "The output image file to write to.",
-    "aeslanier.img");
-
 int mainReadAESLanier(int argc, const char* argv[])
 {
 	setReaderDefaultSource(":t=0-79:s=0");
--- a/src/fe-readibm.cc
+++ b/src/fe-readibm.cc
@@ -7,28 +7,34 @@
 #include "sector.h"
 #include "sectorset.h"
 #include "record.h"
+#include "dataspec.h"
 #include "ibm/ibm.h"
 #include "fmt/format.h"

 static FlagGroup flags { &readerFlags };

 static IntFlag sectorIdBase(
-	{ "--sector-id-base" },
+	{ "--ibm-sector-id-base" },
 	"Sector ID of the first sector.",
 	1);

 static BoolFlag ignoreSideByte(
-	{ "--ignore-side-byte" },
+	{ "--ibm-ignore-side-byte" },
 	"Ignore the side byte in the sector ID, and use the physical side instead.",
 	false);

+static RangeFlag requiredSectors(
+	{ "--ibm-required-sectors" },
+	"A comma seperated list or range of sectors which must be on each track.",
+	"");
+
 int mainReadIBM(int argc, const char* argv[])
 {
 	setReaderDefaultSource(":t=0-79:s=0-1");
 	setReaderDefaultOutput("ibm.img");
    flags.parseFlags(argc, argv);

-	IbmDecoder decoder(sectorIdBase, ignoreSideByte);
+	IbmDecoder decoder(sectorIdBase, ignoreSideByte, requiredSectors);
 	readDiskCommand(decoder);
    return 0;
 }
--- a/src/fe-rpm.cc
+++ b/src/fe-rpm.cc
@@ -2,6 +2,7 @@
 #include "flags.h"
 #include "usb.h"
 #include "dataspec.h"
+#include "protocol.h"

 static FlagGroup flags;

@@ -15,9 +16,18 @@ int mainRpm(int argc, const char* argv[])
    flags.parseFlags(argc, argv);

    FluxSpec spec(source);
-    usbSetDrive(spec.drive, false);
+    usbSetDrive(spec.drive, false, F_INDEX_REAL);
    nanoseconds_t period = usbGetRotationalPeriod();
-    std::cout << "Rotational period is " << period/1000 << " ms (" << 60e6/period << " rpm)" << std::endl;
+    if (period != 0)
+        std::cout << "Rotational period is " << period/1000000 << " ms (" << 60e9/period << " rpm)" << std::endl;
+    else
+    {
+        std::cout << "No index pulses detected from the disk. Common causes of this are:\n"
+                     "  - no drive is connected\n"
+                     "  - the drive doesn't have an index sensor (e.g. BBC Micro drives)\n"
+                     "  - the disk has no index holes (e.g. reversed flippy disks)\n"
+                     "  - (most common) no disk is inserted in the drive!\n";
+    }

    return 0;
 }
--- a/src/fe-seek.cc
+++ b/src/fe-seek.cc
@@ -1,6 +1,7 @@
 #include "globals.h"
 #include "flags.h"
 #include "usb.h"
+#include "protocol.h"

 static FlagGroup flags;

@@ -18,7 +19,7 @@ int mainSeek(int argc, const char* argv[])
 {
    flags.parseFlags(argc, argv);

-    usbSetDrive(drive, false);
+    usbSetDrive(drive, false, F_INDEX_REAL);
    usbSeek(track);
    return 0;
 }
--- a/src/fe-testbulktransport.cc
+++ b/src/fe-testbulktransport.cc
@@ -4,9 +4,10 @@

 static FlagGroup flags;

-int mainTestBulkTransport(int argc, const char* argv[])
+int mainTestBandwidth(int argc, const char* argv[])
 {
    flags.parseFlags(argc, argv);
-    usbTestBulkTransport();
+    usbTestBulkWrite();
+    usbTestBulkRead();
    return 0;
 }
--- a/src/fe-writeamiga.cc
+++ b/src/fe-writeamiga.cc
@@ -0,0 +1,23 @@
+#include "globals.h"
+#include "flags.h"
+#include "decoders/decoders.h"
+#include "amiga/amiga.h"
+#include "writer.h"
+#include "fmt/format.h"
+#include "image.h"
+#include <fstream>
+
+static FlagGroup flags { &writerFlags, &amigaEncoderFlags };
+
+int mainWriteAmiga(int argc, const char* argv[])
+{
+    setWriterDefaultInput(":c=80:h=2:s=11:b=512");
+    setWriterDefaultDest(":d=0:t=0-79:s=0-1");
+    flags.parseFlags(argc, argv);
+
+	AmigaEncoder encoder;
+	writeDiskCommand(encoder);
+
+    return 0;
+}
+
--- a/src/fe-writeibm.cc
+++ b/src/fe-writeibm.cc
@@ -0,0 +1,139 @@
+#include "globals.h"
+#include "flags.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "ibm/ibm.h"
+#include "writer.h"
+#include "fmt/format.h"
+#include "image.h"
+#include <fstream>
+
+static FlagGroup flags { &writerFlags };
+
+static IntFlag trackLengthMs(
+	{ "--ibm-track-length-ms" },
+	"Length of a track in milliseconds.",
+	0);
+
+static IntFlag sectorSize(
+	{ "--ibm-sector-size" },
+	"Size of the sectors to write (bytes).",
+	0);
+
+static BoolFlag emitIam(
+	{ "--ibm-emit-iam" },
+	"Whether to emit an IAM record at the start of the track.",
+	false);
+
+static IntFlag startSectorId(
+	{ "--ibm-start-sector-id" },
+	"Sector ID of first sector.",
+	1);
+
+static IntFlag clockRateKhz(
+	{ "--ibm-clock-rate-khz" },
+	"Clock rate of data to write.",
+	0);
+
+static BoolFlag useFm(
+	{ "--ibm-use-fm" },
+	"Write in FM mode, rather than MFM.",
+	false);
+
+static HexIntFlag idamByte(
+	{ "--ibm-idam-byte" },
+	"16-bit RAW bit pattern to use for the IDAM ID byte",
+	0);
+
+static HexIntFlag damByte(
+	{ "--ibm-dam-byte" },
+	"16-bit RAW bit pattern to use for the DAM ID byte",
+	0);
+
+static IntFlag gap0(
+	{ "--ibm-gap0-bytes" },
+	"Size of gap 0 (the pre-index gap)",
+	0);
+
+static IntFlag gap1(
+	{ "--ibm-gap1-bytes" },
+	"Size of gap 1 (the post-index gap).",
+	0);
+
+static IntFlag gap2(
+	{ "--ibm-gap2-bytes" },
+	"Size of gap 2 (the post-ID gap).",
+	0);
+
+static IntFlag gap3(
+	{ "--ibm-gap3-bytes" },
+	"Size of gap 3 (the post-data or format gap).",
+	0);
+
+static StringFlag sectorSkew(
+	{ "--ibm-sector-skew" },
+	"Order to emit sectors.",
+	"");
+
+static ActionFlag preset1440(
+	{ "--ibm-preset-1440" },
+	"Preset parameters to a 3.5\" 1440kB disk.",
+	[] {
+		setWriterDefaultInput(":c=80:h=2:s=18:b=512");
+		trackLengthMs.setDefaultValue(200);
+		sectorSize.setDefaultValue(512);
+		emitIam.setDefaultValue(true);
+		clockRateKhz.setDefaultValue(500);
+		idamByte.setDefaultValue(0x5554);
+		damByte.setDefaultValue(0x5545);
+		gap0.setDefaultValue(80);
+		gap1.setDefaultValue(50);
+		gap2.setDefaultValue(22);
+		gap3.setDefaultValue(108);
+		sectorSkew.setDefaultValue("0123456789abcdefgh");
+	});
+
+static ActionFlag preset720(
+	{ "--ibm-preset-720" },
+	"Preset parameters to a 3.5\" 720kB disk.",
+	[] {
+		setWriterDefaultInput(":c=80:h=2:s=9:b=512");
+		trackLengthMs.setDefaultValue(200);
+		sectorSize.setDefaultValue(512);
+		emitIam.setDefaultValue(true);
+		clockRateKhz.setDefaultValue(250);
+		idamByte.setDefaultValue(0x5554);
+		damByte.setDefaultValue(0x5545);
+		gap0.setDefaultValue(80);
+		gap1.setDefaultValue(50);
+		gap2.setDefaultValue(22);
+		gap3.setDefaultValue(80);
+		sectorSkew.setDefaultValue("012345678");
+	});
+
+int mainWriteIbm(int argc, const char* argv[])
+{
+	setWriterDefaultDest(":d=0:t=0-79:s=0-1");
+    flags.parseFlags(argc, argv);
+
+	IbmParameters parameters;
+	parameters.trackLengthMs = trackLengthMs;
+	parameters.sectorSize = sectorSize;
+	parameters.emitIam = emitIam;
+	parameters.startSectorId = startSectorId;
+	parameters.clockRateKhz = clockRateKhz;
+	parameters.useFm = useFm;
+	parameters.idamByte = idamByte;
+	parameters.damByte = damByte;
+	parameters.gap0 = gap0;
+	parameters.gap1 = gap1;
+	parameters.gap2 = gap2;
+	parameters.gap3 = gap3;
+	parameters.sectorSkew = sectorSkew;
+
+	IbmEncoder encoder(parameters);
+	writeDiskCommand(encoder);
+
+    return 0;
+}
+
--- a/src/fluxengine.cc
+++ b/src/fluxengine.cc
@@ -26,10 +26,12 @@ extern command_cb mainReadVictor9K;
 extern command_cb mainReadZilogMCZ;
 extern command_cb mainRpm;
 extern command_cb mainSeek;
-extern command_cb mainTestBulkTransport;
+extern command_cb mainTestBandwidth;
 extern command_cb mainTestVoltages;
 extern command_cb mainUpgradeFluxFile;
+extern command_cb mainWriteAmiga;
 extern command_cb mainWriteBrother;
+extern command_cb mainWriteIbm;
 extern command_cb mainWriteFlux;
 extern command_cb mainWriteTestPattern;

@@ -81,7 +83,9 @@ static std::vector<Command> readables =

 static std::vector<Command> writeables =
 {
+    { "amiga",         mainWriteAmiga,    "Writes Amiga disks.", },
    { "brother",       mainWriteBrother,  "Writes 120kB and 240kB Brother word processor disks.", },
+    { "ibm",           mainWriteIbm,      "Writes the ubiquitous IBM format disks.", },
 };

 static std::vector<Command> convertables =
@@ -95,8 +99,8 @@ static std::vector<Command> convertables =

 static std::vector<Command> testables =
 {
-    { "bulktransport", mainTestBulkTransport, "Measures your USB bandwidth.", },
-    { "voltages",      mainTestVoltages,      "Measures the FDD bus voltages.", },
+    { "bandwidth",     mainTestBandwidth, "Measures your USB bandwidth.", },
+    { "voltages",      mainTestVoltages,  "Measures the FDD bus voltages.", },
 };

 static void extendedHelp(std::vector<Command>& subcommands, const std::string& command)
--- a/tests/amiga.cc
+++ b/tests/amiga.cc
@@ -0,0 +1,38 @@
+#include "globals.h"
+#include "bytes.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "arch/amiga/amiga.h"
+#include <assert.h>
+
+static const Bytes testData = {
+    0x52, /* 0101 0010 */
+    0xff, /* 1111 1111 */
+    0x4a, /* 0100 1010 */
+    0x22, /* 0010 0010 */
+};
+static const Bytes testDataInterleaved = {
+    0x1f, /* 0001 1111 */
+    0x35, /* 0011 0101 */
+    0xcf, /* 1100 1111 */
+    0x80, /* 1000 0000 */
+};
+
+static void testInterleave(void)
+{
+    Bytes interleaved = amigaInterleave(testData);
+    assert(interleaved == testDataInterleaved);
+}
+
+static void testDeinterleave(void)
+{
+    Bytes deinterleaved = amigaDeinterleave(testDataInterleaved);
+    assert(deinterleaved == testData);
+}
+
+int main(int argc, const char* argv[])
+{
+    testDeinterleave();
+    testInterleave();
+    return 0;
+}
--- a/tests/bytes.cc
+++ b/tests/bytes.cc
@@ -115,6 +115,15 @@ static void test_slice()
    assert((bs == Bytes{ 0, 0 }));
 }

+static void test_tobits()
+{
+	Bytes b = {1, 2};
+	assert(b.toBits() == (std::vector<bool>{
+		false, false, false, false, false, false, false, true,
+		false, false, false, false, false, false, true, false
+	}));
+}
+
 int main(int argc, const char* argv[])
 {
    test_bounds();
@@ -123,5 +132,6 @@ int main(int argc, const char* argv[])
    test_reads();
    test_writes();
    test_slice();
+	test_tobits();
    return 0;
 }
--- a/tests/crunch.cc
+++ b/tests/crunch.cc
@@ -7,7 +7,7 @@ static uint8_t outputbuffer[64];
 static void test_crunch()
 {
    crunch_state_t cs = {};
-    Bytes inputdata = { 0x01, 0x7f, 0x80, 0x81, 0x01 };
+    Bytes inputdata = { 0x01, 0x7f, 0x80, 0x05, 0x80, 0x81, 0x01 };
    cs.inputptr = inputdata.begin();
    cs.inputlen = inputdata.size();
    cs.outputptr = outputbuffer;
@@ -16,13 +16,13 @@ static void test_crunch()
    donecrunch(&cs);
    Bytes outputdata(outputbuffer, cs.outputptr - outputbuffer);

-    assert((outputdata == Bytes{ 0x01, 0x7f, 0xb0, 0x10 }));
+    assert((outputdata == Bytes{ 0x01, 0x7f, 0xc5, 0x94, 0x04 }));
 }

 static void test_uncrunch()
 {
    crunch_state_t cs = {};
-    Bytes inputdata = { 0x01, 0x7f, 0xb0, 0x10 };
+    Bytes inputdata = { 0x01, 0x7f, 0xc5, 0x94, 0x04 };
    cs.inputptr = inputdata.begin();
    cs.inputlen = inputdata.size();
    cs.outputptr = outputbuffer;
@@ -31,7 +31,7 @@ static void test_uncrunch()
    doneuncrunch(&cs);
    Bytes outputdata(outputbuffer, cs.outputptr - outputbuffer);

-    assert((outputdata == Bytes { 0x01, 0x7f, 0x80, 0x81, 0x01 }));
+    assert((outputdata == Bytes { 0x01, 0x7f, 0x80, 0x05, 0x80, 0x81, 0x01 }));
 }

 int main(int argc, const char* argv[])
--- a/tests/dataspec.cc
+++ b/tests/dataspec.cc
@@ -13,6 +13,28 @@ static void test_split(void)
        == std::vector<std::string>{"", "2", ""}));
    assert((DataSpec::split("2", ",")
        == std::vector<std::string>{"2"}));
+    assert((DataSpec::split("", ",")
+        == std::vector<std::string>()));
+}
+
+static void test_parserange(void)
+{
+    assert(DataSpec::parseRange("")
+        == std::set<unsigned>());
+    assert(DataSpec::parseRange("1")
+        == std::set<unsigned>({1}));
+    assert(DataSpec::parseRange("1,3,5")
+        == std::set<unsigned>({1, 3, 5}));
+    assert(DataSpec::parseRange("1,1,1")
+        == std::set<unsigned>({1}));
+    assert(DataSpec::parseRange("2-3")
+        == std::set<unsigned>({2, 3}));
+    assert(DataSpec::parseRange("2+3")
+        == std::set<unsigned>({2, 3, 4}));
+    assert(DataSpec::parseRange("2+3x2")
+        == std::set<unsigned>({2, 4}));
+    assert(DataSpec::parseRange("9,2+3x2")
+        == std::set<unsigned>({2, 4, 9}));
 }

 static void test_parsemod(void)
@@ -104,6 +126,7 @@ static void test_imagespec(void)
 int main(int argc, const char* argv[])
 {
    test_split();
+	test_parserange();
    test_parsemod();
    test_fluxspec();
    test_imagespec();
--- a/tests/fmmfm.cc
+++ b/tests/fmmfm.cc
@@ -2,7 +2,7 @@
 #include "decoders/decoders.h"
 #include <assert.h>

-int main(int argc, const char* argv[])
+static void testDecode(void)
 {
    assert(decodeFmMfm(
        std::vector<bool>{
@@ -36,6 +36,100 @@ int main(int argc, const char* argv[])
            true, false,
        }
    ) == Bytes{ 0x80 });
+}

+static std::vector<bool> wrappedEncodeMfm(const Bytes& bytes)
+{
+	std::vector<bool> bits(16);
+	unsigned cursor = 0;
+	bool lastBit = false;
+	encodeMfm(bits, cursor, bytes, lastBit);
+	return bits;
+}
+
+static std::vector<bool> wrappedEncodeFm(const Bytes& bytes)
+{
+	std::vector<bool> bits(16);
+	unsigned cursor = 0;
+	encodeFm(bits, cursor, bytes);
+	return bits;
+}
+
+static void testEncodeMfm(void)
+{
+	assert(wrappedEncodeMfm(Bytes{ 0xa1 })
+		== (std::vector<bool>{
+			false, true,
+			false, false,
+			false, true,
+			false, false,
+			true, false,
+			true, false,
+			true, false,
+			false, true
+		})
+	);
+
+	assert(wrappedEncodeMfm(Bytes{ 0xc2 })
+		== (std::vector<bool>{
+			false, true,
+			false, true,
+			false, false,
+			true, false,
+			true, false,
+			true, false,
+			false, true,
+			false, false
+		})
+	);
+
+	assert(wrappedEncodeMfm(Bytes{ 0xb0 })
+		== (std::vector<bool>{
+			false, true,
+			false, false,
+			false, true,
+			false, true,
+			false, false,
+			true, false,
+			true, false,
+			true, false,
+		})
+	);
+}
+
+static void testEncodeFm(void)
+{
+	assert(wrappedEncodeFm(Bytes{ 0x00 })
+		== (std::vector<bool>{
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, false
+		})
+	);
+
+	assert(wrappedEncodeFm(Bytes{ 0x81 })
+		== (std::vector<bool>{
+            true, true,
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, false,
+            true, true
+		})
+	);
+}
+
+int main(int argc, const char* argv[])
+{
+	testDecode();
+	testEncodeMfm();
+	testEncodeFm();
    return 0;
 }
Author	SHA1	Message	Date
David Given	a401173f6d	Teach the Amiga decoder how many sectors to expect on each track.	2020-03-09 12:54:29 +00:00
David Given	ce76dc4279	Merge pull request #140 from davidgiven/sectors Fix a couple of annoying but minor issues	2020-02-28 00:08:11 +01:00
David Given	1025bd857b	Don't crashloop if the USB's not connected, as it causes the drives to be constantly reprobed (which runs the motor).	2020-02-27 22:32:27 +01:00
David Given	025802b2d0	Count required sectors correctly on mac disks.	2020-02-27 22:30:05 +01:00
David Given	adbcb2cd31	Merge pull request #139 from davidgiven/sectors Add support for required sectors, drive autodetection and fix homing on 8" drives.	2020-02-24 21:55:27 +01:00
David Given	c47a563790	Don't seek to track -1 on homing (it appears to upset 8" drives). Detect which drives are present, so that if only a single drive is attached then it's always track 0, regardless of which connector it's on.	2020-02-24 21:47:40 +01:00
David Given	04c09d1a5b	Hopefully, fix the problem where ^Cing a job gets the board in a confused state.	2020-02-21 22:16:20 +01:00
David Given	323da8272a	Hopefully add support for giving the reader a set of required sectors, so if one is missing then we can tell and the track can be reread.	2020-02-21 22:14:44 +01:00
David Given	38700c79fc	Merge pull request #137 from davidgiven/docs Update documentation.	2020-02-20 00:32:19 +01:00
David Given	d504d1890a	Remember to document that you need a FDD cable.	2020-02-20 00:30:17 +01:00
David Given	d53e757cfb	Rework some of the Brother documentation.	2020-02-20 00:25:55 +01:00
David Given	4983239458	Rework the hardware and software documentation.	2020-02-20 00:17:16 +01:00
David Given	376985828a	Add the ditaa pinout table.	2020-02-19 23:49:43 +01:00
David Given	dce0a26820	Merge pull request #136 from davidgiven/ibm Finally add write support for IBM disks.	2020-02-18 23:20:57 +01:00
David Given	14e0a67e7d	IBM write support gets the much vaunted unicorn.	2020-02-18 23:10:09 +01:00
David Given	1656947764	Disable write precompensation, as it actually seems to make things worse.	2020-02-18 22:49:12 +01:00
David Given	647862cdbd	Update the firmware for the new cruncher.	2020-02-18 22:13:41 +01:00
David Given	4a8d83838c	Add IBM write support documentation.	2020-02-18 22:12:56 +01:00
David Given	8acf8e181d	Rework the crunch encoding to be, hopefully, smaller and use less bandwidth for HD disks.	2020-02-18 21:37:32 +01:00
David Given	2df9920209	Rename test bulktransport to test bandwidth; avoid watchdog failures while the bandwidth test is running.	2020-02-18 19:12:52 +01:00
David Given	1a6c6b5420	The bandwidth tester now tests bandwidth in both directions. It looks like my default USB port only gets about 500kB/s write bandwidth. However, when plugged into a port with 850kB/s, I still get underrun errors...	2020-02-17 23:58:40 +01:00
David Given	edc56d44d6	Non-functioning archive checkin: You can only have 120-odd DMA buffers, so my last 'fix' was in fact non-functional.	2020-02-17 23:28:40 +01:00
David Given	ef4eff0195	So writing now works, but only if USB DMA is enabled. But that breaks reading. I've worked round this in a simple but brute force manner and it now looks as if reading and writing work, more or less. There does still seem to be the odd bad sector when writing 1440kB disks.	2020-02-17 21:41:01 +01:00
David Given	df8d45bf66	Rework the output fifo to be a bit more correct about the sync signals, which in turn allows the sequencer to lose less time --- this gets the effective clock rate down to about 1.01us. However we still seem to lose the last sector on 18-sector disks and there are some disk reads so something is still wrong.	2020-02-17 00:13:13 +01:00
David Given	89a27619ff	Correctly propagate MFM encoding state.	2020-02-15 21:47:01 +01:00
David Given	387a86969a	Some verilog optimisations which shave off a few p-terms.	2020-02-15 12:15:51 +01:00
David Given	acb5059d17	Rewrite the sampler again to, hopefully, be more stable and not lose ticks. Luckily, we have just enough space in the FPGA to use an actual logic counter, which simplifies things hugely.	2020-02-15 12:09:19 +01:00
David Given	a4002d2617	Fix a few encoder issues; but while 720kB disks work fine in a real machine, 1440kB disks don't.	2020-02-14 22:47:15 +01:00
David Given	a63a90bbd0	Only attempt to remove the old file on overwrite if it actually exists.	2020-02-14 22:30:46 +01:00
David Given	d25f96dd24	The IBM encoder now works well enough that my USB floppy drive thinks the disk is formatted... but has trouble reading sectors above about 1000. Also remember that encoding MFM needs to keep one bit of state at all times.	2020-02-14 00:06:51 +01:00
David Given	e8febe6508	Allow converting Bytes to bits, and slicing until the end of an object.	2020-02-14 00:04:31 +01:00
David Given	ad3a930c6a	Do the boilerplate of the IBM encoder.	2020-02-09 23:56:20 +01:00
David Given	be41c1de76	You now need to explicitly specify whether flux files get merged or overwritten, because the old behaviour was weird. Reader uses SqliteFluxSink to write flux files, rather than raw database accesses.	2020-02-08 12:41:50 +01:00
David Given	d528978667	Merge pull request #135 from davidgiven/docs Update docs.	2020-02-08 11:53:31 +01:00
David Given	827fcf69d2	Another typo fix.	2020-02-08 11:52:39 +01:00
David Given	711ff545e0	Typo fix.	2020-02-08 11:51:19 +01:00
David Given	5befa31050	Document the GreaseWeazle.	2020-02-08 11:50:09 +01:00
David Given	8e5c2d0ebb	Merge from trunk.	2020-02-08 11:35:31 +01:00
David Given	f95fceeb3d	Finally document IBM disks.	2020-02-08 11:34:57 +01:00
David Given	003b20dbf0	Merge pull request #133 from davidgiven/fixing Display RPM values correctly	2020-01-29 00:52:04 +01:00
David Given	cd9bbaa4b6	Merge from trunk.	2020-01-29 00:42:06 +01:00
David Given	71e622bf72	Fix the fe-rpm RPM display, which didn't get updated when we switched to nanoseconds internally. Fixes #132	2020-01-29 00:41:58 +01:00
David Given	2a065a08df	Remember to ship brother240tool with Windows.	2020-01-28 00:45:04 +01:00
David Given	6087228378	Merge pull request #131 from davidgiven/fixing Debug builds are now debuggable.	2020-01-28 00:40:39 +01:00
David Given	efd74e0d7b	Stop trying to make Github CI on Windows work. It just doesn't seem to be running mingw via ninja.	2020-01-28 00:33:30 +01:00
David Given	b68a9dcc4f	Looks like there is no pacman.exe in the image, so we have to go with the additional download.	2020-01-28 00:30:48 +01:00
David Given	008855daa9	...more...	2020-01-28 00:27:21 +01:00
David Given	7a9d36de2a	...	2020-01-28 00:23:59 +01:00
David Given	c56e982c9a	...	2020-01-28 00:22:18 +01:00
David Given	002cc171a2	More sigh.	2020-01-28 00:19:39 +01:00
David Given	32e721b47a	Sigh.	2020-01-28 00:15:31 +01:00
David Given	1e82f697a9	Temporarily disable AppVeyor to prevent spurious builds.	2020-01-28 00:14:45 +01:00
David Given	fa09631e32	More exploration.	2020-01-28 00:13:38 +01:00
David Given	e06436ce1e	Okay, that's not working. What's available?	2020-01-28 00:05:23 +01:00
David Given	b2f443e1ad	Let's try this, but with the right path.	2020-01-27 23:57:48 +01:00
David Given	2e07be0cf7	Let's try this instead.	2020-01-27 23:56:55 +01:00
David Given	bf0b14d094	Okay, changing the path didn't help.	2020-01-27 23:51:22 +01:00
David Given	c9f5803194	The system is installing, but it's not finding mingw32.	2020-01-27 23:47:30 +01:00
David Given	5293560c02	Try enabling the windows CI build again.	2020-01-27 23:41:03 +01:00
David Given	c49823aa9d	Now the optimised binaries are optimised and the debug binaries aren't.	2020-01-27 23:36:33 +01:00
David Given	c4ef4882ae	Merge pull request #130 from davidgiven/fixing Fix a nasty firmware memory corruption bug	2020-01-27 23:15:20 +01:00
David Given	a8eca06cf0	Don't hang if we hit the end of stream while waiting for a data record.	2020-01-27 23:09:29 +01:00
David Given	065257b5aa	Remove stray tracing.	2020-01-27 23:09:07 +01:00
David Given	29bdfc043a	Allow fractional revolutions and non-synced reading. Find more things which need fixing in the firmware sampler.	2020-01-27 22:52:25 +01:00
David Given	933ffe7ab4	Find and attempt to fix a memory corruption error when sampling --- if the next fragment arrives from the sampler before usbbuffer has finished being transmitted via USB, it'll get overwritten. I've disabled DMA USB to make the code easier to understand and made sure that we flush things more rigorously. This may help the weird pipe errors, too.	2020-01-27 21:40:27 +01:00
David Given	e517f28563	Merge pull request #129 from davidgiven/fixing Make decoding more robust	2020-01-27 01:21:40 +01:00
David Given	91ffcf59c3	When reading data records, retry if we get an UNKNOWN record to work the occasional false positive (which happens now and again with MFM).	2020-01-27 01:15:14 +01:00
David Given	51c618f325	Merge from trunk.	2020-01-26 23:53:29 +01:00
David Given	9dc1067032	Add --dump-sectors. Sector positions are recorded correctly.	2020-01-26 18:30:35 +01:00
David Given	9e75dc3af1	Merge pull request #127 from davidgiven/fixing Fix an issue where HD IBM disks can't be read	2020-01-26 18:06:15 +01:00
David Given	efa4c933b3	Made the MFM marker byte detection a lot more robust --- prevents false positives; it looks like the new sampler is producing a little bit of wobble which randomly spoofs a marker byte now and again. This prevents this from happening (so far).	2020-01-26 17:58:08 +01:00
David Given	6af80d1e5e	Improve some messaging. A data record is always pushed, even if it's empty (to help debugging).	2020-01-26 17:49:12 +01:00
David Given	0c48897814	Add a minimum clock threshold.	2020-01-26 17:48:33 +01:00
David Given	60e5e35947	Merge pull request #124 from davidgiven/tweaks Several index pulse fixes	2020-01-12 01:42:39 +01:00
David Given	86c4e959ca	Mac error fix.	2020-01-12 01:38:19 +01:00
David Given	b0c675c589	Improved error messages when using fe-rpm and it doesn't work.	2020-01-12 01:34:12 +01:00
David Given	d77841c3b7	Add the ability to fake the index pulse source, allowing old drives to be used with FluxEngine.	2020-01-12 01:23:47 +01:00
David Given	4ed1fb6bac	Document the extra index pulses.	2020-01-10 21:23:33 +01:00
David Given	bcc9e9d9a5	Bump the protocol number (I forgot last time I changed the protocol).	2020-01-10 21:04:33 +01:00
David Given	ec327e25a4	Merge pull request #121 from davidgiven/amiga Add support for writing Amiga disks.	2019-12-14 21:55:00 +01:00
David Given	d0ed5b32f7	Add support for 528-byte sectors. Adjust the post-index gap to (try?) and fit all the data in one revolution. I think my write clock is a bit slow.	2019-12-14 21:49:31 +01:00
David Given	7c66e1b0d4	Don't recalibrate after drive errors --- it's really annoying and I don't think it helps.	2019-12-14 21:43:48 +01:00
David Given	4475e9f085	Increase the default bit-error-threshold to 0.4, because that's the value I almost always end up using.	2019-12-14 21:33:39 +01:00
David Given	5c9639ec5a	Document the Amiga write support.	2019-12-14 21:15:47 +01:00
David Given	792cc88192	The Amiga writer now generates valid flux files --- but it looks like the writer's broken (both the Amiga and the Brother have failed).	2019-12-14 20:44:48 +01:00
David Given	5a0fb2761a	Update OSX build instructions.	2019-12-14 11:37:43 +01:00
David Given	ef4581ed39	Merge from trunk.	2019-12-13 23:59:03 +01:00
David Given	d2f8c27cb6	Add checksum routine.	2019-12-01 09:11:36 +01:00
David Given	eaa3c57425	Non-functional boilerplate of Amiga write support.	2019-12-01 09:07:43 +01:00
David Given	549f12a2ab	Merge from master.	2019-12-01 08:36:44 +01:00
David Given	aea254fbe7	Made the AES Lanier reader work again.	2019-12-01 08:35:25 +01:00