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

issue.
Merge pull request #299 from davidgiven/greaseweazle
2025-10-24 11:11:02 -07:00 · 2021-07-09 21:25:58 +01:00 · 2021-07-08 10:08:59 +01:00 · 2021-07-08 10:50:31 +02:00 · 2021-07-08 10:49:57 +02:00 · 2021-07-06 23:05:45 +01:00
496 changed files with 80973 additions and 4243 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -1,42 +0,0 @@
-version: '{branch}.{build}'
-clone_depth: 1
-skip_tags: true
-image: Visual Studio 2019
-
-environment:
-  MSYSTEM: MINGW32
-
-init:
-  - git config --global core.autocrlf input
-
-install:
-  - set PATH=c:\msys64\mingw32\bin;c:\msys64\usr\bin;c:\msys64\bin;%PATH%
-  - echo %PATH%
-  - pacman -S --noconfirm --needed make ninja mingw-w64-i686-libusb mingw-w64-i686-sqlite3 mingw-w64-i686-zlib mingw-w64-i686-gcc zip
-
-build_script:
-  - make
-  - zip -9 fluxengine.zip fluxengine.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
-
-artifacts:
-  - path: fluxengine.zip
-    name: fluxengine.zip
-
-deploy:
-  release: FluxEngine Windows client version $(APPVEYOR_BUILD_NUMBER)
-  description: >
-    This is an automatically built version of the FluxEngine Windows client
-    which is generated whenever a significant checkin has happened. It's had
-    no testing whatsoever.
-
-    To use, download it, put it somewhere, and then run it from a cmd window
-    or other command line shell.
-  provider: GitHub
-  auth_token:
-    secure: dfJjj7fWCoDUz+Ni11OcNPB/U3TNJFwNA2AsL++ChFjniUsZLlC6SDWHiL/t4FZo
-  artifact: fluxengine.zip
-  draft: false
-  prerelease: false
-  on:
-    branch: master
-
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -10,32 +10,45 @@ jobs:
      with:
        fetch-depth: 1
    - name: apt
-      run: sudo apt update && sudo apt install libusb-1.0-0-dev libsqlite3-dev ninja-build
+      run: sudo apt update && sudo apt install libusb-1.0-0-dev libsqlite3-dev ninja-build protobuf-compiler
    - name: make
      run: make

  build-macos:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
      with:
        fetch-depth: 1
    - name: brew
-      run: brew install sqlite pkg-config libusb ninja
+      run: brew install sqlite pkg-config libusb ninja protobuf
    - name: make
      run: make

-#  build-windows:
-#    runs-on: windows-latest
-#    steps:
-#    - uses: numworks/setup-msys2@v1
-#      with:
-#        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: build
-#      run: |
-#        msys2do make
+  build-windows:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+    - uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        msystem: MINGW32
+        install: >-
+          make
+          ninja
+          mingw-w64-i686-libusb
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-zlib
+          mingw-w64-i686-gcc
+          zip
+          mingw-w64-i686-protobuf
+          vim
+    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 1
+    - name: build
+      run: |
+        make

--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -0,0 +1,63 @@
+name: Autorelease
+
+on:
+  push:
+    branches:
+      - "master"
+
+jobs:
+  dev-release:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+    - uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        msystem: MINGW32
+        install: >-
+          make
+          ninja
+          mingw-w64-i686-libusb
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-zlib
+          mingw-w64-i686-gcc
+          zip
+          mingw-w64-i686-protobuf
+          vim
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 1
+    - name: build
+      run: |
+        make
+    - name: zip
+      run: |
+        zip -9 fluxengine.zip fluxengine.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
+    - name: date
+      run: |
+        echo "RELEASE_DATE=$(date --rfc-3339=date)" >> ${GITHUB_ENV}
+    - name: tag
+      uses: EndBug/latest-tag@latest
+      with:
+        tag-name: dev
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - name: delete-old-assets
+      uses: mknejp/delete-release-assets@v1
+      with:
+        token: ${{ github.token }}
+        tag: dev
+        assets: | 
+          fluxengine.zip
+        fail-if-no-assets: false
+    - name: release
+      uses: softprops/action-gh-release@v1
+      with:
+        name: Development build ${{ env.RELEASE_DATE }}
+        files: |
+          fluxengine.zip
+        tag_name: dev
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
+++ b/FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
@@ -1,246 +1,246 @@
-:400000000080002011000000CD0F0000CD0F0000064A08B5136843F020031360044B1A6803F53F5302331A6000F0EEFFE8460040FA46004010B5054C237833B9044B13B181
-:400040000448AFF300800123237010BD6881FF1F0000000058380000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF00000000B1
-:400080006C81FF1F58380000C880FF1F000000000A4A0B4B116801310B40002BBEBF03F1FF3363F03F030133136011685368994202BF024B01221A72704700BF8881FF1F2C
-:4000C0003F0000800A4A0B4B516801310B40002BBEBF03F1FF3363F03F030133536051681368994202BF024B01221A72704700BF8881FF1F3F000080024B012200205A7293
-:4001000002F028B98881FF1F10B5C4B2204601F03DF90128FAD110BD08B572B60F4B0F49DA680132DA601A690132C82A08BF00221A615A6918690132A72A08BF00224A610E
-:400140005B69002B0CBF02230023002814BF184643F0010002F066FE62B608BD8881FF1F38B50446C5B2284602F096F8062002F0B3FA44F00200C0B202F08EF8062002F0FD
-:40018000ABFA284602F088F8BDE83840062002F08DBA10B5642402F079F828B9FFF7E0FF013CF8D1204610BD012010BD70B5C4B2054620460E4601F0E9F8012805D02046DB
-:4001C00001F002FA2846FFF79FFF204601F0E6F8314605460246204601F0A2F9204601F0D5F80028FAD1284670BD000038B5044D0024285D013402F01FFA402CF9D138BDDB
-:40020000A081FF1F08B502F039FC002002F042FC02F054FC02F05EFC80B208BD10B50446012002F051F8642002F040FAFFF7EAFF2080002002F048F8642002F037FAFFF73D
-:40024000E1FF608010BD08B502F044FD002002F04DFD02F05FFD02F069FD80B208BD10B50446FFF796FF322002F020FAFFF7EBFF20800120FFF774FF322002F017FAFFF7BB
-:40028000E2FF608010BD0FB400B593B014AB53F8042B402102A8019302F0C6FE02A802F060F802F06AF813B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF7E3
-:4002C00023FF62782146BDE81040042001F0B6B86C38000007B50023ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB000010B5074C94F8583043B1002095
-:4003000001F0BEFF002002F051FD002384F8583010BD00BF8881FF1F38B5104D837895F85B2004469A4204D0FFF7E4FF002385F85E302368C5F859302279094B1A71A37821
-:40034000002B14BF0220012002F030FDE07802F027FD2079BDE8384002F05EBD8881FF1FE181FF1F38B50D4C94F8585065B904F15900FFF7D1FF012001F082FF4FF47A70D9
-:4003800002F094F984F85E50E3682366012384F85830BDE8384002F0C7B900BF8881FF1FF8B5214C0546FFF7DDFF94F85E3003B15DB91E48FFF767FFFFF7EBFE0120002323
-:4003C00084F85E00636602F087F92A46616E1848FFF759FF144E0027636E9D4216D001F055FF00B17766636E9D4205DD0120FFF7B7FE736E013305E005DA0020FFF7B0FE0E
-:40040000736E013B736602F08FF9E5E7322002F04DF92A2DCCBF0020012002F009FDBDE8F8400448FFF72FBF8881FF1F79380000803800009D3800002DE9F04F99B062B6B3
-:4004400002F0DCF99949042002F000FA984801F029FF984802F0CCFC974801F05DFF02F0ADFB02F07FFA002002F0A0FC01F078FF0221002000F040FF904C012001F0B8F8D9
-:40048000002384F85B30FFF76DFFFFF782FE84F86800FFF72FFF012384F85B30FFF762FFFFF777FE84F86900FFF724FF844B94F86800844994F869202546002A14BF0A46EA
-:4004C0001A46002808BF19467F48FFF7DCFE0321084602F009F9264602F026F994F8583043B12A6EEB689B1A41F28832934201D9FFF700FF00F038FF18B97448FFF7C3FE30
-:4005000004E000F037FF0028F7D10BE000F02CFF10B902F009F9F9E76D48FFF7B4FE032001F052F8032000F031FF0128D4D16948FFF7F2FE68490320FFF738FE94F86A10B5
-:400540006648FFF7A0FE94F86A30023B142B00F2BA83DFE813F01500B8031E00B8032400B8034600B8036C00B803CF00B803B101B803F102B8031003B8031703B803310372
-:4005800003238DF820308DF821300E238DF822300EE394F86C00FFF703FF514B05E3FFF7E1FE00236372E068627A02F0FF0132B9EB681B1AB3F57A7FF6DD0B4608E03BB10E
-:4005C00000227272F168627A12B9EB685B1AFAE707228DF8202004228DF82120ADF82230E6E20220FFF790FD4FF000080DF1200A02F09AF84FF480790027C9EB0803DA1906
-:4006000007F80A200137402FF9D10220FFF77CFD3A465146022000F011FFB9F10109EBD108F10108B8F1400FE2D12E4B38E04FF0010A4FF000080DF1200B02F075F84FF050
-:40064000000959460120FFF7B1FD08EB090300270493049B1BF807203B44DBB2934209D08DE80C0041463B464A461F48FFF70BFE4FF0000A0137402FEBD109F10109B9F5E0
-:40068000807FDED108F10108B8F1400FD5D151461648FFF7F8FDBAF1000F00F01581144B1B8807A8ADF81C3083E200BF19010000F900000091000000C50000008881FF1F76
-:4006C000AF380000AB380000B2380000CA380000DD380000E181FF1FF281FF1FE73800005C3800005E380000F63800001239000060380000606EFFF753FE94F86C0001F0C6
-:40070000E3FD94F86C0001F0C7FD02F0F9FBB64BDFF8F0821A78002702F0FB021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F0E7FB0220FFF7E4FC91
-:40074000012141F6FF734FF48042084602F034FB84F8AA0001F056FF08F807000137402FF8D1DFF8A4A200270AF199091FFA89F80137402F14BF3A4600221AF8010F224438
-:400780000623127E402101F071FF424646F24E419AF8000001F07CFF08F14008402F1FFA88F8E5D196F86D3033B100237372637A002BFCD00023737200234FF0FF32236069
-:4007C00062602372236894F8AA002344197E01F0D1FE94F8AA0001F08FFE012194F8AA0001F062FE2368002BFCD0002398467360D6F80CA0012701F097FFE368B4F86E20C2
-:40080000CAEB030393420DD367B1042195F8AA0001F0BCFE94F8AA0001F0C8FE0028F9D107463072237AFBB96A682B689A4202D1002FE0D118E00220FFF766FC6968402271
-:4008400009EB8111022000F0F9FD6A68674B01321340002BBEBF03F1FF3363F03F03013308F101086360C6E70220277AFFF74CFC00221146022000F0E1FD0220FFF744FC15
-:40088000FFB2FFF7B3FC002001F006FD37B15848FFF7F9FC0220FFF71DFD06E0554B08A81B88ADF82030FFF703FD627A4146237A5148FFF7E8FC09E25048FFF7E4FCD4F8CD
-:4008C0006E7017F03F0701D00320FDE1686EFFF767FD95F86C0001F0F7FC95F86C0001F0DBFC012001F0F6FC02F00AFB444BDFF814811A7842F004021A701A7842F001021C
-:400900001A701A7802F0FE021A701A7802F0FE021A7002F0F9FA01214FF4804341F6FF72084601F0DDFC85F8AA0001F06BFE08F807000137402FF8D1DFF8CC90002709F1F8
-:4009400099031FFA83F804930137402F14BF3A46002219F8010F22440523127E402101F085FE414646F24B5299F8000001F090FE08F14008402F1FFA88F8E5D100274FF0AF
-:40098000FF33376098467360BB463B46D6F86E9037725FEA99190CBF4FF0010A4FF0000A2168124A01310A40002ABCBF02F1FF3262F03F026068B8BF013282426CD02BB162
-:4009C000227A002A77D16A7A002A74D12068049A059302EB8010BAF1000F17D040223F2102F0EEFA1DE000BF9E6400403F0000801C39000062380000363900004939000081
-:400A00009B650040A081FF1F9F81FF1F014601370120FFF7CBFBC7EB0903D3F1000A4AEB030A2168AD4A01310A40002ABEBF02F1FF3262F03F02013222606268059B013223
-:400A40002AD12A683F2A27D14FF00008C5F8048001F074FC85F808806B6895F8AA002B44197E01F087FD95F8AA0001F045FD012195F8AA0001F018FD85F80980637A002B3E
-:400A8000FCD04FF00008012086F8098001F062FC404601F01FFC00E023B1237A5BB96B7A4BB90123626842453FF47AAF0BF1010BD5F8048074E701F047FC012001F00AFCFB
-:400AC000002001F047FC042194F8AA0001F05EFD94F8AA0001F06AFD0028F9D196F8AA0001F0F8FC737A327A0293012303920193CDF800A05B463A4649467948FFF7C3FB59
-:400B0000BAF1000F0BD0FFF771FB002001F0C4FB237A63B17348FFF7B6FB0220D4E0B945F1D071490120FFF741FB0137F7E76F48FFF7A9FB6E4B38E094F86C0001F0C4FB59
-:400B4000606EFFF72DFC6B48FFF79DFB00236372637A002BFCD0012001F0FCFB00237372637A002BFCD0002001F0F4FB6248FFF78AFB624B19E0002084F85E00FFF710FCCF
-:400B80005F4B12E094F8683023B195F869200AB985F86C2094F869201AB113B9012385F86C305848FFF7B8FB574B1B88ADF8203008A8FFF77DFB89E0FFF79CFB02F07CF8D9
-:400BC000002002F01FF82A2701F04AFF002001F0EDFE3A46002108A802F0F2F917238DF820308DF8217001F09FFD002001F048FB002002F0DBF8C82001F058FD0DF12200DE
-:400C0000FFF70CFB0DF13600FFF729FB01F08CFD012002F0CBF8322001F048FD0DF12600FFF7FCFA0DF13A00FFF719FB012001F027FB4FF4967001F039FD01F075FD0DF13A
-:400C40002E00FFF7EBFA0DF14200FFF708FB002001F016FB4FF4967001F028FD01F064FD022002F0A3F8322001F020FD0DEB0700FFF7D4FA0DF13E00FFF7F1FA012001F05E
-:400C8000FFFA4FF4967001F011FD01F04DFD0DF13200FFF7C3FA0DF14600FFF7E0FA002001F0EEFA4FF4967001F000FD01F03CFD002002F07BF8002384F85E3001F07EFF47
-:400CC00001F050FE74E70120FFF704FB032000F07BFC0E48FFF7D7FAFFF7FEBB3F00008053390000833900003892FF1F8D3900006438000095390000A33900006638000055
-:400D000068380000F281FF1F6A380000B03900002DE9F04172B6884B61221A70A3F5F06301221A801924854A9C7092E803008033062283F8002283E80300522203F5807326
-:400D40001A707F4B7F4A1B787F4EDBB2137040F618027E4B00251A8041F2512223F8022C33784FF4F07003F0010343EA450502F0BFF8013C05F003052ED0032DF0D1744BD2
-:400D80004FF480721A8007221A70724A002548211570917002221D705D7103F8032C0422DA716D4A6D4C13786D4E43F00103137012F8013C062743F0030302F8013C2378D8
-:400DC000012243F0800323705B4B1A70654A137843F02003137000E0FEE707FB056300219A881868013502F0EBF8072DF5D15E485E4E002550F8041F05F1105303F14802D4
-:400E000021F0FF074933C9B20B4452005B0002329A4206D012F802EC12F801CC0EF807C0F5E7B0420D44E5D1514A002313609360136193614F4B504F1A68504BDFF888818F
-:400E40001A604F4B1A684F4B1A604F4A137843F002031370137C43F0020313742378A2F5863243F040032370413A137843F010031370464A464B07CA03C31A80454A28339D
-:400E8000106843F8250C127903F8212C424A07CA03C31A80414AE83B07CA03C31A80404A083307CA03C31A803E4A3F4BA2F5616203CBC2F8100EC2F8141E1378042043F009
-:400EC00008031370394B02F5AA521B783D78DBB298F80060EDB203F007010C321B091170F6B2537045F003033B7046F0030388F800302F4B48221A702E4A402313702E492B
-:400F0000937013729372082382F81F3220220A7048710A72294A0A20137001F0DDFB284B88F8006044223D70264D1A7094E80F0007C52B80BDE8F081004800405C090048A4
-:400F40000F010049A146004025420040224200400440004006400040A2430040A0430040B5390000E8460040FCFFFF478C0000480076004064090048F84600402076004024
-:400F80006809004828760040035001401C090048C051004028090048300900483C090048480900483251004054090048CF0100491D51004001590040235B0040585B0040AE
-:400FC00076580040B0430040F946004008B501F0CBFF03680C2B00D1FEE7FEE7084908B50B68084A1844821A802A01DC086005E001F0BAFF0C2303604FF0FF33184608BD0D
-:40100000CC80FF1F8893FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F8046BF7E7114653F8046C8C1AA64202D041F8045BF9E7013884
-:401040001033E5E701F096FFFFF7F6F9FEE700BF01000000843B0000124A134B10B51A60124A134C1368134843F4007313600023032B98BF54F823204FEA830188BF0E4A58
-:401080000133302B4250F3D10C4B1A780C4B1A700C4B084A1A60FFF73BFEBDE8104001F0EDB900BF0004FA050CED00E014ED00E0000000000080FF1FCD0F0000BC7600403B
-:4010C000C080FF1F08ED00E0F8B501F019FF4B4A01271378022643F001031370137C484C43F001031374474B02F5E3521F700B3203F8946C1378054603F07F031370002089
-:4011000001F0EAFA2378404A03F0F90323701378384603F0DF03137023783B43237001F0DBFA282001F0D8FA384B30461A7802F07F021A701A7802F0BF021A7023783343ED
-:40114000237001F0C9FA2378314A43F0040323700023137053702F4AFF2199540133092BFBD1284601F0D0FE0721172001F0FCFA2949172001F0EAFA0721182001F0F4FAF2
-:401180002649182001F0E2FA0721152001F0ECFA2349152001F0DAFA0721052001F0E4FA2049052001F0D2FA0721062001F0DCFA1D49062001F0CAFA0721084601F0D4FA2F
-:4011C0001A49072001F0C2FA0721082001F0CCFA1749082001F0BAFA0021162001F0C4FA1449162001F0B2FA07210C2001F0BCFABDE8F84010490C2001F0A8BAA543004076
-:40120000944300409D60004012600040F851004084600040AD92FF1F971A0000D1180000951A0000C9190000F5190000251A00005D1A00009D1A0000111B0000214B224AF4
-:4012400010B5187000231370204A40201370204A0F2413701F4A13701F4A13701F4A13701F4A13701F4B4FF400021A604FF080721A604FF400121A6020221A6018608020E7
-:4012800018604FF480701860174804704FF480001860164B1A70933B19B91A7802F0FE0202E01A7842F001021A70114B03221A70802203F8202C012001F01AFE0D4B04221F
-:4012C0001A7010BDC892FF1FCE92FF1FCC92FF1FCD92FF1FC992FF1FB892FF1FCB92FF1F4093FF1F00E100E09E6000409C600040286000401260004070B5074C0546237848
-:401300000E461BB9FFF7E0FE0123237031462846BDE87040FFF792BF7892FF1F0A4A002313700A4A13700A4A13700A4A13700A4A13700A4A13700A4A13700A4B03221A7049
-:40134000802203F8202C7047CE92FF1FCC92FF1FCD92FF1FC992FF1FB892FF1FCB92FF1F4093FF1F28600040014B1878704700BFCD92FF1F044B1A7802F0FF001AB1187845
-:401380000022C0B21A707047CC92FF1F024A0C2303FB002040787047D492FF1F431E072B0CD8074A064B00010344805C5B7800F00F0043EA0020023880B2704700207047FA
-:4013C000FC5F00401A4A38B50C2303FB00231B79090C13F0800F00F1FF35044619BF8AB24FF480438BB24FF48042032D18D8DFE805F002070C110021084601F01BF80DE049
-:401400000021084600F0FAFF08E00021084600F0D9FF03E00021084600F0B8FF054B1855EDB2072D03D801F0EDF8034B185538BDD492FF1FA492FF1FAD92FF1F431E072B83
-:401440002DE9F0470446894615465CD82F4F0C2202FB0072D388DFF8B8A09BB2C3F500739D424FF00C0303FB007388BFD588DB7884BFC5F50075ADB2254A43EA1523060119
-:40148000B354B244EBB28AF80130224B1A5C9846FF2A01D1FFF796FF0C2303FB047200215170B9F1000F28D03DB31B4F385D01F011F811232946FE2218F8040001F0D6F8E3
-:4014C00006F5C04278321FFA89F118F8040001F0DFF8124D18F80410385D01F04BF80121385D00F0E1FF735D43F002037355735D03F0FD037355BDE8F08703FB047463793A
-:40150000DBB28AF80230BDE8F08700BFD492FF1FFC5F0040AD92FF1FA492FF1F706000402DE9F047044615468846002940D0431E072B3FD8FFF732FFA84203D22046FFF7CA
-:401540002DFF05461D4E335DFF2B03D141462046FFF738FFDFF868A027011AF8040000F0B9FF1223FE222946305D01F07FF807F5C0411FFA88F27831305D01F089F8DFF854
-:401580004490315D1AF8040000F0F4FF01211AF8040000F089FF17F8093043F0020307F8093017F8093003F0FD0307F8093002E00D4600E000252846BDE8F087AD92FF1FD4
-:4015C000A492FF1F70600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B200011A54704700BFD492FF1FFE5F0040431E072B9FBF024B000108221A5470474D
-:40160000FE5F004030B51A4A1A491B4D0878138803449BB21380194A00231488D8B2A4B27CB1082B0CD050680078C0B2E85450680133013050601088013880B21080ECE768
-:4016400018460B780E4C082B0E4A00D040B10E4D2B7883F080032B700F232370022301E0022323701370094B1870087030BD00BF4493FF1F4093FF1F00600040BC92FF1F5C
-:40168000B992FF1FCE92FF1FCA92FF1F4193FF1F074B02221A70074B80221A70064B0F221A70064A00231370054A012013707047CE92FF1FCA92FF1FB992FF1F4093FF1F5B
-:4016C0004193FF1F30B5164B16491B780A8803F00F03023BDBB21A4492B20A80124C134A0020118889B279B173B15568215C013BC9B229705168DBB20131516011880130B9
-:40170000013989B21180ECE7094A1370094A137883F080031370084B0B221A7030BD00BF296000404493FF1F00600040BC92FF1F4193FF1FCA92FF1FB992FF1F064A0623D5
-:401740001370064A01201370054B80221A70054B00221A70704700BFCE92FF1FB992FF1FCA92FF1F4193FF1F054B9A683AB19A68044910709A680988518000229A6070476E
-:40178000BC92FF1F4493FF1F08B5124B1A78D2B21A701B78DBB21A0602D50F4A137008BD0220FFF7E1FF0D4B1B7803F06003202B05D0402B06D043B900F012FC04E001F0ED
-:4017C000A7FB01E000F046FD10B9034B03221A7008BD00BF28600040B992FF1F0060004008B5084A084B0120197813880B449BB21380064B00221A70FFF7B6FF044B03221E
-:401800001A7008BD4493FF1F4093FF1FCE92FF1FB992FF1F08B50C4B1B78DBB2042B07D0062B09D0022B0DD1BDE80840FFF7D8BFBDE80840FFF746BF0320FFF795FF034BE0
-:4018400003221A7008BD00BFCE92FF1FB992FF1F08B5054B002201201A70FFF785FF034B03221A7008BD00BFCE92FF1FB992FF1F08B50A4B1A7832B11A78094942F0800273
-:401880000A7000221A70074B002201201A70FFF76BFF054B03221A7008BD00BFB892FF1F08600040CE92FF1FB992FF1F074B1B78DBB2042B05D0062B05D0022B05D1FFF794
-:4018C000A1BEFFF7C5BFFFF7D3BF7047CE92FF1F38B51D4C2378DBB2DD0634D518060AD503F00F03012B2ED1FFF74EFF174B1B78190609D538BD5A0602D5FFF7D7FF03E0AB
-:401900009D0620D5FFF786FF23781B061BD4104B1A78104B1B7813430F4A13701278934211D10A4A0849154613782078DBB2000605D41378DBB20B700B7803F00F03287851
-:401940008342F1D138BD38BD28600040B992FF1FCA92FF1F4193FF1F29600040054A00231380054A916819B191680B7092685380704700BF4493FF1FBC92FF1F0E4808B54E
-:4019800003889BB213B9FFF783FE13E00B4B02221A700B4B00221A70FFF7E0FF094AD1799379028843EA012392B2934238BF0380FFF728FE012008BDBC92FF1FCE92FF1F3B
-:4019C000CA92FF1F00600040084B01221A700F3B9B7C074B1A7B02F00302012A1EBFDA7B82F08002DA7301225A7370470B600040D492FF1F094B02221A700F3B93F82230F1
-:401A0000074B1A7E02F00302012A1EBFDA7E82F08002DA7601225A76704700BF0B600040D492FF1F0B4B04221A700F3B93F83230094B93F8242002F00302012A1EBF93F89F
-:401A4000272082F0800283F82720012283F82520704700BF0B600040D492FF1F0B4B08221A700F3B93F84230094B93F8302002F00302012A1EBF93F8332082F0800283F815
-:401A80003320012283F83120704700BF0B600040D492FF1F7047FFF741BC0000F0B5184B184E19780C27C9B201234FF0000C31B3CA0720D5144A4FEA031E7244947850788D
-:401AC0002040C5070DD507FB03652C79240608D5147804F0FE0414706D790C4CEDB204F80E50840706D507FB036425792D0658BF84F801C090700133DBB24908D7E7F0BD14
-:401B00009F600040D492FF1F70600040FE5F004000F0ACBC70B50446184B88B003AA03F11006154618685968083303C5B3422A46F7D11B782B70FCB12223237001AD0323C9
-:401B40002846637000F08AFE002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143C0132082AC1700371417100F10400EAD108B070BDDF390000B8
-:401B80002DE9F0431C4D01222E460C201F274FF0800E4FF0080C194B00FB02581401234418705F70164998F805902144B9F1000F07D098F8044024064CBF887081F802C009
-:401BC00001E081F802E000FB0261CC880132E4B29C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307215971D4D1054BFF221A70BDE8F08300BFD492FF1F70600040F2
-:401C0000FC5F00400A600040064B074A1B7802EBC30253681A7C824286BF03EBC003586900207047C892FF1F403A00002DE9F84F424B1A78002A7ED01878414D0138C0B226
-:401C4000FFF7E2FFA8463F4AC3681478007ADFF800C1E4B203EBC0000C2600274FF0010E834268D01A78A24263D11CF80420597891425ED19A7893F8039002F07F0206FB0C
-:401C800002FA05EB0A01CF7093F802B009F0030981F804B093F803B005F80AB0B3F804A0A1F808A093F902A0BAF1000F0BDAB9F1010F0CBF4FF007094FF00D0981F80590F6
-:401CC00081F801E009E0B9F1010F0CBF4FF005094FF0090981F805904F704FEA02191A4906FB0282494481F802E0B2F808A0CAF3072A81F800A0B2F808A05FFA8AFA81F88C
-:401D000001A0B2F806A011495FFA8AFA494481F806A0B2F80690C9F3072981F80790B2F806905FFA89F981F80490D288C2F307224A71083394E7BDE8F88F00BFCD92FF1F5A
-:401D4000D492FF1FC992FF1FFC5F004070600040BA92FF1F08B5064B18780138C0B2FFF753FF20B143681B7900EBC300406908BDCD92FF1F00212DE9F84F0B464E4E0C2779
-:401D800007FB01F401313219092933554FF000059370494CD3701381937253705371EFD118B1464B1D70464B1D70464B1A78002A7FD0187801250138C0B2FFF725FFA846EC
-:401DC0004368DFF8F8E0DB790C2713F0400F3E4B4FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB0541C36803EB02094B4531D093F802A00AF07F06AE4229D1E5
-:401E00000E89B3F804B0B6B25E4538BFA1F808B01E7893F801B01EF80660B3451AD181F804A0DE780E7093F902A0DE78BAF1000F06F0030607DA012E0CBF07260D264E7100
-:401E400081F8018006E0012E0CBF052609264E7181F801C00833CBE70135092DC3D1C1680A328B1C0A440C200833934209D013F8081C13F80A5C01F07F0100FB01418D728C
-:401E8000F2E7FFF767FF114B0121186000230C2000FB0142D3801289013113449BB203F00102134409299BB2F2D1BDE8F84FFFF767BEBDE8F88F00BFD492FF1FBA92FF1F37
-:401EC0004293FF1FCD92FF1FCB92FF1FD092FF1F114B1B7903F07F035A1E072A19D80F490C2202FB031291781B0141F0010191700021D170517841F002015170127912F0DA
-:401F0000800F074A1A4414BF8D2389239370FFF715BC0020704700BF00600040D492FF1FFC5F004030B4194B1A7902F07F02531E072B27D8164B0C2404FB02339978154DED
-:401F400001F0FE0199700021D97029461201505D114400F07F0050555A7802F0FD025A701A795B78120605D5012B01D18C7006E00D2303E0012B0CBF082309238B7030BC59
-:401F8000FFF7DCBB002030BC704700BF00600040D492FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2FFF72EFE43681B798B4201D2012909D8074A0848535CDBB2A4
-:401FC0004354A3780120DBB2535410BD002010BDCD92FF1F00600040BA92FF1F4293FF1F38B58A4A8A4C13780021DBB221801806517840F18D800A2900F20581DFE811F09D
-:402000005D00030103010301030103010B0003017E0003018200D3787C49012B09D17D4B1A787D4B03EBC2035B685B686360122310E0CB78022B12D18878FFF7E5FD002870
-:4020400000F0E180436863606368DA7863689B7843EA02232380BDE83840FFF78FBCCB78032B26D16D4B00228878D5B2854209D3664A91786A4AEE2908BF1346634A91788D
-:4020800081B106E0187801320028F1D018780344EAE764499278097C914203D16248FFF739FD614B1A78002A00F0AD801A78228018E0BDE8384000F02BBF13F0030313D067
-:4020C000022B40F0A0802380504B0C211B7903F07F02564B01FB02339A78554BD2B21A7000225A706360B6E702222280514A11784F4AC9B2117053706260ACE701232380B4
-:402100004D4BEFE70123238013794C4A1344E9E701390A2977D8DFE801F037764F76067676760A7620009378454ADBB25AE0937803F0FF0153B9404B1A7891425FD0197020
-:40214000404B01201870FFF715FE58E0481EC0B2FFF75AFD0028EED155E0FFF71DFF002851D02A4A384913791279DBB2D2B20A70364A3249D25CCB5C9A4240D0314B0122DC
-:402180001A70FFF753FD3AE003F00303012B2BD009D3022B37D11D4B9B78002B33D1BDE83840FFF7BFBE194B9B78012B2BD1214A137803F0FD0315E003F00303012B13D045
-:4021C00008D3022B1FD1114B9B78E3B9BDE83840FFF77EBE0D4B9B78012B14D1154A137843F0020313700AE0084B1A795AB998781B791749DBB2CA5C22EA0002CA54BDE801
-:402200003840FFF79BBA002038BD00BF00600040BC92FF1FC892FF1F403A0000A43A00002C3A0000173B00006093FF1FD492FF1F7992FF1FCB92FF1FCD92FF1FBA92FF1F53
-:40224000B892FF1FCC92FF1FC992FF1F4293FF1FCF92FF1F074B1A78120609D55B78012B06D1054B054A5A6012781A80FFF786BB0020704700600040BC92FF1F043A00000A
-:40228000014B1870704700BF7A640040014B1878704700BF6B650040014B1870704700BF79640040064A0123136002F688321268E0211064034A1170A2F540721360704724
-:4022C00080E100E000E400E0014B1870704700BF7A650040014B1870704700BF7865004073B515461E460B4C05230022019200920A4601461846237000F064F932462946A0
-:40230000207800F01FF90221207800F009F9207802B070BDD080FF1F064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B042227
-:402340001A60704700E100E0014B04221A60704780E100E0014B1870704700BF7E640040704738B505460078012428B100F068FD285D0134E4B2F8E738BD08B50D2000F063
-:402380005FFDBDE808400A2000F05ABDF7B516461F460B4C00230325019300930A4601462846257000F00EF93A463146207800F0C9F80221207800F0B3F8207803B0F0BD4E
-:4023C000E080FF1FF7B516461F460B4C00230225019300930A4601462846257000F0F2F83A463146207800F0ADF82946207800F097F8207803B0F0BDE180FF1FF7B516468D
-:402400001F460B4C00230125019300930A4601462846257000F0D6F83A463146207800F091F80221207800F07BF8207803B0F0BDE280FF1F73B515461E460B4C0023019385
-:4024400000930A4601461846237000F0BBF832462946207800F076F80221207800F060F8207802B070BD00BFE380FF1F024B1878C0F38010704700BF8F450040074A7F236A
-:40248000802113705170064A013BDBB202F80839002BF9D1034A1370704700BFE480FF1FF87B00400078004017280FD8084B0001C25C11B142F0200201E002F0DF02C25443
-:4024C000C25C42F00102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C254C25C02F0DF02C25400207047012070471070004017280DD8074900017F
-:402500000B4603441A7942F004021A71435C43F00103435400207047012070471070004017280BD8064A0001835C490003F0F10301F00E011943815400207047012070476F
-:402540001070004041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F5EC4081809ABFC280002001207047000017289FBF034B00011954002048
-:4025800088BF0120704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120704700BF1470004017289FBF034B0001185C00F0070088BFFF2070470B
-:4025C00014700040172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF8082003F00F0343EA0213DBB263709DF80C30002003F00F03A370E07010BD73
-:40260000012010BD10B500F07BFC0A4A5378182B0AD91478013B5370E30003F1804303F5F0431B78137000E0FF2400F06DFC204610BD00BFE480FF1F030610B5044611D408
-:4026400000F05EFC084AE300117803F1804303F5F04319705378147001335370BDE8104000F052BC10BD00BFE480FF1F30B504060CD411F4704509D1C40004F1804404F5C7
-:40268000F0442180A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280002001207047000038B50446084DB4F5004F05D9286800F019FCA4F5D6
-:4026C0000044F6E7034B58686043BDE8384000F00FBC00BFEC80FF1F024B1B7A584300F007BC00BFEC80FF1F0E4B00F003001A78490102F0FC02104318701A7801F0600197
-:4027000042F080021A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF83430040014B01221A70704784430040044B00F00F021B6853F82200FD
-:4027400043F82210704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BF08ED00E000F01F0000F16040490100F56440C9B2017070470F4B10B55B
-:402780000F4900240F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72DB68B3FBF2F3084A1360084B4FF400421C60C3F8E82010BD7C92FF1FCF
-:4027C0002928000010E000E0EC80FF1F14E000E018E000E0024A136843F002031360704710E000E008B5FFF7F5FF034A136843F00103136008BD00BF10E000E010B5054C06
-:40280000A3691BB9FFF7BAFF0123A361BDE81040FFF7E8BF7C92FF1F024B1868C0F30040704700BF10E000E038B5FFF7F5FF012808D1054D002455F8243003B19847013465
-:40284000052CF8D138BD00BF8092FF1F024B03EB80035868596070477C92FF1F134B144A1B78DBB20360127843EA0223114A0360127843EA0243104A0360127843EA0263B2
-:4028800003600E4B0E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA02634360704700BF0301004904010049EC4600400201004901010049A0
-:4028C00000010049050100490601004910B500F017FB204A044613780A2043F002031370137C43F00203137412F80A3C43F0010302F80A3C937943F00103937102F5AB52B4
-:40290000137843F003031370134B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222183B1A70094A137843F008031370CB
-:40294000FFF7CAFE064B10222046BDE810401A6000F0DABAAB4300400E5900402F5B004080E200E008B500F0CBFA0F4A137803F0FE031370A2F5AA521D3A137803F0FD03A7
-:402980001370137C03F0FD03137412F80A3C03F0FE0302F80A3C937903F0FE039371BDE8084000F0B1BA00BF08590040044A137803F03F0343EA8010C0B21070704700BF28
-:4029C00008590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F664
-:402A0000C41393FBF1F305490B60054B1A8070470A590040F03900004A93FF1F4C93FF1F5093FF1F08B5102000F0A6F907210420FFF79AFE07490420FFF788FE064A0C206C
-:402A4000137843F006031370FFF7BCFF034B00221A8008BD1D2B0000095900404893FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF72ABF9892FF1F044B1A789F
-:402A800002F0FB021A701A7842F001021A7070470859004010B5084B1C7814F0010403D10028F9D0002404E02046FFF715FE024B1B78204610BD00BF09590040034A044BF3
-:402AC0001B881088181A00B2704700BF5093FF1FA25B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F3D7
-:402B00000028D8BF5B42134493FBF1F000B270474A93FF1F4C93FF1F4893FF1F7047000010B500F0EDF9214A044613780A2043F001031370137C43F00103137412F80A3C06
-:402B400043F0020302F80A3C937943F00203937102F5AA521832137843F003031370144B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8DF
-:402B8000062CA3F597530222123B1A70094A137843F008031370FFF79FFD074B08222046BDE810401A6000F0AFB900BFAB43004006590040275B004080E200E008B500F04F
-:402BC0009FF90F4A137803F0FE031370A2F5AA52153A137803F0FE031370137C03F0FE03137412F80A3C03F0FD0302F80A3C937903F0FD039371BDE8084000F085B900BF94
-:402C000000590040044A137803F03F0343EA8010C0B21070704700BF00590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF60
-:402C400033F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A80704702590040FA3900005693FF1F5C93FF1F5493FF1F08B51020DA
-:402C800000F084F807210320FFF76EFD07490320FFF75CFD064A0C20137843F006031370FFF7BCFF034B00221A8008BD752D0000015900405893FF1F10B5054C23781BB92A
-:402CC000FFF7DCFF01232370BDE81040FFF728BF9992FF1F044B1A7802F0FB021A701A7842F001021A7070470059004010B5084B1C7814F0010403D10028F9D0002404E0B4
-:402D00002046FFF7E9FC024B1B78204610BD00BF01590040034A044B1B881088181A00B2704700BF5493FF1FA05B00400E4A13881BB223B111880A2309B2594301E00B4B8D
-:402D400019680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270475693FF1F5C93FF1F5893FF1F70470000034A00F0F8001378F0
-:402D800003431370704700BF02410040034A00F0F800137803431370704700BF06410040014B1870704700BF78640040014B1870704700BF7965004073B515461E460B4CBF
-:402DC00004230022019200920A46014618462370FFF7F8FB324629462078FFF7B3FB02212078FFF79DFB207802B070BDFC80FF1F074A0223136002F688321268E0215064AD
-:402E0000044A11706FF440710A441360704700BF80E100E001E400E0014B1870704700BF7C640040014B1870704700BF7B640040014B1870704700BF7F6400400000000032
-:402E4000FEB5494652465B460EB40746244909688A46244A12682448022100F071F8030020480068C018204900F06AF8143883460121C9430C460125002600F041F8814613
-:402E800051460B7823400B705846013000F030F83800F04028400B78234003430B70584600F026F80136072EF2D9002001300138013001200B78234003430B705846043084
-:402EC00000F016F8484600F01FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F00C20100000000000230800803D000BF01380046FCD17047FA
-:402F0000EFF3108072B6704780F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F02044B01FB02339B7A00E013790020704700600040D492FF1FB2
-:402F4000002902D0B0FBF1F0704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BF014B1868704700BF6081FF1F0E4B70B51E460E4C0025E41A7D
-:402F8000A410A54204D056F8253098470135F8E700F0DEFD084B094C1E46E41AA4100025A54204D056F8253098470135F8E770BD5C3B00005C3B00005C3B0000643B00007A
-:402FC00003460244934202D003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF40273ADF80C300CBF234604F1FF33029305934FF6FF730091F6
-:403000000491ADF80E3002461E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000007B5009313460A46014603480068FFF7CBFF03B05DF804FB0F
-:403040006081FF1F2DE9F0478E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656905EB450595FBF3F57B1C43449D4238BF1D4653050FD52946F8
-:4030800000F04AFB064698B13A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B92169504600F0E8FA0C23CAF80030A3894FF0FF3043F04003F2
-:4030C000A381BDE8F08726613E44266046466561ED1BA560464528BF464649463246206800F0B3FAA36800209B1BA36023681E442660BDE8F08700002DE9F04F9DB00393CD
-:403100008B8980461C060D4616460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B610023099320238DF82930DFF89CB130238DF82A3037463C461B
-:4031400014F8013B1BB9B7EB060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780099B4B4409933B78002B00F0A08000234FF0FF320493079332
-:40318000059206938DF853301A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F018430490EFE7D90644BF20228DF853201A0744BF2B228DF853208C
-:4031C00022782A2A03D0079A00210A200BE0039A111D12680391002A10DA524243F00200079204900BE027463B780134303B092B03D800FB02320121F5E701B107923B786F
-:403200002E2B1ED17B782A2B0AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781C0A2407463A780130303A092A03D804FB01210123F5E703B109
-:40324000059103223978224800F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1C8DF8281000F0D4F988B1194B33B9039B073323F007030833E3
-:40328000039314E003AB00932A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F1FF3F824603D0099B5344099342E7AB895B0601D4099801E019
-:4032C0004FF0FF301DB0BDE8F08F00BF2B3B0000313B0000353B000000000000453000002DE9F04791461F460A698B6806469342B8BF1346C9F8003091F843200C46DDF815
-:40330000208012B10133C9F800302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E00123524639463046C04701301AD00135E368D9F800209B1A3C
-:403340009D42F1DB94F843302268003318BF012392060FD5E118302081F843005A1C94F845102244023382F8431003E04FF0FF30BDE8F08704F1430239463046C0470130D7
-:40338000F4D02268D9F80050E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED184FF000091A344D4509D00123224639463046C0470130D5D08C
-:4033C00009F10109F3E70020BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8011D8632A22D009D8002A00F0BB80582A40F0CA8081F84520BC
-:40340000834955E0642A1ED0692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A603EE0752A24D0782A3AD0ADE01A6801F14205111D19601368C2
-:4034400084F84230A8E021681A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E01368002B3CDA2D225B4284F8432037E021681A6811F0800F53
-:4034800002D0111D196007E011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE078225A4984F845202268186812F0800F00F104051D6003D11E
-:4034C000550601D5038800E00368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E049490A226568002DA56008DB206820F0040020602BB9002D42
-:403500007DD175460CE0002B79D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0708D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0360
-:4035400023612EE008681A6810F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198000E0196000232361754616E01A68111D1960156800216268C6
-:40358000284600F049F808B1401B6060636804E004F1420584F8422001232361002384F84330CDF800803B4603AA21463046FFF797FE013002D14FF0FF3026E023692A46C6
-:4035C00039463046C0470130F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B7890
-:4036000004F1420584F842308AE705B0BDE8F083DF3900003C3B000010B5C9B202449042034605D01C7801308C42F8D1184610BD002010BD10B5431E0A44914204D011F885
-:40364000014B03F8014FF8E710BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014D01F8014DF8E710BD994204D011F8014B02F8014FF8E710BD08
-:4036800038B50546002944D051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A3420DD92268A018834201BF18685B681218226063600C6023E087
-:4036C000A24203D813465A68002AF9D118681918A1420BD12168014458188242196013D110685268014419605A600DE002D90C232B6009E021686018824201BF1068526861
-:403700000918216062605C602846BDE8384000F098B838BDA092FF1F70B5CD1C25F0030508350C2D38BF0C25002D064601DBA94202D90C23336046E000F082F8234B1C6831
-:403740001A462146A1B10B685B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4615E00C464968E9E7174C23681BB9304600F052F8206029464B
-:40378000304600F04DF8431C18D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A0ED05A42E25070BD211A304600F034F80130EBD10C2333609D
-:4037C000304600F03EF8002070BD00BFA092FF1F9C92FF1FF8B5074615460E4621B91146BDE8F840FFF798BF1AB9FFF749FF2846F8BD00F027F885420ED929463846FFF7AD
-:403800008BFF044650B131462A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C0023054608462360FDF7D6FB431C02D1236803B12B6038BD8493FF1F15
-:403840007047704751F8040C0028BEBF091851F8043CC0180438704700000000050209020B020D020F021102130215027265706C792030782530327800686F6D696E670074
-:40388000626567696E6E696E67207365656B2066726F6D20256420746F2025640066696E6973686564207365656B00796573006E6F00647269766520303A202573206472D4
-:4038C00069766520313A2025730057616974696E6720666F72205553422E2E2E0055534220726561647900636F6D6D616E6420307825303278006661696C2025642B2564B5
-:403900002B2564203D3D2025642C206E6F74202564007061737365643D256400756E64657272756E206166746572202564207061636B65747300636F756E743D2564206933
-:403940003D256420643D256400636D645F777269746500703D25642063723D25642063773D256420663D256420773D256420696E6465783D256420756E64657272756E3D51
-:40398000256400756E64657272756E2100737563636573730073746172742065726173696E670073746F702065726173696E670069646C65000051004010004051004030AB
-:4039C0000000000140001000140140000800400140000A004C0140000200500140200030313233343536373839414243444546000001000000040000001000010000000492
-:403A00000000001028000000000104000100000000000000000157494E5553420000303030303100000000000000000012034D00530046005400310030003000010000009D
-:403A400001000000483A000001000000173B0000000000000000000001000000603A000001000000E93A000004000000823A0000000000000000000000000000803A000037
-:403A8000FF00000001024000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500780045006E00670069006E0065002A03A3
-:403AC00043006F0077006C00610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010080320904000004FF0000010705010240A2
-:403B00000000070582024000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B2000686C4C00656667454647003031323359
-:403B400034353637383961626364656600000000F8B500BFF8BC08BC9E4670475900000059100000F8B500BFF8BC08BC9E46704735000000883B0000C880FF1FA0000000EB
-:403B80002012000000000000000000008893FF1FFF000000675000400C00000007000000FFFFFFFF7F8000003F0000000000007D00FA0000400000000090D003FF0000003E
-:403BC0000000000000000000000000000000000000000000000000000000000000000000293B00000000000000000000000000000000000000000000000000000000000061
-:403C000000000000000000000000000000000000000000000000000000000000000000000081FF1F00000000000000000000000000000000000000000000000000000000E5
-:403C40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044
-:403C80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004
+:4000000000800020110000004910000049100000064A08B5136843F020031360044B1A6803F53F5302331A6001F02CF8E8460040FA46004010B5054C237833B9044B13B14F
+:400040000448AFF300800123237010BD6881FF1F00000000D0380000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF0000000039
+:400080006C81FF1FD0380000C880FF1F000000000A4A0B4B116801310B40002BBEBF03F1FF3363F03F030133136011685368994202BF024B01221A72704700BF8881FF1FB4
+:4000C0003F0000800A4A0B4B516801310B40002BBEBF03F1FF3363F03F030133536051681368994202BF024B01221A72704700BF8881FF1F3F000080114BDA68196919B9FD
+:4001000001221A75597514E09969521A19698A4294BF587D00201875187D094908B1002204E0086982428CBF002201224A75DA689A611B7D13B1002002F04AB9704700BF6C
+:400140008881FF1F10B5C4B2204601F05DF90128FAD110BD08B572B60F4B0F49DA680132DA60DA690132C82A08BF0022DA611A6AD8690132A72A08BF00220A621B6A002B0F
+:400180000CBF02230023002814BF184643F0010002F086FE62B608BD8881FF1F38B50446C5B2284602F0B6F8062002F0D3FA44F00200C0B202F0AEF8062002F0CBFA2846F9
+:4001C00002F0A8F8BDE83840062002F0ADBA10B5642402F099F828B9FFF7E0FF013CF8D1204610BD012010BD70B5C4B2054620460E4601F009F9012805D0204601F022FA20
+:400200002846FFF79FFF204601F006F9314605460246204601F0C2F9204601F0F5F80028FAD1284670BD000038B5044D0024285D013402F03FFA402CF9D138BDAC81FF1FBB
+:4002400008B502F059FC002002F062FC02F074FC02F07EFC80B208BD10B50446012002F071F8642002F060FAFFF7EAFF2080002002F068F8642002F057FAFFF7E1FF60807C
+:4002800010BD08B502F064FD002002F06DFD02F07FFD02F089FD80B208BD10B50446FFF796FF322002F040FAFFF7EBFF20800120FFF774FF322002F037FAFFF7E2FF6080BA
+:4002C00010BD0FB400B593B014AB53F8042B402102A8019302F0E4FE02A802F080F802F08AF813B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF723FF62780A
+:400300002146BDE81040042001F0D6B8E438000007B50023ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB000010B5074C94F8643043B1002001F0DEFFDE
+:40034000002002F071FD002384F8643010BD00BF8881FF1F38B5104D837895F8672004469A4204D0FFF7E4FF002385F86A302368C5F865302279094B1A71A378002B14BF41
+:400380000220012002F050FDE07802F047FD2079BDE8384002F07EBD8881FF1FED81FF1F38B50D4C94F8645065B904F16500FFF7D1FF012001F0A2FF4FF47A7002F0B4F954
+:4003C00084F86A50E368E366012384F86430BDE8384002F0E7B900BF8881FF1FF8B5214C0546FFF7DDFF94F86A3003B15DB91E48FFF767FFFFF7EBFE0120002384F86A0078
+:40040000236702F0A7F92A46216F1848FFF759FF144E0027236F9D4216D001F075FF00B13767236F9D4205DD0120FFF7B7FE336F013305E005DA0020FFF7B0FE336F013B03
+:40044000336702F0AFF9E5E7322002F06DF92A2DCCBF0020012002F029FDBDE8F8400448FFF72FBF8881FF1FF1380000F8380000153900002DE9F04F99B062B602F0FCF91F
+:400480009E49042002F020FA9D4801F049FF9D4802F0ECFC9C4801F07DFF02F0CDFB02F09FFA002002F0C0FC01F098FF0221002000F060FF954C012001F0D8F8002384F868
+:4004C0006730FFF76DFFFFF782FE84F87400FFF72FFF012384F86730FFF762FFFFF777FE84F87500FFF724FF894B94F87400894994F875202546002A14BF0A461A4600286F
+:4005000008BF19468448FFF7DCFE0321084602F029F9264602F046F994F8643043B1EA6EEB689B1A41F28832934201D9FFF700FF00F058FF18B97948FFF7C3FE04E000F06D
+:4005400057FF0028F7D10BE000F04CFF10B902F029F9F9E77248FFF7B4FE032001F072F8032000F051FF0128D4D16E48FFF7F2FE6D490320FFF738FE94F876106B48FFF7E5
+:40058000A0FE94F87630023B142B00F2D683DFE813F01500D4031E00D4032400D4035000D4037600D403D900D403C101D4030803D4032C03D4033303D4034D0303238DF851
+:4005C00020308DF821300F238DF822302AE394F87800FFF703FF564B21E340F2DC57FFF7DFFE00232375E068227D02F0FF012AB9EB681B1ABB42F7DD0B4611E083B100227E
+:40060000174696F87810F068277594F814E0BEF1000F02D1EB681B1AF7E701329142F3DA07228DF8202004228DF82120ADF82230F8E20220FFF786FD4FF000080DF1200A54
+:4006400002F0B0F84FF480790027C9EB0803DA1907F80A200137402FF9D10220FFF772FD3A465146022000F027FFB9F10109EBD108F10108B8F1400FE2D12E4B38E04FF06E
+:40068000010A4FF000080DF1200B02F08BF84FF0000959460120FFF7A7FD08EB090300270493049B1BF807203B44DBB29A4209D08DE80C0041463B464A461F48FFF701FEDC
+:4006C0004FF0000A0137402FEBD109F10109B9F5807FDED108F10108B8F1400FD5D151461648FFF7EEFDBAF1000F00F01B81144B1B8807A8ADF81C3095E200BF5501000004
+:40070000F900000091000000C50000008881FF1F27390000233900002A3900004239000055390000ED81FF1FFE81FF1F5F390000D4380000D63800006E3900008A390000D6
+:40074000D8380000206FFFF749FE94F8780001F0F9FD94F8780001F0DDFD02F00DFCB94BDFF8FC821A78002702F0FB021A701A7842F001021A701A7802F0FE021A701A786C
+:4007800002F0FE021A7002F0FBFB0220FFF7DAFC012141F6FF734FF48042084602F04AFB84F8B60001F06CFF08F807000137402FF8D1DFF8B0A200270AF195091FFA89F80A
+:4007C0000137402F14BF3A4600221AF8010F2244062392F82420402101F086FF424646F24F419AF8000001F091FF08F14008402F1FFA88F8E4D196F8793053B196F87C30B1
+:40080000336100233375237D002BFCD000233375336100234FF0FF32236062602372236894F8B600234493F8241001F0E1FE94F8B60001F09FFE012194F8B60001F072FE9E
+:400840002368002BFCD0002398467360D6F80CA0012701F0A7FFE368B4F87A20CAEB030393420DD367B1042195F8B60001F0CCFE94F8B60001F0D8FE0028F9D107463072C3
+:40088000237AFBB96A682B689A4202D1002FE0D118E00220FFF756FC6968402209EB8111022000F009FE6A68674B01321340002BBEBF03F1FF3363F03F03013308F101081C
+:4008C0006360C6E70220277AFFF73CFC00221146022000F0F1FD0220FFF734FCFFB2FFF7A3FC002001F016FD37B15848FFF7E9FC0220FFF70DFD06E0554B08A81B88ADF869
+:400900002030FFF7F3FC227D4146237A5148FFF7D8FC15E25048FFF7D4FCD4F87A7017F03F0701D0032009E2286FFFF757FD95F8780001F007FD95F8780001F0EBFC01204C
+:4009400001F006FD02F018FB444BDFF814811A7842F004021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F007FB01214FF4804341F6FF72084601F0BF
+:40098000EDFC85F8B60001F07BFE08F807000137402FF8D1DFF8CC90002709F195031FFA83F804930137402F14BF3A46002219F8010F2244052392F82420402101F094FEA6
+:4009C000414646F24A5299F8000001F09FFE08F14008402F1FFA88F8E4D100274FF0FF33376098467360BB463B46D6F87A9037725FEA99190CBF4FF0010A4FF0000A2168BA
+:400A0000114A01310A40002ABCBF02F1FF3262F03F026068B8BF013282426FD02BB1227A002A7AD12A7D002A77D12068049A059302EB8010BAF1000F16D040223F2102F079
+:400A4000FBFA1CE09F6400403F00008094390000DA380000AE390000C13900009A650040AC81FF1FAB81FF1F014601370120FFF7BBFBC7EB0903D3F1000A4AEB030A21684C
+:400A8000B34A01310A40002ABEBF02F1FF3262F03F02013222606268059B01322ED12A683F2A2BD14FF00008C5F8048001F084FC85F808806B6895F8B6002B4493F82410D5
+:400AC00001F096FD95F8B60001F054FD012195F8B60001F027FD95F87E302B6185F81480237D002BFCD04FF00008012086F8148001F06EFC404601F02BFC00E023B1237A40
+:400B00005BB92B7D4BB90123626842453FF477AF0BF1010BD5F8048071E701F053FC012001F016FC002001F053FC042194F8B60001F06AFD94F8B60001F076FD804600285F
+:400B4000F8D196F8B60001F003FD337D327A0293012303920193CDF800A05B463A4649467C48FFF7AEFBC6F81080BAF1000F0BD0FFF75AFB002001F0CDFB237A63B176484B
+:400B8000FFF79FFB0220D9E0B945F1D073490120FFF72AFB0137F7E77148FFF792FB714B3DE094F8780001F0CDFB206FFFF716FC6D48FFF786FB94F87930236100232375F4
+:400BC000237D002BFCD0012001F002FC00233375237D002BFCD0002001F0FAFB002363483361FFF76EFB624B19E0002084F86A00FFF7F4FB5F4B12E094F8743023B195F867
+:400C000075200AB985F8782094F875201AB113B9012385F878305848FFF79CFB574B1B88ADF8203008A8FFF761FB89E0FFF780FB02F080F8002002F023F82A2701F04EFFDD
+:400C4000002001F0F1FE3A46002108A802F0F4F917238DF820308DF8217001F0A3FD002001F04CFB002002F0DFF8C82001F05CFD0DF12200FFF7F0FA0DF13600FFF70DFBE9
+:400C800001F090FD012002F0CFF8322001F04CFD0DF12600FFF7E0FA0DF13A00FFF7FDFA012001F02BFB4FF4967001F03DFD01F079FD0DF12E00FFF7CFFA0DF14200FFF703
+:400CC000ECFA002001F01AFB4FF4967001F02CFD01F068FD022002F0A7F8322001F024FD0DEB0700FFF7B8FA0DF13E00FFF7D5FA012001F003FB4FF4967001F015FD01F023
+:400D000051FD0DF13200FFF7A7FA0DF14600FFF7C4FA002001F0F2FA4FF4967001F004FD01F040FD002002F07FF8002384F86A3001F082FF01F054FE74E70120FFF7E8FA75
+:400D4000032000F07FFC0E48FFF7BBFAFFF7E2BB3F000080CB390000FB3900004092FF1F053A0000DC3800000D3A00001B3A0000DE380000E0380000FE81FF1FE238000096
+:400D8000283A00002DE9F04172B6874A874D1378002443F020031370062606FB045300219A881868013402F047F9072CF5D18048804D002450F8041F04F1105303F14C02D0
+:400DC00021F0FF064D33C9B20B4452005B0002329A4206D012F8027C12F801EC07F806E0F5E7A8420C44E5D1734A00231360936013619361714A724D1168724A724C116044
+:400E0000724A19261168724A724F116072490A7842F002020A700A7C42F002020A742A78A1F5863142F040022A7041390A7842F010020A70694A07CA03C469492280086863
+:400E4000684A2834106009791171674A07CA03C42280664AE83C07CA03C42280644A083407CA03C42280634A03CAC4F80A006248C4F80E100178614C41F008010170604995
+:400E800061200870A1F5F061012008808E7092E803005C4A84E80300062111705221A2F580721170584A594912781C46D2B20A70574A4FF4E261118041F2512122F8021C31
+:400EC0003B784FF4F07003F0010343EA440303F0030402F049F8013E64D0032CF0D14D4A4FF4807313804C49072313704B4800230B704821017013705371494B02221A706B
+:400F000004229A7290F89A33464F43F0010380F89A3390F89933DFF82C8143F0030380F899332B78C12043F080032B70344B18703D4B3E481B783C78DBB298F80060E4B280
+:400F400003F0070ED34080F800E0F6B2437044F003033B7046F0030388F80030344B1970344940230B708B700B728B72082381F81F32202180F8B51280F8BA222E4A0A208F
+:400F8000117082F82D3001F0E5FB2C4B88F8006044223C702A4C1A7095E80F0007C42380BDE8F081FEE700BFE84600402D3A0000FCFFFF4794000048007600405C0B004894
+:400FC000A043004020760040C0510040600B0048287600402542004003500140140B0048200B0048CB510040280B0048340B0048400B00484C0B004822430040004100404B
+:4010000000480040004300400F010049A14600402242004004400040064000400840004001400040F8460040CF0100496E5800401D510040015900402B5B004076580040B5
+:40104000B0430040F946004008B501F0C9FF03680C2B00D1FEE7FEE7084908B50B68084A1844821A802A01DC086005E001F0B8FF0C2303604FF0FF33184608BDCC80FF1F34
+:401080009093FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F8046BF7E7114653F8046C8C1AA64202D041F8045BF9E701381033E5E757
+:4010C00001F094FFFFF7D6F9FEE700BF01000000FC3B0000124A134B10B51A60124A134C1368134843F4007313600023032B98BF54F823204FEA830188BF0E4A0133302B02
+:401100004250F3D10C4B1A780C4B1A700C4B084A1A60FFF737FEBDE8104001F0EDB900BF0004FA050CED00E014ED00E0000000000080FF1F49100000BC760040C080FF1F72
+:4011400008ED00E0F8B501F017FF4B4A01271378022643F001031370137C484C43F001031374474B02F5E3521F700B3203F8946C1378054603F07F031370002001F0EAFA93
+:401180002378404A03F0F90323701378384603F0DF03137023783B43237001F0DBFA282001F0D8FA384B30461A7802F07F021A701A7802F0BF021A7023783343237001F0BE
+:4011C000C9FA2378314A43F0040323700023137053702F4AFF2199540133092BFBD1284601F0CEFE0721172001F0FCFA2949172001F0EAFA0721182001F0F4FA2649182051
+:4012000001F0E2FA0721152001F0ECFA2349152001F0DAFA0721052001F0E4FA2049052001F0D2FA0721062001F0DCFA1D49062001F0CAFA0721084601F0D4FA1A490720CB
+:4012400001F0C2FA0721082001F0CCFA1749082001F0BAFA0021162001F0C4FA1449162001F0B2FA07210C2001F0BCFABDE8F84010490C2001F0A8BAA54300409443004068
+:401280009D60004012600040F851004084600040B592FF1F131B00004D190000111B0000451A0000711A0000A11A0000D91A0000191B00008D1B0000214B224A10B51870D4
+:4012C00000231370204A40201370204A0F2413701F4A13701F4A13701F4A13701F4A13701F4B4FF400021A604FF080721A604FF400121A6020221A601860802018604FF4F9
+:4013000080701860174804704FF480001860164B1A70933B19B91A7802F0FE0202E01A7842F001021A70114B03221A70802203F8202C012001F018FE0D4B04221A7010BD04
+:40134000D092FF1FD692FF1FD492FF1FD592FF1FD192FF1FC092FF1FD392FF1F4893FF1F00E100E09E6000409C600040286000401260004070B5074C054623780E461BB9B6
+:40138000FFF7E0FE0123237031462846BDE87040FFF792BF8092FF1F0A4A002313700A4A13700A4A13700A4A13700A4A13700A4A13700A4A13700A4B03221A70802203F84C
+:4013C000202C7047D692FF1FD492FF1FD592FF1FD192FF1FC092FF1FD392FF1F4893FF1F28600040014B1878704700BFD592FF1F044B1A7802F0FF001AB118780022C0B28E
+:401400001A707047D492FF1F024A0C2303FB002040787047DC92FF1F431E072B0CD8074A064B00010344805C5B7800F00F0043EA0020023880B2704700207047FC5F004062
+:401440001A4A38B50C2303FB00231B79090C13F0800F00F1FF35044619BF8AB24FF480438BB24FF48042032D18D8DFE805F002070C110021084601F01BF80DE000210846F4
+:4014800000F0FAFF08E00021084600F0D9FF03E00021084600F0B8FF054B1855EDB2072D03D801F0EDF8034B185538BDDC92FF1FAC92FF1FB592FF1F431E072B2DE9F0470D
+:4014C0000446894615465CD82F4F0C2202FB0072D388DFF8B8A09BB2C3F500739D424FF00C0303FB007388BFD588DB7884BFC5F50075ADB2254A43EA15230601B354B244E9
+:40150000EBB28AF80130224B1A5C9846FF2A01D1FFF796FF0C2303FB047200215170B9F1000F28D03DB31B4F385D01F011F811232946FE2218F8040001F0D6F806F5C04262
+:4015400078321FFA89F118F8040001F0DFF8124D18F80410385D01F04BF80121385D00F0E1FF735D43F002037355735D03F0FD037355BDE8F08703FB04746379DBB28AF8A7
+:401580000230BDE8F08700BFDC92FF1FFC5F0040B592FF1FAC92FF1F706000402DE9F047044615468846002940D0431E072B3FD8FFF732FFA84203D22046FFF72DFF0546CA
+:4015C0001D4E335DFF2B03D141462046FFF738FFDFF868A027011AF8040000F0B9FF1223FE222946305D01F07FF807F5C0411FFA88F27831305D01F089F8DFF84490315DE9
+:401600001AF8040000F0F4FF01211AF8040000F089FF17F8093043F0020307F8093017F8093003F0FD0307F8093002E00D4600E000252846BDE8F087B592FF1FAC92FF1F51
+:4016400070600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B200011A54704700BFDC92FF1FFE5F0040431E072B9FBF024B000108221A547047FE5F00407B
+:4016800030B51A4A1A491B4D0878138803449BB21380194A00231488D8B2A4B27CB1082B0CD050680078C0B2E85450680133013050601088013880B21080ECE718460B78A4
+:4016C0000E4C082B0E4A00D040B10E4D2B7883F080032B700F232370022301E0022323701370094B1870087030BD00BF4C93FF1F4893FF1F00600040C492FF1FC192FF1F34
+:40170000D692FF1FD292FF1F4993FF1F074B02221A70074B80221A70064B0F221A70064A00231370054A012013707047D692FF1FD292FF1FC192FF1F4893FF1F4993FF1F11
+:4017400030B5164B16491B780A8803F00F03023BDBB21A4492B20A80124C134A0020118889B279B173B15568215C013BC9B229705168DBB20131516011880130013989B2B5
+:401780001180ECE7094A1370094A137883F080031370084B0B221A7030BD00BF296000404C93FF1F00600040C492FF1F4993FF1FD292FF1FC192FF1F064A06231370064ACF
+:4017C00001201370054B80221A70054B00221A70704700BFD692FF1FC192FF1FD292FF1F4993FF1F054B9A683AB19A68044910709A680988518000229A607047C492FF1F2D
+:401800004C93FF1F08B5124B1A78D2B21A701B78DBB21A0602D50F4A137008BD0220FFF7E1FF0D4B1B7803F06003202B05D0402B06D043B900F012FC04E001F0A5FB01E04F
+:4018400000F046FD10B9034B03221A7008BD00BF28600040C192FF1F0060004008B5084A084B0120197813880B449BB21380064B00221A70FFF7B6FF044B03221A7008BDC9
+:401880004C93FF1F4893FF1FD692FF1FC192FF1F08B50C4B1B78DBB2042B07D0062B09D0022B0DD1BDE80840FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A70E0
+:4018C00008BD00BFD692FF1FC192FF1F08B5054B002201201A70FFF785FF034B03221A7008BD00BFD692FF1FC192FF1F08B50A4B1A7832B11A78094942F080020A700022E6
+:401900001A70074B002201201A70FFF76BFF054B03221A7008BD00BFC092FF1F08600040D692FF1FC192FF1F074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF742
+:40194000C5BFFFF7D3BF7047D692FF1F38B51D4C2378DBB2DD0634D518060AD503F00F03012B2ED1FFF74EFF174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5DF
+:40198000FFF786FF23781B061BD4104B1A78104B1B7813430F4A13701278934211D10A4A0849154613782078DBB2000605D41378DBB20B700B7803F00F0328788342F1D1E2
+:4019C00038BD38BD28600040C192FF1FD292FF1F4993FF1F29600040054A00231380054A916819B191680B7092685380704700BF4C93FF1FC492FF1F0E4808B503889BB255
+:401A000013B9FFF783FE13E00B4B02221A700B4B00221A70FFF7E0FF094AD1799379028843EA012392B2934238BF0380FFF728FE012008BDC492FF1FD692FF1FD292FF1F00
+:401A400000600040084B01221A700F3B9B7C074B1A7B02F00302012A1EBFDA7B82F08002DA7301225A7370470B600040DC92FF1F094B02221A700F3B93F82230074B1A7EF8
+:401A800002F00302012A1EBFDA7E82F08002DA7601225A76704700BF0B600040DC92FF1F0B4B04221A700F3B93F83230094B93F8242002F00302012A1EBF93F8272082F048
+:401AC000800283F82720012283F82520704700BF0B600040DC92FF1F0B4B08221A700F3B93F84230094B93F8302002F00302012A1EBF93F8332082F0800283F833200122D0
+:401B000083F83120704700BF0B600040DC92FF1F7047FFF741BC0000F0B5184B184E19780C27C9B201234FF0000C31B3CA0720D5144A4FEA031E7244947850782040C5074E
+:401B40000DD507FB03652C79240608D5147804F0FE0414706D790C4CEDB204F80E50840706D507FB036425792D0658BF84F801C090700133DBB24908D7E7F0BD9F60004080
+:401B8000DC92FF1F70600040FE5F004000F0ACBC70B50446184B88B003AA03F11006154618685968083303C5B3422A46F7D11B782B70FCB12223237001AD0323284663703F
+:401BC00000F08AFE002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143C0132082AC1700371417100F10400EAD108B070BD573A00002DE9F043B7
+:401C00001C4D01222E460C201F274FF0800E4FF0080C194B00FB02581401234418705F70164998F805902144B9F1000F07D098F8044024064CBF887081F802C001E081F877
+:401C400002E000FB0261CC880132E4B29C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307215971D4D1054BFF221A70BDE8F08300BFDC92FF1F70600040FC5F004028
+:401C80000A600040064B074A1B7802EBC30253681A7C824286BF03EBC003586900207047D092FF1FB83A00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFEA
+:401CC000A8463F4AC3681478007ADFF800C1E4B203EBC0000C2600274FF0010E834268D01A78A24263D11CF80420597891425ED19A7893F8039002F07F0206FB02FA05EB77
+:401D00000A01CF7093F802B009F0030981F804B093F803B005F80AB0B3F804A0A1F808A093F902A0BAF1000F0BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E007
+:401D400009E0B9F1010F0CBF4FF005094FF0090981F805904F704FEA02191A4906FB0282494481F802E0B2F808A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F81A
+:401D800006A011495FFA8AFA494481F806A0B2F80690C9F3072981F80790B2F806905FFA89F981F80490D288C2F307224A71083394E7BDE8F88F00BFD592FF1FDC92FF1F91
+:401DC000D192FF1FFC5F004070600040C292FF1F08B5064B18780138C0B2FFF753FF20B143681B7900EBC300406908BDD592FF1F00212DE9F84F0B464E4E0C2707FB01F46E
+:401E000001313219092933554FF000059370494CD3701381937253705371EFD118B1464B1D70464B1D70464B1A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8E0
+:401E4000F8E0DB790C2713F0400F3E4B4FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB0541C36803EB02094B4531D093F802A00AF07F06AE4229D10E89B3F8A4
+:401E800004B0B6B25E4538BFA1F808B01E7893F801B01EF80660B3451AD181F804A0DE780E7093F902A0DE78BAF1000F06F0030607DA012E0CBF07260D264E7181F80180C8
+:401EC00006E0012E0CBF052609264E7181F801C00833CBE70135092DC3D1C1680A328B1C0A440C200833934209D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF737
+:401F000067FF114B0121186000230C2000FB0142D3801289013113449BB203F00102134409299BB2F2D1BDE8F84FFFF767BEBDE8F88F00BFDC92FF1FC292FF1F4A93FF1F7A
+:401F4000D592FF1FD392FF1FD892FF1F114B1B7903F07F035A1E072A19D80F490C2202FB031291781B0141F0010191700021D170517841F002015170127912F0800F074A54
+:401F80001A4414BF8D2389239370FFF715BC0020704700BF00600040DC92FF1FFC5F004030B4194B1A7902F07F02531E072B27D8164B0C2404FB02339978154D01F0FE0155
+:401FC00099700021D97029461201505D114400F07F0050555A7802F0FD025A701A795B78120605D5012B01D18C7006E00D2303E0012B0CBF082309238B7030BCFFF7DCBB3C
+:40200000002030BC704700BF00600040DC92FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2FFF72EFE43681B798B4201D2012909D8074A0848535CDBB24354A378F6
+:402040000120DBB2535410BD002010BDD592FF1F00600040C292FF1F4A93FF1F38B58A4A8A4C13780021DBB221801806517840F18D800A2900F20581DFE811F05D00030155
+:4020800003010301030103010B0003017E0003018200D3787C49012B09D17D4B1A787D4B03EBC2035B685B686360122310E0CB78022B12D18878FFF7E5FD002800F0E18000
+:4020C000436863606368DA7863689B7843EA02232380BDE83840FFF78FBCCB78032B26D16D4B00228878D5B2854209D3664A91786A4AEE2908BF1346634A917881B106E046
+:40210000187801320028F1D018780344EAE764499278097C914203D16248FFF739FD614B1A78002A00F0AD801A78228018E0BDE8384000F029BF13F0030313D0022B40F0A3
+:40214000A0802380504B0C211B7903F07F02564B01FB02339A78554BD2B21A7000225A706360B6E702222280514A11784F4AC9B2117053706260ACE7012323804D4BEFE722
+:402180000123238013794C4A1344E9E701390A2977D8DFE801F037764F76067676760A7620009378454ADBB25AE0937803F0FF0153B9404B1A7891425FD01970404B012062
+:4021C0001870FFF715FE58E0481EC0B2FFF75AFD0028EED155E0FFF71DFF002851D02A4A384913791279DBB2D2B20A70364A3249D25CCB5C9A4240D0314B01221A70FFF788
+:4022000053FD3AE003F00303012B2BD009D3022B37D11D4B9B78002B33D1BDE83840FFF7BFBE194B9B78012B2BD1214A137803F0FD0315E003F00303012B13D008D3022B3C
+:402240001FD1114B9B78E3B9BDE83840FFF77EBE0D4B9B78012B14D1154A137843F0020313700AE0084B1A795AB998781B791749DBB2CA5C22EA0002CA54BDE83840FFF71A
+:402280009BBA002038BD00BF00600040C492FF1FD092FF1FB83A00001C3B0000A43A00008F3B00006893FF1FDC92FF1F8192FF1FD392FF1FD592FF1FC292FF1FC092FF1FB0
+:4022C000D492FF1FD192FF1F4A93FF1FD792FF1F074B1A78120609D55B78012B06D1054B054A5A6012781A80FFF786BB0020704700600040C492FF1F7C3A0000014B18707E
+:40230000704700BF7B650040014B1878704700BF6B640040014B1870704700BF75650040064A0123136002F688321268E0211064034A1170A2F540721360704780E100E038
+:4023400000E400E0014B1870704700BF7E640040014B1870704700BF7D64004073B515461E460B4C05230022019200920A4601461846237000F064F932462946207800F0D1
+:402380001FF90221207800F009F9207802B070BDD080FF1F064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B04221A607047FE
+:4023C00000E100E0014B04221A60704780E100E0014B1870704700BF78650040704738B505460078012428B100F066FD285D0134E4B2F8E738BD08B50D2000F05DFDBDE81C
+:4024000008400A2000F058BDF7B516461F460B4C00230325019300930A4601462846257000F00EF93A463146207800F0C9F80221207800F0B3F8207803B0F0BDE080FF1F52
+:40244000F7B516461F460B4C00230225019300930A4601462846257000F0F2F83A463146207800F0ADF82946207800F097F8207803B0F0BDE180FF1FF7B516461F460B4CCE
+:4024800000230125019300930A4601462846257000F0D6F83A463146207800F091F80221207800F07BF8207803B0F0BDE280FF1F73B515461E460B4C0023019300930A46DE
+:4024C00001461846237000F0BBF832462946207800F076F80221207800F060F8207802B070BD00BFE380FF1F024B1878C0F38010704700BF8F450040074A7F2380211370A9
+:402500005170064A013BDBB202F80839002BF9D1034A1370704700BFE480FF1FF87B00400078004017280FD8084B0001C25C11B142F0200201E002F0DF02C254C25C42F096
+:402540000102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C254C25C02F0DF02C25400207047012070471070004017280DD8074900010B460344B6
+:402580001A7942F004021A71435C43F00103435400207047012070471070004017280BD8064A0001835C490003F0F10301F00E0119438154002070470120704710700040C7
+:4025C00041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F5EC4081809ABFC280002001207047000017289FBF034B00011954002088BF012020
+:40260000704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120704700BF1470004017289FBF034B0001185C00F0070088BFFF207047147000402E
+:40264000172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF8082003F00F0343EA0213DBB263709DF80C30002003F00F03A370E07010BD012010BDC8
+:4026800010B500F079FC0A4A5378182B0AD91478013B5370E30003F1804303F5F0431B78137000E0FF2400F06BFC204610BD00BFE480FF1F030610B5044611D400F05CFC32
+:4026C000084AE300117803F1804303F5F04319705378147001335370BDE8104000F050BC10BD00BFE480FF1F30B504060CD411F4704509D1C40004F1804404F5F0442180BE
+:40270000A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280002001207047000038B50446084DB4F5004F05D9286800F017FCA4F50044F6E70B
+:40274000034B58686043BDE8384000F00DBC00BFEC80FF1F024B1B7A584300F005BC00BFEC80FF1F0E4B00F003001A78490102F0FC02104318701A7801F0600142F0800287
+:402780001A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF83430040014B01221A70704784430040044B00F00F021B6853F8220043F82210C4
+:4027C000704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BF08ED00E000F01F0000F16040490100F56440C9B2017070470F4B10B50F490024CC
+:402800000F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72DB68B3FBF2F3084A1360084B4FF400421C60C3F8E82010BD8492FF1FA5280000F5
+:4028400010E000E0EC80FF1F14E000E018E000E0024A136843F002031360704710E000E008B5FFF7F5FF034A136843F00103136008BD00BF10E000E010B5054CA3691BB9F6
+:40288000FFF7BAFF0123A361BDE81040FFF7E8BF8492FF1F024B1868C0F30040704700BF10E000E038B5FFF7F5FF012808D1054D002455F8243003B198470134052CF8D1C3
+:4028C00038BD00BF8892FF1F024B03EB80035868596070478492FF1F134B144A1B78DBB20360127843EA0223114A0360127843EA0243104A0360127843EA026303600E4B60
+:402900000E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA02634360704700BF0301004904010049EC46004002010049010100490001004991
+:40294000050100490601004910B500F015FB204A044613780A2043F002031370137C43F00203137412F80A3C43F0010302F80A3C937943F00103937102F5AB52137843F0C1
+:4029800003031370134B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222183B1A70094A137843F008031370FFF7CAFE4B
+:4029C000064B10222046BDE810401A6000F0D8BAAB4300400E5900402F5B004080E200E008B500F0C9FA0F4A137803F0FE031370A2F5AA521D3A137803F0FD031370137CD7
+:402A000003F0FD03137412F80A3C03F0FE0302F80A3C937903F0FE039371BDE8084000F0AFBA00BF08590040044A137803F03F0343EA8010C0B21070704700BF085900401A
+:402A4000082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FB1F
+:402A8000F1F305490B60054B1A8070470A590040683A00005293FF1F5493FF1F5893FF1F08B5102000F0A6F907210420FFF79AFE07490420FFF788FE064A0C20137843F002
+:402AC00006031370FFF7BCFF034B00221A8008BD992B0000095900405093FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF72ABFA092FF1F044B1A7802F0FB0262
+:402B00001A701A7842F001021A7070470859004010B5084B1C7814F0010403D10028F9D0002404E02046FFF715FE024B1B78204610BD00BF09590040034A044B1B88108826
+:402B4000181A00B2704700BF5893FF1FA25B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BFCA
+:402B80005B42134493FBF1F000B270475293FF1F5493FF1F5093FF1F7047000010B500F0EBF9214A044613780A2043F001031370137C43F00103137412F80A3C43F00203F7
+:402BC00002F80A3C937943F00203937102F5AA521832137843F003031370144B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F5CD
+:402C000097530222123B1A70094A137843F008031370FFF79FFD074B08222046BDE810401A6000F0ADB900BFAB43004006590040275B004080E200E008B500F09DF90F4AAB
+:402C4000137803F0FE031370A2F5AA52153A137803F0FE031370137C03F0FE03137412F80A3C03F0FD0302F80A3C937903F0FD039371BDE8084000F083B900BF005900406D
+:402C8000044A137803F03F0343EA8010C0B21070704700BF00590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910102D
+:402CC0000A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A80704702590040723A00005E93FF1F6493FF1F5C93FF1F08B5102000F084F8A9
+:402D000007210320FFF76EFD07490320FFF75CFD064A0C20137843F006031370FFF7BCFF034B00221A8008BDF12D0000015900406093FF1F10B5054C23781BB9FFF7DCFFC0
+:402D400001232370BDE81040FFF728BFA192FF1F044B1A7802F0FB021A701A7842F001021A7070470059004010B5084B1C7814F0010403D10028F9D0002404E02046FFF7A0
+:402D8000E9FC024B1B78204610BD00BF01590040034A044B1B881088181A00B2704700BF5C93FF1FA05B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B8A
+:402DC0001B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270475E93FF1F6493FF1F6093FF1F70470000034A00F0F80013780343137066
+:402E0000704700BF02410040034A00F0F800137803431370704700BF06410040014B1870704700BF77650040014B1870704700BF7465004073B515461E460B4C04230022C3
+:402E4000019200920A46014618462370FFF7F8FB324629462078FFF7B3FB02212078FFF79DFB207802B070BDFC80FF1F074A0223136002F688321268E0215064044A1170A6
+:402E80006FF440710A441360704700BF80E100E001E400E0014B1870704700BF78640040014B1870704700BF7B640040014B1870704700BF79650040FEB5494652465B460F
+:402EC0000EB40746244909688A46244A12682448022100F071F8030020480068C018204900F06AF8143883460121C9430C460125002600F041F8814651460B7823400B7016
+:402F00005846013000F030F83800F04028400B78234003430B70584600F026F80136072EF2D9002001300138013001200B78234003430B705846043000F016F8484600F07F
+:402F40001FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F00C20100000000000230800803D000BF01380046FCD17047EFF3108072B67047A4
+:402F800080F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F02044B01FB02339B7A00E013790020704700600040DC92FF1F002902D0B0FBF1F0F4
+:402FC000704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BF014B1868704700BF6081FF1F0E4B70B51E460E4C0025E41AA410A54204D056F8C7
+:40300000253098470135F8E700F0DEFD084B094C1E46E41AA4100025A54204D056F8253098470135F8E770BDD43B0000D43B0000D43B0000DC3B000003460244934202D0A0
+:4030400003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF40273ADF80C300CBF234604F1FF33029305934FF6FF7300910491ADF80E300246EB
+:403080001E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000007B5009313460A46014603480068FFF7CBFF03B05DF804FB6081FF1F2DE9F04703
+:4030C0008E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656905EB450595FBF3F57B1C43449D4238BF1D4653050FD5294600F04AFB064698B1FA
+:403100003A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B92169504600F0E8FA0C23CAF80030A3894FF0FF3043F04003A381BDE8F087266174
+:403140003E44266046466561ED1BA560464528BF464649463246206800F0B3FAA36800209B1BA36023681E442660BDE8F08700002DE9F04F9DB003938B8980461C060D46C4
+:4031800016460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B610023099320238DF82930DFF89CB130238DF82A3037463C4614F8013B1BB9B7EB2C
+:4031C000060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780099B4B4409933B78002B00F0A08000234FF0FF3204930793059206938DF8533038
+:403200001A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F018430490EFE7D90644BF20228DF853201A0744BF2B228DF8532022782A2A03D0079AE1
+:4032400000210A200BE0039A111D12680391002A10DA524243F00200079204900BE027463B780134303B092B03D800FB02320121F5E701B107923B782E2B1ED17B782A2BC0
+:403280000AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781C0A2407463A780130303A092A03D804FB01210123F5E703B1059103223978224843
+:4032C00000F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1C8DF8281000F0D4F988B1194B33B9039B073323F007030833039314E003AB00936E
+:403300002A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F1FF3F824603D0099B5344099342E7AB895B0601D4099801E04FF0FF301DB0BDE883
+:40334000F08F00BFA33B0000A93B0000AD3B000000000000BD3000002DE9F04791461F460A698B6806469342B8BF1346C9F8003091F843200C46DDF8208012B10133C9F83C
+:4033800000302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E00123524639463046C04701301AD00135E368D9F800209B1A9D42F1DB94F843306A
+:4033C0002268003318BF012392060FD5E118302081F843005A1C94F845102244023382F8431003E04FF0FF30BDE8F08704F1430239463046C0470130F4D02268D9F8005092
+:40340000E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED184FF000091A344D4509D00123224639463046C0470130D5D009F10109F3E700207C
+:40344000BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8011D8632A22D009D8002A00F0BB80582A40F0CA8081F84520834955E0642A1ED0BC
+:40348000692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A603EE0752A24D0782A3AD0ADE01A6801F14205111D1960136884F84230A8E02168C0
+:4034C0001A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E01368002B3CDA2D225B4284F8432037E021681A6811F0800F02D0111D196007E072
+:4035000011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE078225A4984F845202268186812F0800F00F104051D6003D1550601D5038800E061
+:403540000368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E049490A226568002DA56008DB206820F0040020602BB9002D7DD175460CE0002B3D
+:4035800079D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0708D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0323612EE008681A687C
+:4035C00010F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198000E0196000232361754616E01A68111D1960156800216268284600F049F808B172
+:40360000401B6060636804E004F1420584F8422001232361002384F84330CDF800803B4603AA21463046FFF797FE013002D14FF0FF3026E023692A4639463046C047013070
+:40364000F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B7804F1420584F8423012
+:403680008AE705B0BDE8F083573A0000B43B000010B5C9B202449042034605D01C7801308C42F8D1184610BD002010BD10B5431E0A44914204D011F8014B03F8014FF8E7C8
+:4036C00010BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014D01F8014DF8E710BD994204D011F8014B02F8014FF8E710BD38B50546002944D089
+:4037000051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A3420DD92268A018834201BF18685B681218226063600C6023E0A24203D813465A68A1
+:40374000002AF9D118681918A1420BD12168014458188242196013D110685268014419605A600DE002D90C232B6009E021686018824201BF106852680918216062605C609A
+:403780002846BDE8384000F098B838BDA892FF1F70B5CD1C25F0030508350C2D38BF0C25002D064601DBA94202D90C23336046E000F082F8234B1C681A462146A1B10B683D
+:4037C0005B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4615E00C464968E9E7174C23681BB9304600F052F820602946304600F04DF8431C4D
+:4038000018D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A0ED05A42E25070BD211A304600F034F80130EBD10C233360304600F03EF800206A
+:4038400070BD00BFA892FF1FA492FF1FF8B5074615460E4621B91146BDE8F840FFF798BF1AB9FFF749FF2846F8BD00F027F885420ED929463846FFF78BFF044650B131468C
+:403880002A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C0023054608462360FDF7D8FB431C02D1236803B12B6038BD8C93FF1F7047704751F8040C10
+:4038C0000028BEBF091851F8043CC0180438704700000000050209020B020D020F021102130215027265706C792030782530327800686F6D696E6700626567696E6E696E71
+:4039000067207365656B2066726F6D20256420746F2025640066696E6973686564207365656B00796573006E6F00647269766520303A20257320647269766520313A202589
+:40394000730057616974696E6720666F72205553422E2E2E0055534220726561647900636F6D6D616E6420307825303278006661696C2025642B25642B2564203D3D2025B5
+:40398000642C206E6F74202564007061737365643D256400756E64657272756E206166746572202564207061636B65747300636F756E743D256420693D256420643D256436
+:4039C00000636D645F777269746500703D25642063723D25642063773D256420663D256420773D256420696E6465783D256420756E64657272756E3D256400756E6465723A
+:403A000072756E2100737563636573730073746172742065726173696E670073746F702065726173696E670069646C65000051004010004051004030000000014000100080
+:403A4000140140000800400140000A004C0140000200500140200030313233343536373839414243444546000001000000040000001000010000000400000010280000002A
+:403A8000000104000100000000000000000157494E5553420000303030303100000000000000000012034D005300460054003100300030000100000001000000C03A00005A
+:403AC000010000008F3B0000000000000000000001000000D83A000001000000613B000004000000FA3A0000000000000000000000000000F83A0000FF000000010240009F
+:403B0000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500780045006E00670069006E0065002A0343006F0077006C00CF
+:403B4000610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010080320904000004FF00000107050102400000070582024000E6
+:403B8000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B2000686C4C00656667454647003031323334353637383961629F
+:403BC0006364656600000000F8B500BFF8BC08BC9E46704759000000D5100000F8B500BFF8BC08BC9E46704735000000003C0000C880FF1FA0000000281200000000000046
+:403C0000000000009093FF1FFF000000675000400C00000007000000FFFFFFFF7F8000003F0000000000C05D80BB000030000000006CDC02FF00000000000000000000002F
+:403C4000000000000000000000000000000000000000000000000000A13B000000000000000000000000000000000000000000000000000000000000000000000000000068
+:403C80000000000000000000000000000000000000000000000000000081FF1F00000000000000000000000000000000000000000000000000000000000000000000000065
 :403CC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C4
 :403D00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083
 :403D40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043
@@ -4098,52 +4098,52 @@
 :40FF80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041
 :40FFC0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
 :0200000480007A
-:400000000145004009520040015B0040016500400101014003030140010501400307014052080140500901404F0A0140480B0140490C0140470D0140400E0140360F01409E
-:4000400002150140031701405C18014057190140471A0140531B01400B400140124101400B4201400D43014002440140074501400B4601400C470140104801401149014069
-:40008000154C01400D4D014005500140045101407E02080209411080110218041902600C61157C402721290AE204E601EA20EE02E202E608EA10EE04000801080404050568
-:4000C0000708080809080C400D080E1011011201130E143A16401708180819081C021E042305240825042701280629082A782C202D012E402F02307F310F327F330F380AE4
-:400100003B0A580459045B045C995F018203830187018A108C018D018E248F08907C9282930E961097019A809D019E1C9F04A101A210A302A510A610AA10AB01AC01AE48FD
-:40014000B01FB10FB4F0B510BA20BB02BF10D608D80BD90BDB04DC99DD90DF01012202010488051007800A860B100C020DA00E2011011208134414021504162017201804BE
-:4001800019021A041B011CA01E202008220126012790282029202A012C022E282F4032493514360139013B443C803D2A5980614069906F0278417B0288049141928093D450
-:4001C00094249602970A982299249A019B409C019D019EC0A188A208A402A504A709B404B502B604C0FBC2FFC4EFCAF7CCEBCEFBD608D808DE01E608EA10EE0400FC0108A1
-:4002000002020310071408200AD00BE40CE10D100E080F8212031314161017141D1F1E101F4020802110223C2321261028402A302B142CE12E04301F310F33F034E03B08A2
-:40024000580B590B5B045C995F0180368209852A86128740882D89098A128B148E098F209080924093C09440968098079C249D089F13A03FA180A320A840A908ADEAB0076D
-:40028000B1E0B280B301B438B518B640B706BE44D808D904DB04DC99DF0100820120040A07050A420B100EA80F01110112091304171219201A401D8A1E081F4020602101B0
-:4002C000231025102652275029202A012C022F483249364239033B543D283E806102620169406C0C6F0178017F0187058C028D04900292809345946495029642971298206E
-:4003000099049B069C019D219E449F01A041A208A418A701B040B204B7C0C0FBC2FDC45FCAB5CC9BCE7FDE11E40800020104040806140A010C1C101012081301140215050D
-:400340001601170220032B022D062E022F0130043107320336183A083F015608580459045B045C095D905F018128829083118401853F86448A9C8C208D3F8EC090C191FFA2
-:40038000922895149690972199019A039B0E9D409E90A0FCA202A902AA90AB01ADC0AE90B140B330B41FB50FB6E0B780BA80D608D80BD90BDB04DC99DD90DF0101A604240E
-:4003C0000501070208400A240B400EA0120113121401164019801A041B401D841EA02080229C2344260129602C082F0230023294370539063A053B403F01580259025A0213
-:400400005B405F806140670168036A806B026C016F06780182019440950296E4974698209C429D209E049F02A412A580A741B240B420B540C0FFC23FC49BCA3CCCCFCE8BAA
-:40044000D618D818DE01EA20EE0203900401060407900A100B9C0D010E100F4812101520161017C01A031B031DFC1E1C1F02201C2202239025C127242A102B902C012E08A9
-:400480002F9033E0341F351F3B08420147E0482049FF4AFF4BFF4F83580859085A045B045C995D095F018310871C8B108D018F0893109F03A310A501A704AB10AD1CAF0254
-:4004C000B71FD908DB04DC90DF0100400120032008420A281110134219101A0820042120220826802701284229202A042B202C422D202F20312032483402368039123B4544
-:400500003C203D103F454180520159105A445B0160046208638269406E8078807C807F018201C007C20FC40BCAFFCC9ECEFFD008D60FD80FDE18EA01EE08E020E623EE0BF2
-:40054000022005880612083209880C080E010F011049118812321432151017A0182119461A1C1BB81D9A1E091F20206321422204230424322588282029882A022C322D04B6
-:400580003020313F324033C1341F37C1398A3A203E055608580459045B045C995D905F018401860289018D028E039002920199089B049D049F08A004B002B102B204B304D8
-:4005C000B401B501B708B822B988BE15BF55C043C520C802C9FFCAFFCBFFCD20CEF0D110D804D904DA04DB04DD09DF01E108E240E340E480E640E740000801400320051496
-:40060000060107400A800D800EA8108016441799181019021B101C401E081F0420012111220424A02505264227A02D202F52324033203504360137A039903C243E4040504B
-:40064000488049204A0459405A205D045E085F4064016580670268046A806C036E406F01831085118B4491D0938094A89504970A984099449B509C019D119EC89F20A0500A
-:40068000A188A211A402A535A708A980C0F5C2F8C4F8CAF0CCFCCE7CD003D61CD810E022E620EA04EE0B010129022C013102350136013E403F115608580459045B045D9048
-:4006C0005F0180478208830885218626874E880189018A388B708D4E8E40914E92029426974E98269B029D809E11A010A201A321A520A604A701A811AA26AB04AC26AD0FF1
-:40070000AF10B040B380B43FB57FB63FBAA0BB20BF04C003C50EC70CC811C9FFCAFFCBFFD004D601D804D904DA04DB04DC99DD09DF01E2C0040205940DA20E201002150580
-:40074000162017A01B401D111E011F102040221024042530260827082B042E642F40344035043602371038013C803D283E0145084F04570858905C406001630868026C042B
-:400780006D016E046F02768981028410860888808D028E049002910492409380940C96209724984099869A049BB09D119E899F08A040A18CA212A530A74AA881AE04B74049
-:4007C000C0F0C2F0C4F1CAF4CCF0CEF1D040D61CD80CE008E404E602E8041B011F083180330836843B408340C630CCF0CE10E22032043380364037023B043F808180A0042B
-:40080000A340A580A604AE80AF41B004CCF0CE60E680EE40531057208510960897049F02A004A644A780D460E240860491209608972498809F02A004A640A7A0AA04B48062
-:40084000E610EE201680C40458405E019A80A404AC04D401D6011B04844096019C40A404A710B680B710C608EA08EE0808080B080E020F4087048A209601A404A710AB043D
-:40088000C20FE00425808004871089808B04912097249880A004A720AB02AE40AF80C820E6C0EED0511054045880700477809008912098809B80A004AB80AF20D4E0DC8000
-:4008C000DE20EA80EE1005200A400C100F201C0852225620610186029641A220A404A710AA41AC08AF40C001C20DC601D407D80270018001852086018810960198109920A0
-:40090000AA20B501DC01E204EC0201010D010F0111011D0100FF01AB02021105BF0000A09F001F000000000000000000100000004000000000000000C0000000FF0000B88D
-:4009400047004700000100008000000282008200000000000007070007000000270018012700180100040000000500000000000000000000000000000000000000000000C4
-:400980000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037
-:4009C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F7
-:400A000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B6
-:400A40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000076
-:400A80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036
-:400AC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F6
-:400B000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B5
-:400B40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000075
+:400000000145004009520040015B0040016400400301014002030140080501400C0701405A0801404F0901405E0A0140480B0140510C0140490D01404F0E01403E0F014057
+:40004000261401403215014028160140371701405B1801404A190140521A0140561B01400C4001400D4101400B4201400E4301400244014007450140094601400E47014042
+:400080000D4801400F490140194C01400D4D014006500140045101407E02084409021080110218011904601361197C4027212A0A8840E204E620A440EE028602980CA44036
+:4000C000A808AC04E282EA08EE04870289028A048F10980C9940A202A440AD40E64AEA01EE0C02080301041706E80701080809020A400C800D030E08100F11021408150176
+:4001000016201702181019021A071C081EF01F0220012204230224012502260628012A022B012CFF2D0330FF35033E013F105608580459045B045D905F01808081748301C8
+:400140008480867E8752884089528A108C408D528E20907E910793089524975B983E9A409B049C409D329E049FC0A040A152A202A440A552A608A87EA952AD20AE01AF8055
+:40018000B103B31CB6FFB7E0BB88BE40D804D904DB04DC90DF010008011002800301051007620A050B400D200E020F501080114412091554170119801E8020402101228854
+:4001C00023612704284029942D512F103001312032883510368939023B943C083E013F505C80640268016A406D806F08840288019140928293809408950A964097159801FC
+:400200009B089C229D159E069F20A004A128A201A401A540A648A708AC80C0FFC2FBC4FFCAFFCCFFCEFFD610D810E280E608E808EA01EE0C002001110250050106100901A8
+:400240000A030B1E0D110E1C107C110D120213221440151116301D041E1020802461260428612A082E103060310332803330341F350437083E043F1040234520480249FF27
+:400280004AFF4BFF4D204EF05110580B59045A045C995D095F0161086240634064806640674081408201840188078B128C078D368E088F0992109309940799249A069C019B
+:4002C0009D079E02A006A209A401A604A801A92DAA06AB12AC0FAD3FB140B401B507B61EB738BE10BF01D804D90BDB04DC99DF0100800122032005550A410B200E800F1598
+:400300001080112012221401154A172019221A101D401E061F40201821AA22012308244026A027042E402F0831823208342036803701381839423D903E02421448805C40CC
+:400340006D106F0178027C028701891091409281932096409C029D229E049F04A040A110A202A320A401A940AF48B340C0FFC2FDC4FFCA30CCBBCEBFD006D610DE81E2802C
+:40038000007C0160028206100710080109400A240D7C0E030F02121013031501161C1704180119011A481B081E101F1022102310268027102B102E102F1C301F311F3320DC
+:4003C000354036F03A805608580B590B5B045C995D905F01800482118314851086E08782881F89088A208B108D1F8F40901F9240951097219B149C019E1E9F14A3E4A41F55
+:40040000A680A808AA11AC02AE11AF14B1F0B30FB4F0B60FBA20BB02D80BD90BDB04DC99DF010102024003240444068007240A410C800D220F201222131014011502170861
+:4004400019C01A031B301C401F412080210223B024182530262128402A402C812D822E102F2031403324344036213784380839023A803B303C143EC03F015F40670169402A
+:4004800078027C0291029290960297129C029D629E049F04A202A441A522A621A730AA12C0FEC2F9C4B7CAF9CCFECEFFD610D810DE81EE02001C010102020306061008010D
+:4004C00009040A040B010E0312101507180119071A081E102102221023012A1C2D072E10301F3107580B590B5B045C995F0181E782908310878488208AC08B188E908F84EC
+:40050000929093849508969097229801990E9A489B419D019E039F06A29CA3E4A4C1A624A784AA90AB84ACFCAE02B21FB4E0B5F8B707BA20BB80C202C60EC804C9FFCAFF6A
+:40054000CBFFCF83D80BD90BDA04DB04DC99DD09DF01004203640552070109220A020D620F201080120213101522174418401D181F10210122022550269029022B012C803A
+:400580002D022E102F203120330436A0370539223B103C8A3D203F0245484605470848044B1057405C405E225F086520660167226A8078027C0283408D48C0DFC2FBC4FBE9
+:4005C000CAE9CCF6CEF5D020D6F0D8F0DE810A010C01130115012301260134013501382039203E103F105608580459045B045D905F018C029001930195019C04A602A902A1
+:40060000B002B204B301B401B702B802B908BE15BF44D804D904DB04DF01030507010E400F011308170418041E281F022304268027102B402F08330537055B405D805E2030
+:40064000614065C06B056E406F0883488B068C048E808F4093019F10A604A844AA10AF50B001B220B404C083C290C424CA21CCC3D638D808E204E6A0E811EA08EE035608FE
+:400680005B045D9080018505870289088D068F019002930194049510972098089B029D04A130A204A520A710A908AA08AD08B002B107B208B330B404B508B601BE41BF11A1
+:4006C000D608D804D904DB04DC99DD90DF01000208080A080B8010041302188419081A012080210822202809290A3004329238083A803B2059605F406110628067016801DA
+:4007000081088204868087408A018D209208980C99429A809B029D109F10A202A440A910B280C008C20EC40ACA0FCC0FCE0ED61CD81CE001E408E662EC04EE0A00100260BB
+:4007400003010453070209020A080B200C010D030F0410401210130115081604170119091A531BF21C011D801E021F022053210223102401250226022740280129022BFC12
+:400780002C132DFF2E203070320F340F35FF360F3A023F10580459045B045C095F018020840185028602870188208C028D018E01902094F89604970198109A039C049D0478
+:4007C0009E40A020A10BA480A508A604A813A902AAE4AC07AE08AF02B104B2FFB308B503B703BBA0BE04BF01D804D904DB04DC90DF01002A03010501072509200B920D227D
+:400800000E211365155619081C021D051F1420102180228223162610280229082A212C042D402F64324835203680372938403B043E093F506A406F027D017E808204842025
+:4008400088208E4290409142928293C19408951D9605973498029A019B2C9CE09D159E049F03A128A209A308A480AA02B140B504B740C0FFC2FFC4FFCAFFCCFACEFAE210B7
+:40088000E480E662EE2A0001011F02080401050106400704080109010A200B080C010D1F0E021001121013401401154016FE18041B1F1C801D011E011F0221012201231E7A
+:4008C00027202804291F2AF92CFF2D012F1032FF333F35403E043F10400246E0470C481849FF4AFF4BFF50045601580459045A045B045C905D095F0162C08040843286C42E
+:4009000088408C068E08922294F8960498809A049C40A040A410A602A840AE01B0FFB4FFB822D804DB04DC09DF010052032004500640072009A00B900E620F04114012402C
+:40094000132114441540170819081D101F21202421042204231029282A82312832013340351036103956400442804301502466086710680469146A416B416F02708071025A
+:40098000720683028440860490509142920293859408951C96059702980499209B289C409D109E089F01A001A1A8A201A4B4A502A720AB08AF42B320B480B620C0FFC2FFD1
+:4009C000C4FBCA0FCC0FCE0FD004E040E210E440E831EC40EE201B011F083020330836843B4083408820C630CCF0CE10E22032043380364037043B043F80A340A604AE80F7
+:400A0000AF41CCF0CE60EE405010570484408A80960897049F04A644A780D460E24086048C10942096089704A040A280A640A784AA04AB04E610EA80EE201420C40458108D
+:400A40005E019820A404AC04D401D6011B049502960198209C10A404B101C608EA0408080B080F41870495029601970199809C10A404AB05AC20AD80C20F240883048B04A7
+:400A80008E409704A040A280A704AE40AF80C820E620EE50528054405A40722076808AA09240A040A280AA80B404D4E0DC80DE20EC20070208020D811C085320568059806E
+:400AC0005F0185808A018F039502960199809C10A404AC08AF40C001C20DC601D407D601E208E40975018C028D018F209802A720AA80B010DE04E002E208E402E804010148
+:400B00000D010F0111011B011D0100FF01AB020211050000BF0000A09F001F000000000000000000100000004000000000000000C0000000FF0000B8470047000001000013
+:400B400080000002820082000000000000070700070000001D0018011D00180100040000000500000000000000000000000000000000000000000000000000000000000065
 :400B80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035
 :400BC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F5
 :400C000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B4
@@ -4615,12 +4615,12 @@
 :0200000490105A
 :04000000BC90ACAF55
 :0200000490303A
-:0200000096F078
+:0200000064D4C6
 :0200000490402A
 :4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C0
 :400040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080
 :400080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040
 :4000C0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 :0200000490501A
-:0C00000000012E16106900002E2FA759D9
+:0C00000000012E16106900002E30753D26
 :00000001FF
--- a/FluxEngine.cydsn/FluxEngine.cydwr
+++ b/FluxEngine.cydsn/FluxEngine.cydwr
@@ -272,7 +272,7 @@
        <Data key="derive_type" value="AUTO" />
        <Data key="desired_freq" value="1600000" />
        <Data key="desired_unit" value="0" />
-        <Data key="divider" value="40" />
+        <Data key="divider" value="30" />
        <Data key="domain" value="DIGITAL" />
        <Data key="enabled" value="True" />
        <Data key="minus_accuracy" value="0.25" />
@@ -390,7 +390,7 @@
        <Data key="derive_type" value="AUTO" />
        <Data key="desired_freq" value="1600000" />
        <Data key="desired_unit" value="0" />
-        <Data key="divider" value="40" />
+        <Data key="divider" value="30" />
        <Data key="domain" value="DIGITAL" />
        <Data key="enabled" value="True" />
        <Data key="minus_accuracy" value="0.25" />
@@ -604,7 +604,7 @@
        <Data key="check_tolerance" value="True" />
        <Data key="clock_version" value="v1" />
        <Data key="derive_type" value="BUILTIN" />
-        <Data key="desired_freq" value="64" />
+        <Data key="desired_freq" value="48" />
        <Data key="desired_unit" value="6" />
        <Data key="divider" value="0" />
        <Data key="domain" value="0" />
@@ -814,7 +814,7 @@
  </Group>
  <Group key="Component">
    <Group key="v1">
-      <Data key="cy_boot" value="cy_boot_v5_81" />
+      <Data key="cy_boot" value="cy_boot_v6_10" />
      <Data key="Em_EEPROM_Dynamic" value="Em_EEPROM_Dynamic_v2_20" />
      <Data key="LIN_Dynamic" value="LIN_Dynamic_v5_0" />
    </Group>
@@ -4214,7 +4214,7 @@
  </Group>
  <Group key="System3">
    <Data key="CYDEV_CONFIG_FASTBOOT_ENABLED" value="True" />
-    <Data key="CYDEV_CONFIG_UNUSED_IO" value="AllowButWarn" />
+    <Data key="CYDEV_CONFIG_UNUSED_IO" value="Disallowed" />
    <Data key="CYDEV_CONFIGURATION_ECC" value="True" />
    <Data key="CYDEV_CONFIGURATION_MODE" value="COMPRESSED" />
    <Data key="CYDEV_DEBUGGING_DPS" value="Disable" />
--- a/FluxEngine.cydsn/FluxEngine.cyprj
+++ b/FluxEngine.cydsn/FluxEngine.cyprj
@@ -2913,6 +2913,110 @@
 </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="Clock_2" persistent="">
+<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="Clock_2.c" persistent="Generated_Source\PSoC5\Clock_2.c">
+<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="Clock_2.h" persistent="Generated_Source\PSoC5\Clock_2.h">
+<Hidden v="True" />
+</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>
+<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="Clock_3" persistent="">
+<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="Clock_3.c" persistent="Generated_Source\PSoC5\Clock_3.c">
+<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="Clock_3.h" persistent="Generated_Source\PSoC5\Clock_3.h">
+<Hidden v="True" />
+</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>
+<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="Clock_5" persistent="">
+<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="Clock_5.c" persistent="Generated_Source\PSoC5\Clock_5.c">
+<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="Clock_5.h" persistent="Generated_Source\PSoC5\Clock_5.h">
+<Hidden v="True" />
+</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>
+<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="USBFS_ep5" persistent="">
+<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="USBFS_ep5_dma.c" persistent="Generated_Source\PSoC5\USBFS_ep5_dma.c">
+<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="USBFS_ep5_dma.h" persistent="Generated_Source\PSoC5\USBFS_ep5_dma.h">
+<Hidden v="True" />
+</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>
@@ -3480,8 +3584,8 @@
 </platforms>
 <project_current_platform v="c9323d49-d323-40b8-9b59-cc008d68a989" />
 <last_selected_tab v="Cypress" />
-<WriteAppVersionLastSavedWith v="4.2.0.641" />
-<WriteAppMarketingVersionLastSavedWith v=" 4.2" />
+<WriteAppVersionLastSavedWith v="4.4.0.80" />
+<WriteAppMarketingVersionLastSavedWith v=" 4.4" />
 <project_id v="ff3eb327-f593-4eb3-a00f-72497469e963" />
 <GenerateDescriptionFiles v="False" />
 </CyGuid_49cfd574-032a-4a64-b7be-d4eeeaf25e43>
@@ -3493,9 +3597,7 @@
 <library_dep persistent="${CyRoot}\psoc\content\default\CyAnnotationLibrary\CyAnnotationLibrary.cylib\CyAnnotationLibrary.cyprj" />
 </library_deps>
 <CyGuid_b0d670ad-d48f-47cb-9d0b-b1642bab195c type_name="CyDesigner.Common.Base.CyExprTypeMgr" version="1" />
-<ignored_deps>
-<library_dep persistent="C:\Users\dg\Documents\PSoC Creator\4.1\Downloads ( 4.1).cylib\Downloads ( 4.1).cyprj" />
-</ignored_deps>
+<ignored_deps />
 </CyGuid_495451fe-d201-4d01-b22d-5d3f5609ac37>
 <boot_component v="" />
 <current_generation v="150" />
--- a/FluxEngine.cydsn/Sequencer/Sequencer.v
+++ b/FluxEngine.cydsn/Sequencer/Sequencer.v
@@ -20,13 +20,14 @@ module Sequencer (

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

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

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

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

-reg oldindex;
-wire indexed;
-always @(posedge clock) oldindex <= index;
-assign indexed = !oldindex && index;
-
 always @(posedge clock)
 begin
    if (reset)
@@ -65,7 +61,7 @@ begin
                if (dataclocked)
                begin
                    pulsepending <= opcode[7];
-                    countdown <= opcode[5:0];
+                    countdown <= opcode[5:0] - 1; /* compensate for extra tick in state machine */
                    
                    state <= STATE_WRITING;
                end
@@ -76,12 +72,15 @@ begin
                if (sampleclocked)
                begin
                    if (countdown == 0)
-                        state <= STATE_LOAD;
+                        state <= STATE_WAITING;
                    else
                        countdown <= countdown - 1;
                    sampleclocked <= 0;
                end
            end
+            
+            STATE_WAITING:
+                state <= STATE_LOAD;
        endcase
    end
 end
--- a/FluxEngine.cydsn/TopDesign/TopDesign.cysch
+++ b/FluxEngine.cydsn/TopDesign/TopDesign.cysch
--- a/FluxEngine.cydsn/main.c
+++ b/FluxEngine.cydsn/main.c
@@ -79,6 +79,7 @@ CY_ISR(index_irq_cb)
     * the track. */
    static bool hardsec_index_irq_primed = false;
    static uint32_t hardsec_last_pulse_time = 0;
+    uint32_t index_pulse_duration = clock - hardsec_last_pulse_time;

    if (!hardsec_index_threshold)
    {
@@ -87,12 +88,18 @@ CY_ISR(index_irq_cb)
    }
    else
    {
-        index_irq = hardsec_index_irq_primed;
+        /* It's only an index pulse if the previous pulse is less than
+         * the threshold.
+         */
+        index_irq = (index_pulse_duration <= hardsec_index_threshold) ?
+            hardsec_index_irq_primed : false;
+
        if (index_irq)
            hardsec_index_irq_primed = false;
        else
            hardsec_index_irq_primed =
-                clock - hardsec_last_pulse_time <= hardsec_index_threshold;
+                index_pulse_duration <= hardsec_index_threshold;
+
        hardsec_last_pulse_time = clock;
    }
    
@@ -275,7 +282,6 @@ static void seek_to(int track)
        CyWdtClear();
    }
    CyDelay(STEP_SETTLING_TIME);
-    
    TK43_REG_Write(track < 43); /* high if 0..42, low if 43 or up */
    print("finished seek");
 }
@@ -305,7 +311,7 @@ static void cmd_measure_speed(struct measurespeed_frame* f)
    while (!index_irq)
    {
        elapsed = clock - start_clock;
-        if (elapsed > 1000)
+        if (elapsed > 1500)
        {
            elapsed = 0;
            break;
@@ -416,7 +422,6 @@ static void cmd_read(struct read_frame* f)
    seek_to(current_track);
    SIDE_REG_Write(f->side);
    STEP_REG_Write(f->side); /* for drives which multiplex SIDE and DIR */
-    
    /* Do slow setup *before* we go into the real-time bit. */
    
    {
@@ -562,7 +567,6 @@ static void cmd_write(struct write_frame* f)
    seek_to(current_track);    
    SIDE_REG_Write(f->side);
    STEP_REG_Write(f->side); /* for drives which multiplex SIDE and DIR */
-    
    SEQUENCER_CONTROL_Write(1); /* put the sequencer into reset */
    {
        uint8_t i = CyEnterCriticalSection();        
@@ -627,7 +631,6 @@ static void cmd_write(struct write_frame* f)

                /* Wait for the index marker. While this happens, the DMA engine
                 * will prime the FIFO. */
-
                hardsec_index_threshold = f->hardsec_threshold_ms;
                index_irq = false;
                while (!index_irq)
@@ -693,7 +696,7 @@ abort:
 static void cmd_erase(struct erase_frame* f)
 {
    SIDE_REG_Write(f->side);
-    seek_to(current_track);    
+    seek_to(current_track);
    /* Disk is now spinning. */
    
    print("start erasing");
--- a/30
+++ b/30
@@ -1,21 +1,23 @@
-PACKAGES = zlib sqlite3 libusb-1.0
+PACKAGES = zlib sqlite3 libusb-1.0 protobuf

-export CFLAGS = --std=c++14 -ffunction-sections -fdata-sections
-export LDFLAGS =
+export CFLAGS = -x c++ --std=c++14 -ffunction-sections -fdata-sections
+export LDFLAGS = -pthread

 export COPTFLAGS = -Os
-export LDOPTFLAGS = -Os -s
+export LDOPTFLAGS = -Os

 export CDBGFLAGS = -O0 -g
 export LDDBGFLAGS = -O0 -g

 ifeq ($(OS), Windows_NT)
+export PROTOC = /mingw32/bin/protoc
 export CXX = /mingw32/bin/g++
-export AR = /mingw32/bin/ar rcs
+export AR = /mingw32/bin/ar rc
+export RANLIB = /mingw32/bin/ranlib
 export STRIP = /mingw32/bin/strip
-export CFLAGS += -I/mingw32/include/libusb-1.0
+export CFLAGS += -I/mingw32/include/libusb-1.0 -I/mingw32/include
 export LDFLAGS +=
-export LIBS = -static -lz -lsqlite3 -lusb-1.0
+export LIBS += -L/mingw32/lib -static -lz -lsqlite3 -lusb-1.0 -lprotobuf
 export EXTENSION = .exe
 else

@@ -25,21 +27,31 @@ $(warning These pkg-config packages are installed: $(shell pkg-config --list-all
 $(error You must have these pkg-config packages installed: $(PACKAGES))
 endif

+export PROTOC = protoc
 export CXX = g++
-export AR = ar rcs
+export AR = ar rc
+export RANLIB = ranlib
 export STRIP = strip
 export CFLAGS += $(shell pkg-config --cflags $(PACKAGES))
 export LDFLAGS +=
-export LIBS = $(shell pkg-config --libs $(PACKAGES))
+export LIBS += $(shell pkg-config --libs $(PACKAGES))
 export EXTENSION =
+
+ifeq ($(shell uname),Darwin)
+AR = ar rcS
+RANLIB += -c -no_warning_for_no_symbols
 endif

+endif
+export XXD = xxd
+
 CFLAGS += -Ilib -Idep/fmt -Iarch

 export OBJDIR = .obj

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

 clean:
 	@echo CLEAN
--- a/README.md
+++ b/README.md
@@ -4,6 +4,11 @@ FluxEngine
 (If you're reading this on GitHub, the formatting's a bit messed up. [Try the
 version on cowlark.com instead.](http://cowlark.com/fluxengine/)

+**Breaking news!** As of 2021-05-21, the command line environment has changed
+_substantially_ (to make it more consistent and flexible, and allow some new
+backend features like multi-format IBM scheme disks, which are popular with
+CP/M). If things don't work the way you expect, please check the documentation.
+
 What?
 -----

@@ -24,6 +29,14 @@ Don't believe me? Watch the demo reel!
 <iframe width="373" height="210" src="https://www.youtube.com/embed/m_s1iw8eW7o" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 </div>

+**New!** The FluxEngine client software now works with
+[GreaseWeazle](https://github.com/keirf/Greaseweazle/wiki) hardware. So, if you
+can't find a PSoC5 development kit, or don't want to use the Cypress Windows
+tools for programming it, you can use one of these instead. Very nearly all
+FluxEngine features are available with the GreaseWeazle and it works out-of-the
+box. See the [dedicated GreaseWeazle documentation page](doc/greaseweazle.md)
+for more information.
+
 **Important note.** On 2020-04-02 I changed the bytecode format (and firmware).
 Flux files will need to be upgraded with `fluxengine upgradefluxfile`. The new
 format should be more reliable and use way, way less bandwidth. Sorry for the
@@ -52,8 +65,15 @@ following friendly articles:
  - [Using a FluxEngine](doc/using.md) ∾ what to do with your new hardware ∾
    flux files and image files ∾ knowing what you're doing

-  - [Troubleshooting dubious disks](doc/problems.md) ∾ it's not an exact science ∾
-    the sector map ∾ clock detection and the histogram
+  - [Using GreaseWeazle hardware with the FluxEngine client
+	software](doc/greaseweazle.md) ∾ what works ∾ what doesn't work ∾ where to
+	go for help
+
+  - [Troubleshooting dubious disks](doc/problems.md) ∾ it's not an exact
+	science ∾ the sector map ∾ clock detection and the histogram
+
+  - [Checking your drive](doc/driveresponse.md) ∾ you can't do that with that ∾
+	measuring your drive's ability to work with exotic formats

 Which?
 ------
@@ -70,20 +90,20 @@ people who've had it work).

 ### Old disk formats

-| Format                                   | Read? | Write? | Notes |
-|:-----------------------------------------|:-----:|:------:|-------|
-| [IBM PC compatible](doc/disk-ibm.md)     |  🦄   |   🦄   | and compatibles (like the Atari ST) |
-| [Acorn ADFS](doc/disk-acornadfs.md)      |  🦄   |   🦖*  | single- and double- sided           |
-| [Acorn DFS](doc/disk-acorndfs.md)        |  🦄   |   🦖*  |                                     |
-| [Ampro Little Board](doc/disk-ampro.md)  |  🦖   |   🦖*   |                                     |
-| [Apple II DOS 3.3](doc/disk-apple2.md)   |  🦄   |        | doesn't do logical sector remapping |
-| [Amiga](doc/disk-amiga.md)               |  🦄   |        |                                     |
-| [Commodore 64 1541](doc/disk-c64.md)     |  🦖   |        | and probably the other GCR formats  |
-| [Brother 120kB](doc/disk-brother.md)     |  🦄   |        |                                     |
-| [Brother 240kB](doc/disk-brother.md)     |  🦄   |   🦄   |                                     |
-| [Brother FB-100](doc/disk-fb100.md)      |  🦖   |        | Tandy Model 100, Husky Hunter, knitting machines |
-| [Macintosh 800kB](doc/disk-macintosh.md) |  🦄   |   🦄   | and probably the 400kB too          |
-| [TRS-80](doc/disk-trs80.md)              |  🦖   |   🦖*  | a minor variation of the IBM scheme |
+| Format                                    | Read? | Write? | Notes |
+|:------------------------------------------|:-----:|:------:|-------|
+| [IBM PC compatible](doc/disk-ibm.md)      |  🦄   |   🦄   | and compatibles (like the Atari ST) |
+| [Acorn ADFS](doc/disk-acornadfs.md)       |  🦄   |   🦖*  | single- and double- sided           |
+| [Acorn DFS](doc/disk-acorndfs.md)         |  🦄   |   🦖*  |                                     |
+| [Ampro Little Board](doc/disk-ampro.md)   |  🦖   |   🦖*  |                                     |
+| [Apple II DOS 3.3](doc/disk-apple2.md)    |  🦄   |        | doesn't do logical sector remapping |
+| [Amiga](doc/disk-amiga.md)                |  🦄   |   🦄   |                                     |
+| [Commodore 64 1541/1581](doc/disk-c64.md) |  🦄   |   🦄   | and probably the other formats      |
+| [Brother 120kB](doc/disk-brother.md)      |  🦄   |   🦖   |                                     |
+| [Brother 240kB](doc/disk-brother.md)      |  🦄   |   🦄   |                                     |
+| [Brother FB-100](doc/disk-fb100.md)       |  🦖   |        | Tandy Model 100, Husky Hunter, knitting machines |
+| [Macintosh 800kB](doc/disk-macintosh.md)  |  🦄   |   🦄   | and probably the 400kB too          |
+| [TRS-80](doc/disk-trs80.md)               |  🦖   |   🦖*  | a minor variation of the IBM scheme |
 {: .datatable }

 `*`: these formats are variations of the generic IBM format, and since the
@@ -103,7 +123,9 @@ at least, check the CRC so what data's there is probably good.
 | [AES Superplus / No Problem](doc/disk-aeslanier.md) |  🦖   | | hard sectors! |
 | [Durango F85](doc/disk-durangof85.md)    |  🦖   |        | 5.25" |
 | [DVK MX](doc/disk-mx.md)                 |  🦖   |        | Soviet PDP-11 clone |
+| [VDS Eco1](doc/disk-eco1.md)             |  🦖   |        | 8" mixed format |
 | [Micropolis](doc/disk-micropolis.md)     |  🦄   |        | Micropolis 100tpi drives |
+| [Northstar(doc/disk-northstar.md)        |  🦖   |   🦖   | 5.25" hard sectors |
 | [TI DS990 FD1000](doc/disk-tids990.md)   |  🦄   |  🦄    | 8" |
 | [Victor 9000](doc/disk-victor9k.md)      |  🦖   |        | 8" |
 | [Zilog MCZ](doc/disk-zilogmcz.md)        |  🦖   |        | 8" _and_ hard sectors |
@@ -190,6 +212,21 @@ contributions from many other people. It is licensed under the terms of the
 BSD license. Please see the contents of the directory for the full text.

 As an exception, `dep/emu` contains parts of the OpenBSD C library
-code, Todd Miller and William A. Rowe (and probably others). It is licensed
+code, maintained by Todd Miller and William A. Rowe (and probably others). It is licensed
 under the terms of the 3-clause BSD license. Please see the contents of the
 directory for the full text. It's been lightly modified by me.
+
+As an exception, `dep/agg` contains parts of the Anti-Grain Antialiasing
+library, written by Maxim Semanarev (and others). It is licensed under the
+terms of the 3-clause BSD license. Please see the contents of the directory for
+the full text. It's been lightly modified by me.
+
+As an exception, `dep/stb` contains parts of the libstb utility library,
+written by Sean T Barett (and others). It is public domain/Unlicense/MIT
+licensed, at your choice. Please see the contents of the directory for the full
+text.
+
+As an exception, `dep/snowhouse` contains the snowhouse assertion library,
+taken from https://github.com/banditcpp/snowhouse. It is Boost Standard License
+1.0 licensed. Please see the contents of the directory for the full text.
+
--- a/arch/aeslanier/aeslanier.h
+++ b/arch/aeslanier/aeslanier.h
@@ -7,10 +7,12 @@

 class Sector;
 class Fluxmap;
+class AesLanierDecoderProto;

 class AesLanierDecoder : public AbstractDecoder
 {
 public:
+	AesLanierDecoder(const AesLanierDecoderProto&) {}
    virtual ~AesLanierDecoder() {}

    RecordType advanceToNextRecord();
--- a/arch/aeslanier/aeslanier.proto
+++ b/arch/aeslanier/aeslanier.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message AesLanierDecoderProto {}
+
--- a/arch/amiga/amiga.h
+++ b/arch/amiga/amiga.h
@@ -12,10 +12,13 @@
 class Sector;
 class Fluxmap;
 class SectorSet;
+class AmigaDecoderProto;
+class AmigaEncoderProto;

 class AmigaDecoder : public AbstractDecoder
 {
 public:
+	AmigaDecoder(const AmigaDecoderProto&) {}
    virtual ~AmigaDecoder() {}

    RecordType advanceToNextRecord();
@@ -27,13 +30,16 @@ public:
 class AmigaEncoder : public AbstractEncoder
 {
 public:
+	AmigaEncoder(const AmigaEncoderProto& config):
+		_config(config) {}
 	virtual ~AmigaEncoder() {}

 public:
    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
-};

-extern FlagGroup amigaEncoderFlags;
+private:
+	const AmigaEncoderProto& _config;
+};

 extern uint32_t amigaChecksum(const Bytes& bytes);
 extern Bytes amigaInterleave(const Bytes& input);
--- a/arch/amiga/amiga.proto
+++ b/arch/amiga/amiga.proto
@@ -0,0 +1,13 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message AmigaDecoderProto {}
+
+message AmigaEncoderProto {
+	optional double clock_rate_us = 1
+		[default=2.00, (help)="Encoded data clock rate."];
+	optional double post_index_gap_ms = 2
+		[default=0.5, (help)="Post-index gap before first sector header."];
+}
+
--- a/arch/amiga/encoder.cc
+++ b/arch/amiga/encoder.cc
@@ -6,18 +6,7 @@
 #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);
+#include "arch/amiga/amiga.pb.h"

 static bool lastBit;

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

 static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
 {
 	cursor += width;
+	lastBit = data & 1;
 	for (int i=0; i<width; i++)
 	{
 		unsigned pos = cursor - i - 1;
@@ -49,19 +39,16 @@ static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data,
 	}
 }

-static void write_interleaved_bytes(std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
 {
-	assert(!(bytes.size() & 3));
-	Bytes interleaved = amigaInterleave(bytes);
-	encodeMfm(bits, cursor, interleaved, lastBit);
-}
+	ByteReader br(bytes);
+	BitReader bitr(br);

-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);
+	while (!bitr.eof())
+	{
+		if (cursor < bits.size())
+			bits[cursor++] = bitr.get();
+	}
 }

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

+	uint32_t checksum = 0;
+
+	auto write_interleaved_bytes = [&](const Bytes& bytes)
+	{
+		Bytes interleaved = amigaInterleave(bytes);
+		Bytes mfm = encodeMfm(interleaved, lastBit);
+		checksum ^= amigaChecksum(mfm);
+		checksum &= 0x55555555;
+		write_bits(bits, cursor, mfm);
+	};
+
+	auto write_interleaved_word = [&](uint32_t word)
+	{
+		Bytes b(4);
+		b.writer().write_be32(word);
+		write_interleaved_bytes(b);
+	};
+
    write_bits(bits, cursor, AMIGA_SECTOR_RECORD, 6*8);

-	std::vector<bool> headerBits(20*16);
-	unsigned headerCursor = 0;
-
+	checksum = 0;
 	Bytes header = 
 		{
 			0xff, /* Amiga 1.0 format byte */
@@ -81,22 +84,16 @@ static void write_sector(std::vector<bool>& bits, unsigned& cursor, const Sector
 			(uint8_t) sector->logicalSector,
 			(uint8_t) (AMIGA_SECTORS_PER_TRACK - sector->logicalSector)
 		};
-	write_interleaved_bytes(headerBits, headerCursor, header);
+	write_interleaved_bytes(header);
 	Bytes recoveryInfo(16);
 	if (sector->data.size() == 528)
 		recoveryInfo = sector->data.slice(512, 16);
-	write_interleaved_bytes(headerBits, headerCursor, recoveryInfo);
+	write_interleaved_bytes(recoveryInfo);
+	write_interleaved_word(checksum);

-	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);
+	Bytes data = sector->data.slice(0, 512);
+	write_interleaved_word(amigaChecksum(encodeMfm(amigaInterleave(data), lastBit)));
+	write_interleaved_bytes(data);
 }

 std::unique_ptr<Fluxmap> AmigaEncoder::encode(
@@ -105,11 +102,11 @@ std::unique_ptr<Fluxmap> AmigaEncoder::encode(
 	if ((physicalTrack < 0) || (physicalTrack >= AMIGA_TRACKS_PER_DISK))
 		return std::unique_ptr<Fluxmap>();

-	int bitsPerRevolution = 200000.0 / clockRateUs;
+	int bitsPerRevolution = 200000.0 / _config.clock_rate_us();
 	std::vector<bool> bits(bitsPerRevolution);
 	unsigned cursor = 0;

-    fillBitmapTo(bits, cursor, postIndexGapMs * 1000 / clockRateUs, { true, false });
+    fillBitmapTo(bits, cursor, _config.post_index_gap_ms() * 1000 / _config.clock_rate_us(), { true, false });
 	lastBit = false;

 	for (int sectorId=0; sectorId<AMIGA_SECTORS_PER_TRACK; sectorId++)
@@ -123,7 +120,7 @@ std::unique_ptr<Fluxmap> AmigaEncoder::encode(
 	fillBitmapTo(bits, cursor, bits.size(), { true, false });

 	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-	fluxmap->appendBits(bits, clockRateUs*1e3);
+	fluxmap->appendBits(bits, _config.clock_rate_us()*1e3);
 	return fluxmap;
 }

--- a/arch/apple2/apple2.h
+++ b/arch/apple2/apple2.h
@@ -9,10 +9,12 @@

 class Sector;
 class Fluxmap;
+class Apple2DecoderProto;

 class Apple2Decoder : public AbstractDecoder
 {
 public:
+	Apple2Decoder(const Apple2DecoderProto&) {}
    virtual ~Apple2Decoder() {}

    RecordType advanceToNextRecord();
--- a/arch/apple2/apple2.proto
+++ b/arch/apple2/apple2.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message Apple2DecoderProto {}
+
--- a/arch/brother/brother.h
+++ b/arch/brother/brother.h
@@ -14,11 +14,15 @@
 #define BROTHER_SECTORS_PER_TRACK        12

 class Sector;
+class SectorSet;
 class Fluxmap;
+class BrotherDecoderProto;
+class BrotherEncoderProto;

 class BrotherDecoder : public AbstractDecoder
 {
 public:
+    BrotherDecoder(const BrotherDecoderProto& config) {}
    virtual ~BrotherDecoder() {}

    RecordType advanceToNextRecord();
@@ -29,20 +33,17 @@ public:
 class BrotherEncoder : public AbstractEncoder
 {
 public:
-	BrotherEncoder(int format, int bias):
-		_format(format),
-		_bias(bias)
+	BrotherEncoder(const BrotherEncoderProto& config):
+		_config(config)
 	{}

 	virtual ~BrotherEncoder() {}

 private:
-	int _format;
-	int _bias;
+	const BrotherEncoderProto& _config;
+
 public:
    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
 };

-extern FlagGroup brotherEncoderFlags;
-
 #endif
--- a/arch/brother/brother.proto
+++ b/arch/brother/brother.proto
@@ -0,0 +1,20 @@
+syntax = "proto2";
+
+message BrotherDecoderProto {}
+
+enum BrotherFormat {
+	BROTHER240 = 0;
+	BROTHER120 = 1;
+};
+
+message BrotherEncoderProto {
+	optional double clock_rate_us = 1 [default = 3.83];
+	optional double post_index_gap_ms = 2 [default = 1.0];
+	optional double sector_spacing_ms = 3 [default = 16.2];
+	optional double post_header_spacing_ms = 4 [default = 0.69];
+	optional string sector_skew = 5 [default = "05a3816b4927"];
+
+	optional BrotherFormat format = 6 [default = BROTHER240];
+	optional int32 bias = 7 [default = 0];
+}
+
--- a/arch/brother/encoder.cc
+++ b/arch/brother/encoder.cc
@@ -6,6 +6,7 @@
 #include "crc.h"
 #include "sectorset.h"
 #include "writer.h"
+#include "arch/brother/brother.pb.h"

 FlagGroup brotherEncoderFlags;

@@ -132,17 +133,17 @@ std::unique_ptr<Fluxmap> BrotherEncoder::encode(
 	int logicalTrack;
 	if (physicalSide != 0)
 		return std::unique_ptr<Fluxmap>();
-	physicalTrack -= _bias;
-	switch (_format)
+	physicalTrack -= _config.bias();
+	switch (_config.format())
 	{
-		case 120:
+		case BROTHER120:
 			if ((physicalTrack < 0) || (physicalTrack >= (BROTHER_TRACKS_PER_120KB_DISK*2))
 					|| (physicalTrack & 1))
 				return std::unique_ptr<Fluxmap>();
 			logicalTrack = physicalTrack/2;
 			break;

-		case 240:
+		case BROTHER240:
 			if ((physicalTrack < 0) || (physicalTrack >= BROTHER_TRACKS_PER_240KB_DISK))
 				return std::unique_ptr<Fluxmap>();
 			logicalTrack = physicalTrack;
--- a/arch/c64/c64.h
+++ b/arch/c64/c64.h
@@ -1,16 +1,42 @@
 #ifndef C64_H
 #define C64_H

+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+
 #define C64_SECTOR_RECORD    0xffd49
 #define C64_DATA_RECORD      0xffd57
 #define C64_SECTOR_LENGTH    256

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

 class Commodore64Decoder : public AbstractDecoder
 {
 public:
+	Commodore64Decoder(const Commodore64DecoderProto&) {}
    virtual ~Commodore64Decoder() {}

    RecordType advanceToNextRecord();
@@ -18,4 +44,25 @@ public:
    void decodeDataRecord();
 };

+class Commodore64Encoder : public AbstractEncoder
+{
+public:
+	Commodore64Encoder(const Commodore64EncoderProto& config):
+		_config(config)
+	{}
+
+	virtual ~Commodore64Encoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	void writeSector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector) const;
+	
+private:
+	const Commodore64EncoderProto& _config;
+	uint8_t _formatByte1;
+	uint8_t _formatByte2;
+};
+
 #endif
--- a/arch/c64/c64.proto
+++ b/arch/c64/c64.proto
@@ -0,0 +1,13 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Commodore64DecoderProto {}
+
+message Commodore64EncoderProto {
+	optional double post_index_gap_us = 1 [default=0.0,
+		(help) = "post-index gap before first sector header."];
+	optional double clock_compensation_factor = 2 [default=1.0,
+		(help) = "scale the output clock by this much."];
+}
+
--- a/arch/c64/encoder.cc
+++ b/arch/c64/encoder.cc
@@ -0,0 +1,349 @@
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "c64.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "sector.h"
+#include "writer.h"
+#include "fmt/format.h"
+#include "arch/c64/c64.pb.h"
+#include <ctype.h>
+#include "bytes.h"
+
+static bool lastBit;
+
+static double clockRateUsForTrack(unsigned track)
+{
+    /*
+     * Track   # Sectors/Track Speed Zone  bits/rotation       
+     * 1 – 17          21          3       61,538.4
+     * 18 – 24         19          2       57,142.8
+     * 25 – 30         18          1       53,333.4
+     * 31 – 35         17          0       50,000.0
+    */
+    if (track < 17)
+        return 200000.0/61538.4;
+    if (track < 24)
+        return 200000.0/57142.8;
+    if (track < 30)
+        return 200000.0/53333.4;
+    return 200000.0/50000.0;
+
+}
+
+static unsigned sectorsForTrack(unsigned track)
+{
+    /*
+     * Track   Sectors/track   # Sectors   Storage in Bytes
+     *   -----   -------------   ---------   ----------------
+     *    1-17        21            357           7820
+     *   18-24        19            133           7170
+     *   25-30        18            108           6300
+     *   31-40(*)     17             85           6020
+     *                              ---
+     *                              683 (for a 35 track image)
+     */
+    if (track < 17)
+        return 21;
+    if (track < 24)
+        return 19;
+    if (track < 30)
+        return 18;
+    return 17;
+}
+
+static int encode_data_gcr(uint8_t data)
+{
+    switch (data)
+    {
+        #define GCR_ENTRY(gcr, data) \
+            case data: return gcr;
+        #include "data_gcr.h"
+        #undef GCR_ENTRY
+    }
+    return -1;
+};
+
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
+{
+    for (bool bit : src)  //Range-based for loop
+    {
+        if (cursor < bits.size())
+            bits[cursor++] = bit;
+    }
+}
+
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
+{
+    cursor += width;
+    for (int i=0; i<width; i++)
+    {
+        unsigned pos = cursor - i - 1;              
+        if (pos < bits.size())
+            bits[pos] = data & 1;
+        data >>= 1;
+    }
+}
+
+void bindump(std::ostream& stream, std::vector<bool>& buffer)
+{
+    size_t pos = 0;
+
+    while ((pos < buffer.size()) and (pos <520))
+    {
+        stream << fmt::format("{:5d} : ", pos);
+        for (int i=0; i<40; i++)
+        {
+            if ((pos+i) < buffer.size())
+                stream << fmt::format("{:01b}", (buffer[pos+i]));
+            else
+                stream << "-- ";
+            if ((((pos + i + 1) % 8) == 0) and i != 0)
+                stream << "  ";
+
+        }
+        stream << std::endl;
+        pos += 40;
+    }
+}
+static std::vector<bool> encode_data(uint8_t input)
+{
+    /*
+    * Four 8-bit data bytes are converted to four 10-bit GCR bytes at a time by
+    * the 1541 DOS.  RAM is only an 8-bit storage device though. This hardware
+    * limitation prevents a 10-bit GCR byte from being stored in a single
+    * memory location. Four 10-bit GCR bytes total 40 bits - a number evenly
+    * divisible by our overriding 8-bit constraint. Commodore sub- divides the
+    * 40 GCR bits into five 8-bit bytes to solve this dilemma. This explains
+    * why four 8-bit data bytes are converted to GCR form at a time. The
+    * following step by step example demonstrates how this bit manipulation is
+    * performed by the DOS.
+    *
+    * STEP 1. Four 8-bit Data Bytes
+    * $08 $10 $00 $12
+    *
+    * STEP 2. Hexadecimal to Binary Conversion
+    * 1. Binary Equivalents
+    * $08       $10         $00         $12
+    * 00001000  00010000    00000000    00010010
+    *
+    * STEP 3. Binary to GCR Conversion
+    * 1. Four 8-bit Data Bytes
+    * 00001000 00010000 00000000 00010010
+    * 2. High and Low Nybbles
+    * 0000 1000 0001 0000 0000 0000 0001 0010
+    * 3. High and Low Nybble GCR Equivalents
+    * 01010 01001 01011 01010 01010 01010 01011 10010
+    * 4. Four 10-bit GCR Bytes
+    * 0101001001 0101101010 0101001010 0101110010
+    *
+    * STEP 4. 10-bit GCR to 8-bit GCR Conversion
+    *   1. Concatenate Four 10-bit GCR Bytes
+    *   0101001001010110101001010010100101110010
+    *   2. Five 8-bit Subdivisions
+    *   01010010 01010110 10100101 00101001 01110010
+    *
+    * STEP 5. Binary to Hexadecimal Conversion
+    * 1. Hexadecimal Equivalents
+    *   01010010    01010110    10100101    00101001    01110010
+    *   $52         $56         $A5         $29         $72
+    *
+    * STEP 6. Four 8-bit Data Bytes are Recorded as Five 8-bit GCR Bytes
+    *   $08 $10 $00 $12
+    *
+    * are recorded as
+    *   $52 $56 $A5 $29 $72
+    */
+
+    std::vector<bool> output(10, false);
+    uint8_t hi = 0;
+    uint8_t lo = 0;
+    uint8_t lo_GCR = 0;
+    uint8_t hi_GCR = 0;
+
+    //Convert the byte in high and low nibble
+    lo = input >> 4; //get the lo nibble shift the bits 4 to the right          
+    hi = input & 15; //get the hi nibble bij masking the lo bits (00001111)     
+
+
+    lo_GCR = encode_data_gcr(lo);   //example value: 0000   GCR = 01010
+    hi_GCR = encode_data_gcr(hi);   //example value: 1000   GCR = 01001
+    //output = [0,1,2,3,4,5,6,7,8,9]
+    //value  = [0,1,0,1,0,0,1,0,0,1]
+    //          01010 01001
+
+    int b = 4;
+    for (int i = 0; i < 10; i++)
+    {
+        if (i < 5) //01234
+        {       //i = 0 op 
+            output[4-i] = (lo_GCR & 1); //01010
+
+            //01010 -> & 00001 -> 00000 output[4] = 0
+            //00101 -> & 00001 -> 00001 output[3] = 1
+            //00010 -> & 00001 -> 00000 output[2] = 0
+            //00001 -> & 00001 -> 00001 output[1] = 1
+            //00000 -> & 00001 -> 00000 output[0] = 0
+            lo_GCR >>= 1;
+        } else  
+        {
+            output[i+b] = (hi_GCR & 1); //01001
+            //01001 -> & 00001 -> 00001 output[9] = 1
+            //00100 -> & 00001 -> 00000 output[8] = 0
+            //00010 -> & 00001 -> 00000 output[7] = 0
+            //00001 -> & 00001 -> 00001 output[6] = 1
+            //00000 -> & 00001 -> 00000 output[5] = 0
+            hi_GCR >>= 1;
+            b = b-2;
+        }
+    }
+    return output;
+}
+
+void Commodore64Encoder::writeSector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector) const
+{
+    /* Source: http://www.unusedino.de/ec64/technical/formats/g64.html 
+     * 1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
+     * 2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
+     * 3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
+     * 4. Data sync         FF FF FF FF FF (40 'on' bits, not GCR)
+     * 5. Data block        55...4A (325 GCR bytes)
+     * 6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
+     * 1. Header sync       (SYNC for the next sector)
+    */
+    if ((sector->status == Sector::OK) or (sector->status == Sector::BAD_CHECKSUM))
+    {
+        // There is data to encode to disk.
+        if ((sector->data.size() != C64_SECTOR_LENGTH))
+            Error() << fmt::format("unsupported sector size {} --- you must pick 256", sector->data.size());    
+
+        // 1. Write header Sync (not GCR)
+        for (int i=0; i<6; i++)
+            write_bits(bits, cursor, C64_HEADER_DATA_SYNC, 1*8); /* sync */
+
+        // 2. Write Header info 10 GCR bytes
+        /*
+         * The 10 byte header info (#2) is GCR encoded and must be decoded  to
+         * it's normal 8 bytes to be understood. Once decoded, its breakdown is
+         * as follows:
+         * 
+         * Byte $00 - header block ID           ($08)
+         *   01 - header block checksum 16  (EOR of $02-$05)
+         *   02 - Sector
+         *   03 - Track
+         *   04 - Format ID byte #2
+         *   05 - Format ID byte #1
+         *   06-07 - $0F ("off" bytes)
+         */
+        uint8_t encodedTrack = ((sector->logicalTrack) + 1); // C64 track numbering starts with 1. Fluxengine with 0.
+        uint8_t encodedSector = sector->logicalSector;
+        // uint8_t formatByte1 = C64_FORMAT_ID_BYTE1;
+        // uint8_t formatByte2 = C64_FORMAT_ID_BYTE2;
+        uint8_t headerChecksum = (encodedTrack ^ encodedSector ^ _formatByte1 ^ _formatByte2);
+        write_bits(bits, cursor, encode_data(C64_HEADER_BLOCK_ID));
+        write_bits(bits, cursor, encode_data(headerChecksum));
+        write_bits(bits, cursor, encode_data(encodedSector));
+        write_bits(bits, cursor, encode_data(encodedTrack));
+        write_bits(bits, cursor, encode_data(_formatByte2));
+        write_bits(bits, cursor, encode_data(_formatByte1));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+
+        // 3. Write header GAP not GCR
+        for (int i=0; i<9; i++)
+            write_bits(bits, cursor, C64_HEADER_GAP, 1*8); /* header gap */
+
+        // 4. Write Data sync not GCR
+        for (int i=0; i<6; i++)
+            write_bits(bits, cursor, C64_HEADER_DATA_SYNC, 1*8); /* sync */
+
+        // 5. Write data block 325 GCR bytes
+        /*
+         * The 325 byte data block (#5) is GCR encoded and must be  decoded  to  its
+         * normal 260 bytes to be understood. The data block is made up of the following:
+         * 
+         * Byte    $00 - data block ID ($07)
+         *      01-100 - 256 bytes data
+         *      101 - data block checksum (EOR of $01-100)
+         *      102-103 - $00 ("off" bytes, to make the sector size a multiple of 5)
+         */
+
+        write_bits(bits, cursor, encode_data(C64_DATA_BLOCK_ID));
+        uint8_t dataChecksum = xorBytes(sector->data);
+        ByteReader br(sector->data);
+        int i = 0;
+        for (i = 0; i < C64_SECTOR_LENGTH; i++)
+        {
+            uint8_t val = br.read_8();
+            write_bits(bits, cursor, encode_data(val));     
+        }
+        write_bits(bits, cursor, encode_data(dataChecksum));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+        write_bits(bits, cursor, encode_data(C64_PADDING));
+
+        //6. Write inter-sector gap 9 - 12 bytes nor gcr
+        for (int i=0; i<9; i++)
+            write_bits(bits, cursor, C64_INTER_SECTOR_GAP, 1*8); /* sync */
+
+    }
+}
+
+std::unique_ptr<Fluxmap> Commodore64Encoder::encode(
+    int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+    /* The format ID Character # 1 and # 2 are in the .d64 image only present
+     * in track 18 sector zero which contains the BAM info in byte 162 and 163.
+     * it is written in every header of every sector and track. headers are not
+     * stored in a d64 disk image so we have to get it from track 18 which
+     * contains the BAM.
+    */
+
+    const auto& sectorData = allSectors.get(C64_BAM_TRACK*2, 0, 0); //Read de BAM to get the DISK ID bytes
+    if (sectorData)
+    {
+        ByteReader br(sectorData->data);
+        br.seek(162); //goto position of the first Disk ID Byte
+        _formatByte1 = br.read_8();
+        _formatByte2 = br.read_8();
+    }
+    else
+        _formatByte1 = _formatByte2 = 0;
+    
+    int logicalTrack = physicalTrack / 2;
+    double clockRateUs = clockRateUsForTrack(logicalTrack) * _config.clock_compensation_factor();
+
+    int bitsPerRevolution = 200000.0 / clockRateUs;
+
+    std::vector<bool> bits(bitsPerRevolution);
+    unsigned cursor = 0;
+
+    fillBitmapTo(bits, cursor, _config.post_index_gap_us() / clockRateUs, { true, false });
+    lastBit = false;
+
+    unsigned numSectors = sectorsForTrack(logicalTrack);
+    unsigned writtenSectors = 0;
+    for (int sectorId=0; sectorId<numSectors; sectorId++)
+    {
+        const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+        if (sectorData)
+        {
+            writeSector(bits, cursor, sectorData);
+            writtenSectors++;
+        }
+    }
+    if (writtenSectors == 0)
+        return std::unique_ptr<Fluxmap>();
+
+    if (cursor >= bits.size())
+        Error() << fmt::format("track data overrun by {} bits", cursor - bits.size());
+    fillBitmapTo(bits, cursor, bits.size(), { true, false });
+
+    std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+    fluxmap->appendBits(bits, clockRateUs*1e3);
+    return fluxmap;
+}
+
+// vim: sw=4 ts=4 et
+
--- a/arch/f85/f85.h
+++ b/arch/f85/f85.h
@@ -7,10 +7,12 @@

 class Sector;
 class Fluxmap;
+class F85DecoderProto;

 class DurangoF85Decoder : public AbstractDecoder
 {
 public:
+	DurangoF85Decoder(const F85DecoderProto&) {}
    virtual ~DurangoF85Decoder() {}

    RecordType advanceToNextRecord();
--- a/arch/f85/f85.proto
+++ b/arch/f85/f85.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message F85DecoderProto {}
+
--- a/arch/fb100/fb100.h
+++ b/arch/fb100/fb100.h
@@ -8,10 +8,12 @@
 class Sector;
 class Fluxmap;
 class Track;
+class Fb100DecoderProto;

 class Fb100Decoder : public AbstractDecoder
 {
 public:
+	Fb100Decoder(const Fb100DecoderProto&) {}
    virtual ~Fb100Decoder() {}

    RecordType advanceToNextRecord();
--- a/arch/fb100/fb100.proto
+++ b/arch/fb100/fb100.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message Fb100DecoderProto {}
+
--- a/arch/ibm/decoder.cc
+++ b/arch/ibm/decoder.cc
@@ -6,6 +6,8 @@
 #include "decoders/fluxmapreader.h"
 #include "sector.h"
 #include "record.h"
+#include "arch/ibm/ibm.pb.h"
+#include "proto.h"
 #include <string.h>

 static_assert(std::is_trivially_copyable<IbmIdam>::value,
@@ -89,6 +91,11 @@ const FluxMatchers ANY_RECORD_PATTERN(
    }
 );

+std::set<unsigned> IbmDecoder::requiredSectors(Track& track) const
+{
+	return iterate(_config.required_sectors());
+}
+
 AbstractDecoder::RecordType IbmDecoder::advanceToNextRecord()
 {
 	const FluxMatcher* matcher = nullptr;
@@ -131,14 +138,14 @@ void IbmDecoder::decodeSectorRecord()
    br.read_8(); /* skip ID byte */
    _sector->logicalTrack = br.read_8();
    _sector->logicalSide = br.read_8();
-    _sector->logicalSector = br.read_8() - _sectorBase;
+    _sector->logicalSector = br.read_8() - _config.sector_id_base();
    _currentSectorSize = 1 << (br.read_8() + 7);
    uint16_t wantCrc = br.read_be16();
    uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, _currentHeaderLength + 5));
    if (wantCrc == gotCrc)
        _sector->status = Sector::DATA_MISSING; /* correct but unintuitive */

-    if (_ignoreSideByte)
+    if (_config.ignore_side_byte())
        _sector->logicalSide = _sector->physicalSide;
 }

--- a/arch/ibm/encoder.cc
+++ b/arch/ibm/encoder.cc
@@ -6,6 +6,7 @@
 #include "crc.h"
 #include "sectorset.h"
 #include "writer.h"
+#include "arch/ibm/ibm.pb.h"
 #include "fmt/format.h"
 #include <ctype.h>

@@ -76,21 +77,6 @@ void IbmEncoder::writeRawBits(uint32_t data, int width)
 	}
 }

-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;
@@ -99,22 +85,56 @@ static uint8_t decodeUint16(uint16_t raw)
 	return decodeFmMfm(b.toBits())[0];
 }

+void IbmEncoder::getTrackFormat(IbmEncoderProto::TrackdataProto& trackdata, unsigned cylinder, unsigned head)
+{
+	trackdata.Clear();
+	for (const auto& f : _config.trackdata())
+	{
+		if (f.has_cylinder() && (f.cylinder() != cylinder))
+			continue;
+		if (f.has_head() && (f.head() != head))
+			continue;
+
+		trackdata.MergeFrom(f);
+	}
+}
+
 std::unique_ptr<Fluxmap> IbmEncoder::encode(
 	int physicalTrack, int physicalSide, const SectorSet& allSectors)
 {
-	double clockRateUs = 1e3 / _parameters.clockRateKhz;
-	if (!_parameters.useFm)
+	IbmEncoderProto::TrackdataProto trackdata;
+	getTrackFormat(trackdata, physicalTrack, physicalSide);
+
+	auto writeBytes = [&](const Bytes& bytes)
+	{
+		if (trackdata.use_fm())
+			encodeFm(_bits, _cursor, bytes);
+		else
+			encodeMfm(_bits, _cursor, bytes, _lastBit);
+	};
+
+	auto writeFillerBytes = [&](int count, uint8_t byte)
+	{
+		Bytes bytes = { byte };
+		for (int i=0; i<count; i++)
+			writeBytes(bytes);
+	};
+
+	if (trackdata.swap_sides())
+		physicalSide = 1 - physicalSide;
+	double clockRateUs = 1e3 / trackdata.clock_rate_khz();
+	if (!trackdata.use_fm())
 		clockRateUs /= 2.0;
-	int bitsPerRevolution = (_parameters.trackLengthMs * 1000.0) / clockRateUs;
+	int bitsPerRevolution = (trackdata.track_length_ms() * 1000.0) / clockRateUs;
 	_bits.resize(bitsPerRevolution);
 	_cursor = 0;

-	uint8_t idamUnencoded = decodeUint16(_parameters.idamByte);
-	uint8_t damUnencoded = decodeUint16(_parameters.damByte);
+	uint8_t idamUnencoded = decodeUint16(trackdata.idam_byte());
+	uint8_t damUnencoded = decodeUint16(trackdata.dam_byte());

 	uint8_t sectorSize = 0;
 	{
-		int s = _parameters.sectorSize >> 7;
+		int s = trackdata.sector_size() >> 7;
 		while (s > 1)
 		{
 			s >>= 1;
@@ -122,32 +142,35 @@ std::unique_ptr<Fluxmap> IbmEncoder::encode(
 		}
 	}

-	uint8_t gapFill = _parameters.useFm ? 0x00 : 0x4e;
+	uint8_t gapFill = trackdata.use_fm() ? 0x00 : 0x4e;

-	writeBytes(_parameters.gap0, gapFill);
-	if (_parameters.emitIam)
+	writeFillerBytes(trackdata.gap0(), gapFill);
+	if (trackdata.emit_iam())
 	{
-		writeBytes(_parameters.useFm ? 6 : 12, 0x00);
-		if (!_parameters.useFm)
+		writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+		if (!trackdata.use_fm())
 		{
 			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);
+		writeRawBits(trackdata.use_fm() ? FM_IAM_RECORD : MFM_IAM_RECORD, 16);
+		writeFillerBytes(trackdata.gap1(), gapFill);
 	}

 	bool first = true;
-	for (char sectorChar : _parameters.sectorSkew)
+	for (char sectorChar : trackdata.sector_skew())
 	{
 		int sectorId = charToInt(sectorChar);
 		if (!first)
-			writeBytes(_parameters.gap3, gapFill);
+			writeFillerBytes(trackdata.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);
+		{
+			/* If there are any missing sectors, this is an empty track. */
+			return std::unique_ptr<Fluxmap>();
+		}

 		/* Writing the sector and data records are fantastically annoying.
 		 * The CRC is calculated from the *very start* of the record, and
@@ -161,8 +184,8 @@ std::unique_ptr<Fluxmap> IbmEncoder::encode(
 			Bytes header;
 			ByteWriter bw(header);

-			writeBytes(_parameters.useFm ? 6 : 12, 0x00);
-			if (!_parameters.useFm)
+			writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+			if (!trackdata.use_fm())
 			{
 				for (int i=0; i<3; i++)
 					bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
@@ -170,54 +193,53 @@ std::unique_ptr<Fluxmap> IbmEncoder::encode(
 			bw.write_8(idamUnencoded);
 			bw.write_8(sectorData->logicalTrack);
 			bw.write_8(sectorData->logicalSide);
-			bw.write_8(sectorData->logicalSector + _parameters.startSectorId);
+			bw.write_8(sectorData->logicalSector + trackdata.start_sector_id());
 			bw.write_8(sectorSize);
 			uint16_t crc = crc16(CCITT_POLY, header);
 			bw.write_be16(crc);

 			int conventionalHeaderStart = 0;
-			if (!_parameters.useFm)
+			if (!trackdata.use_fm())
 			{
 				for (int i=0; i<3; i++)
 					writeRawBits(MFM_RECORD_SEPARATOR, 16);
 				conventionalHeaderStart += 3;

 			}
-			writeRawBits(_parameters.idamByte, 16);
+			writeRawBits(trackdata.idam_byte(), 16);
 			conventionalHeaderStart += 1;

 			writeBytes(header.slice(conventionalHeaderStart));
 		}

-		writeBytes(_parameters.gap2, gapFill);
+		writeFillerBytes(trackdata.gap2(), gapFill);

 		{
 			Bytes data;
 			ByteWriter bw(data);

-			writeBytes(_parameters.useFm ? 6 : 12, 0x00);
-			if (!_parameters.useFm)
+			writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+			if (!trackdata.use_fm())
 			{
 				for (int i=0; i<3; i++)
 					bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
 			}
 			bw.write_8(damUnencoded);

-			Bytes truncatedData = sectorData->data.slice(0, _parameters.sectorSize);
+			Bytes truncatedData = sectorData->data.slice(0, trackdata.sector_size());
 			bw += truncatedData;
-			hexdump(std::cout, data.slice(0, 64));
 			uint16_t crc = crc16(CCITT_POLY, data);
 			bw.write_be16(crc);

 			int conventionalHeaderStart = 0;
-			if (!_parameters.useFm)
+			if (!trackdata.use_fm())
 			{
 				for (int i=0; i<3; i++)
 					writeRawBits(MFM_RECORD_SEPARATOR, 16);
 				conventionalHeaderStart += 3;

 			}
-			writeRawBits(_parameters.damByte, 16);
+			writeRawBits(trackdata.dam_byte(), 16);
 			conventionalHeaderStart += 1;

 			writeBytes(data.slice(conventionalHeaderStart));
@@ -227,7 +249,7 @@ std::unique_ptr<Fluxmap> IbmEncoder::encode(
 	if (_cursor >= _bits.size())
 		Error() << "track data overrun";
 	while (_cursor < _bits.size())
-		writeBytes(1, gapFill);
+		writeFillerBytes(1, gapFill);

 	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
 	fluxmap->appendBits(_bits, clockRateUs*1e3);
--- a/arch/ibm/ibm.h
+++ b/arch/ibm/ibm.h
@@ -3,6 +3,7 @@

 #include "decoders/decoders.h"
 #include "encoders/encoders.h"
+#include "arch/ibm/ibm.pb.h"

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

@@ -32,50 +33,27 @@ struct IbmIdam
 class IbmDecoder : public AbstractDecoder
 {
 public:
-    IbmDecoder(unsigned sectorBase, bool ignoreSideByte=false,
-			const std::set<unsigned> requiredSectors=std::set<unsigned>()):
-        _sectorBase(sectorBase),
-        _ignoreSideByte(ignoreSideByte),
-		_requiredSectors(requiredSectors)
+    IbmDecoder(const IbmDecoderProto& config):
+		_config(config)
    {}

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

-	std::set<unsigned> requiredSectors(Track& track) const
-	{ return _requiredSectors; }
+	std::set<unsigned> requiredSectors(Track& track) const;

 private:
-    unsigned _sectorBase;
-    bool _ignoreSideByte;
-	std::set<unsigned> _requiredSectors;
+	const IbmDecoderProto& _config;
    unsigned _currentSectorSize;
    unsigned _currentHeaderLength;
 };

-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:
-	IbmEncoder(const IbmParameters& parameters):
-		_parameters(parameters)
+	IbmEncoder(const IbmEncoderProto& config):
+		_config(config)
 	{}

 	virtual ~IbmEncoder() {}
@@ -85,12 +63,12 @@ public:

 private:
 	void writeRawBits(uint32_t data, int width);
-	void writeBytes(const Bytes& bytes);
-	void writeBytes(int count, uint8_t value);
 	void writeSync();
 	
+	void getTrackFormat(IbmEncoderProto::TrackdataProto& format, unsigned track, unsigned side);
+
 private:
-	IbmParameters _parameters;
+	const IbmEncoderProto& _config;
 	std::vector<bool> _bits;
 	unsigned _cursor;
 	bool _lastBit;
--- a/arch/ibm/ibm.proto
+++ b/arch/ibm/ibm.proto
@@ -0,0 +1,34 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message IbmDecoderProto {
+	optional int32 sector_id_base = 1        [default = 1, (help) = "ID of first sector"];
+	optional bool ignore_side_byte = 2       [default = false, (help) = "ignore side byte in sector header"];
+	optional RangeProto required_sectors = 3 [(help) = "require these sectors to exist for a good read"];
+}
+
+message IbmEncoderProto {
+	message TrackdataProto {
+		optional int32 cylinder = 15        [(help) = "if set, the format applies only to this track"];
+		optional int32 head = 16            [(help) = "if set, the format applies only to this head"];
+
+		optional double track_length_ms = 1 [(help) = "length of track"];
+		optional int32 sector_size = 2      [default=512, (help) = "number of bytes per sector"];
+		optional bool emit_iam = 3          [default=true, (help) = "whether to emit an IAM record"];
+		optional int32 start_sector_id = 4  [default=1, (help) = "ID of first sector"];
+		optional double clock_rate_khz = 5  [(help) = "data clock rate"];
+		optional bool use_fm = 6            [default=false, (help) = "whether to use FM encoding rather than MFM"];
+		optional int32 idam_byte = 7        [default=0x5554, (help) = "16-bit raw bit pattern of IDAM byte"];
+		optional int32 dam_byte = 8         [default=0x5545, (help) = "16-bit raw bit pattern of DAM byte"];
+		optional int32 gap0 = 9             [default=80, (help) = "size of gap 1 (the post-index gap)"];
+		optional int32 gap1 = 10            [default=50, (help) = "size of gap 2 (the post-ID gap)"];
+		optional int32 gap2 = 11            [default=22, (help) = "size of gap 3 (the pre-data gap)"];
+		optional int32 gap3 = 12            [default=80, (help) = "size of gap 4 (the post-data or format gap)"];
+		optional string sector_skew = 13    [(help) = "order to emit sectors"];
+		optional bool swap_sides = 14       [default=false, (help) = "swap side bytes when writing"];
+	}
+
+	repeated TrackdataProto trackdata = 1;
+}
+
--- a/arch/macintosh/encoder.cc
+++ b/arch/macintosh/encoder.cc
@@ -19,7 +19,7 @@ static DoubleFlag postIndexGapUs(
 static DoubleFlag clockCompensation(
 	{ "--clock-compensation-factor" },
 	"Scale the output clock by this much.",
-	.9724);
+	1.0);

 static bool lastBit;

--- a/arch/macintosh/macintosh.h
+++ b/arch/macintosh/macintosh.h
@@ -15,10 +15,13 @@

 class Sector;
 class Fluxmap;
+class MacintoshDecoderProto;
+class MacintoshEncoderProto;

 class MacintoshDecoder : public AbstractDecoder
 {
 public:
+	MacintoshDecoder(const MacintoshDecoderProto&) {}
    virtual ~MacintoshDecoder() {}

    RecordType advanceToNextRecord();
@@ -31,6 +34,7 @@ public:
 class MacintoshEncoder : public AbstractEncoder
 {
 public:
+	MacintoshEncoder(const MacintoshEncoderProto&) {}
 	virtual ~MacintoshEncoder() {}

 public:
--- a/arch/macintosh/macintosh.proto
+++ b/arch/macintosh/macintosh.proto
@@ -0,0 +1,5 @@
+syntax = "proto2";
+
+message MacintoshDecoderProto {}
+message MacintoshEncoderProto {}
+
--- a/arch/micropolis/micropolis.h
+++ b/arch/micropolis/micropolis.h
@@ -1,14 +1,16 @@
-#ifndef ZILOGMCZ_H
-#define ZILOGMCZ_H
+#ifndef MICROPOLIS_H
+#define MICROPOLIS_H

 #define MICROPOLIS_ENCODED_SECTOR_SIZE (1+2+266+6)

 class Sector;
 class Fluxmap;
+class MicropolisDecoderProto;

 class MicropolisDecoder : public AbstractDecoder
 {
 public:
+	MicropolisDecoder(const MicropolisDecoderProto&) {}
 	virtual ~MicropolisDecoder() {}

 	RecordType advanceToNextRecord();
--- a/arch/micropolis/micropolis.proto
+++ b/arch/micropolis/micropolis.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message MicropolisDecoderProto {}
+
--- a/arch/mx/mx.h
+++ b/arch/mx/mx.h
@@ -3,9 +3,12 @@

 #include "decoders/decoders.h"

+class MxDecoderProto;
+
 class MxDecoder : public AbstractDecoder
 {
 public:
+	MxDecoder(const MxDecoderProto&) {}
    virtual ~MxDecoder() {}

    void beginTrack();
--- a/arch/mx/mx.proto
+++ b/arch/mx/mx.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message MxDecoderProto {}
+
--- a/arch/northstar/decoder.cc
+++ b/arch/northstar/decoder.cc
@@ -0,0 +1,175 @@
+/* Decoder for North Star 10-sector hard-sectored disks.
+ *
+ * Supports both single- and double-density.  For the sector format and
+ * checksum algorithm, see pp. 33 of the North Star Double Density Controller
+ * manual:
+ *
+ * http://bitsavers.org/pdf/northstar/boards/Northstar_MDS-A-D_1978.pdf
+ *
+ * North Star disks do not contain any track/head/sector information
+ * encoded in the sector record.  For this reason, we have to be absolutely
+ * sure that the hardSectorId is correct.
+ */
+
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
+#include "northstar.h"
+#include "bytes.h"
+#include "fmt/format.h"
+
+/*
+ * MFM sectors have 32 bytes of 00's followed by two sync characters,
+ * specified in the North Star MDS manual as 0xFBFB.
+ *
+ * This is true for most disks; however, I found a few disks, including an
+ * original North Star DOS/BASIC v2.2.1 DQ disk) that uses 0xFBnn, where
+ * nn is an incrementing pattern.
+ *
+ * 00        00        00        F         B
+ * 0000 0000 0000 0000 0000 0000 0101 0101 0100 0101
+ * A    A    A    A    A    A    5    5    4    5
+ */
+static const FluxPattern MFM_PATTERN(64, 0xAAAAAAAAAAAA5545LL);
+
+/* FM sectors have 16 bytes of 00's followed by 0xFB.
+ * 00        FB
+ * 0000 0000 1111 1111 1110 1111
+ * A    A    F    F    E    F
+ */
+static const FluxPattern FM_PATTERN(64, 0xAAAAAAAAAAAAFFEFLL);
+
+const FluxMatchers ANY_SECTOR_PATTERN(
+	{
+		&MFM_PATTERN,
+		&FM_PATTERN,
+	}
+);
+
+/* Search for FM or MFM sector record */
+AbstractDecoder::RecordType NorthstarDecoder::advanceToNextRecord()
+{
+	nanoseconds_t now = _fmr->tell().ns();
+
+	/* For all but the first sector, seek to the next sector pulse.
+	 * The first sector does not contain the sector pulse in the fluxmap.
+	 */
+	if (now != 0) {
+		_fmr->seekToIndexMark();
+		now = _fmr->tell().ns();
+	}
+
+	/* Discard a possible partial sector at the end of the track.
+	 * This partial sector could be mistaken for a conflicted sector, if
+	 * whatever data read happens to match the checksum of 0, which is
+	 * rare, but has been observed on some disks.
+	 */
+	if (now > (_fmr->getDuration() - 21e6)) {
+		_fmr->seekToIndexMark();
+		return(UNKNOWN_RECORD);
+	}
+
+	int msSinceIndex = std::round(now / 1e6);
+
+	const FluxMatcher* matcher = nullptr;
+
+	/* Note that the seekToPattern ignores the sector pulses, so if
+	 * a sector is not found for some reason, the seek will advance
+	 * past one or more sector pulses.  For this reason, calculate
+	 * _hardSectorId after the sector header is found.
+	 */
+	_sector->clock = _fmr->seekToPattern(ANY_SECTOR_PATTERN, matcher);
+
+	int sectorFoundTimeRaw = std::round((_fmr->tell().ns()) / 1e6);
+	int sectorFoundTime;
+
+	/* Round time to the nearest 20ms */
+	if ((sectorFoundTimeRaw % 20) < 10) {
+		sectorFoundTime = (sectorFoundTimeRaw / 20) * 20;
+	}
+	else {
+		sectorFoundTime = ((sectorFoundTimeRaw + 20) / 20) * 20;
+	}
+
+	/* Calculate the sector ID based on time since the index */
+	_hardSectorId = (sectorFoundTime / 20) % 10;
+
+//	std::cout << fmt::format(
+//		"Sector ID {}: hole at {}ms, sector start at {}ms",
+//		_hardSectorId, msSinceIndex, sectorFoundTimeRaw) << std::endl;
+
+	if (matcher == &MFM_PATTERN) {
+		_sectorType = SECTOR_TYPE_MFM;
+		readRawBits(48);
+		return SECTOR_RECORD;
+	}
+
+	if (matcher == &FM_PATTERN) {
+		_sectorType = SECTOR_TYPE_FM;
+		readRawBits(48);
+		return SECTOR_RECORD;
+	}
+
+	return UNKNOWN_RECORD;
+}
+
+/* Checksum is initially 0.
+ * For each data byte, XOR with the current checksum.
+ * Rotate checksum left, carrying bit 7 to bit 0.
+ */
+uint8_t northstarChecksum(const Bytes& bytes) {
+	ByteReader br(bytes);
+	uint8_t checksum = 0;
+
+	while (!br.eof()) {
+		checksum ^= br.read_8();
+		checksum = ((checksum << 1) | ((checksum >> 7)));
+	}
+
+	return checksum;
+}
+
+void NorthstarDecoder::decodeSectorRecord()
+{
+	unsigned recordSize, payloadSize, headerSize;
+
+	if (_sectorType == SECTOR_TYPE_MFM) {
+		recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_DD;
+		payloadSize = NORTHSTAR_PAYLOAD_SIZE_DD;
+		headerSize = NORTHSTAR_HEADER_SIZE_DD;
+	}
+	else {
+		recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_SD;
+		payloadSize = NORTHSTAR_PAYLOAD_SIZE_SD;
+		headerSize = NORTHSTAR_HEADER_SIZE_SD;
+	}
+
+	auto rawbits = readRawBits(recordSize * 16);
+	auto bytes = decodeFmMfm(rawbits).slice(0, recordSize);
+	ByteReader br(bytes);
+	uint8_t sync_char;
+
+	_sector->logicalSide = _sector->physicalSide;
+	_sector->logicalSector = _hardSectorId;
+	_sector->logicalTrack = _sector->physicalTrack;
+
+	sync_char = br.read_8();	/* Sync char: 0xFB */
+	if (_sectorType == SECTOR_TYPE_MFM) {
+		sync_char = br.read_8();/* MFM second Sync char, usually 0xFB */
+	}
+
+	_sector->data = br.read(payloadSize);
+
+	uint8_t wantChecksum = br.read_8();
+	uint8_t gotChecksum = northstarChecksum(bytes.slice(headerSize, payloadSize));
+
+	_sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+}
+
+std::set<unsigned> NorthstarDecoder::requiredSectors(Track& track) const
+{
+	static std::set<unsigned> sectors = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	return sectors;
+}
--- a/arch/northstar/encoder.cc
+++ b/arch/northstar/encoder.cc
@@ -0,0 +1,130 @@
+#include "globals.h"
+#include "northstar.h"
+#include "sectorset.h"
+
+#define GAP_FILL_SIZE_SD 30
+#define PRE_HEADER_GAP_FILL_SIZE_SD 9
+#define GAP_FILL_SIZE_DD 62
+#define PRE_HEADER_GAP_FILL_SIZE_DD 16
+
+#define GAP1_FILL_BYTE	(0x4F)
+#define GAP2_FILL_BYTE	(0x4F)
+
+#define TOTAL_SECTOR_BYTES ()
+
+static void write_sector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector)
+{
+	int preambleSize = 0;
+	int encodedSectorSize = 0;
+	int gapFillSize = 0;
+	int preHeaderGapFillSize = 0;
+
+	bool doubleDensity;
+
+	switch (sector->data.size()) {
+	case NORTHSTAR_PAYLOAD_SIZE_SD:
+		preambleSize = NORTHSTAR_PREAMBLE_SIZE_SD;
+		encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_SD + NORTHSTAR_ENCODED_SECTOR_SIZE_SD + GAP_FILL_SIZE_SD;
+		gapFillSize = GAP_FILL_SIZE_SD;
+		preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_SD;
+		doubleDensity = false;
+		break;
+	case NORTHSTAR_PAYLOAD_SIZE_DD:
+		preambleSize = NORTHSTAR_PREAMBLE_SIZE_DD;
+		encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_DD + NORTHSTAR_ENCODED_SECTOR_SIZE_DD + GAP_FILL_SIZE_DD;
+		gapFillSize = GAP_FILL_SIZE_DD;
+		preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_DD;
+		doubleDensity = true;
+		break;
+	default:
+		Error() << "unsupported sector size --- you must pick 256 or 512";
+		break;
+	}
+
+	int fullSectorSize = preambleSize + encodedSectorSize;
+	auto fullSector = std::make_shared<std::vector<uint8_t>>();
+	fullSector->reserve(fullSectorSize);
+
+	/* sector gap after index pulse */
+	for (int i = 0; i < preHeaderGapFillSize; i++)
+		fullSector->push_back(GAP1_FILL_BYTE);
+
+	/* sector preamble */
+	for (int i = 0; i < preambleSize; i++)
+		fullSector->push_back(0);
+
+	Bytes sectorData;
+	if (sector->data.size() == encodedSectorSize)
+		sectorData = sector->data;
+	else {
+		ByteWriter writer(sectorData);
+		writer.write_8(0xFB);     /* sync character */
+		if (doubleDensity == true) {
+			writer.write_8(0xFB); /* Double-density has two sync characters */
+		}
+		writer += sector->data;
+		if (doubleDensity == true) {
+			writer.write_8(northstarChecksum(sectorData.slice(2)));
+		} else {
+			writer.write_8(northstarChecksum(sectorData.slice(1)));
+		}
+	}
+	for (uint8_t b : sectorData)
+		fullSector->push_back(b);
+
+	if (sector->logicalSector != 9) {
+		/* sector postamble */
+		for (int i = 0; i < gapFillSize; i++)
+			fullSector->push_back(GAP2_FILL_BYTE);
+
+		if (fullSector->size() != fullSectorSize)
+			Error() << "sector mismatched length (" << sector->data.size() << ") expected: " << fullSector->size() << " got " << fullSectorSize;
+	} else {
+		/* sector postamble */
+		for (int i = 0; i < gapFillSize; i++)
+			fullSector->push_back(GAP2_FILL_BYTE);
+	}
+
+	bool lastBit = false;
+
+	if (doubleDensity == true) {
+		encodeMfm(bits, cursor, fullSector, lastBit);
+	}
+	else {
+		encodeFm(bits, cursor, fullSector);
+	}
+}
+
+std::unique_ptr<Fluxmap> NorthstarEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+	int bitsPerRevolution = 100000;
+	double clockRateUs = 4.00;
+
+	if ((physicalTrack < 0) || (physicalTrack >= 35))
+		return std::unique_ptr<Fluxmap>();
+
+	const auto& sector = allSectors.get(physicalTrack, physicalSide, 0);
+
+	if (sector->data.size() == NORTHSTAR_PAYLOAD_SIZE_SD) {
+		bitsPerRevolution /= 2;		// FM
+	} else {
+		clockRateUs /= 2.00;
+	}
+
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;
+
+	for (int sectorId = 0; sectorId < 10; sectorId++)
+	{
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		write_sector(bits, cursor, sectorData);
+	}
+
+	if (cursor > bits.size())
+		Error() << "track data overrun";
+
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(bits, clockRateUs * 1e3);
+	return fluxmap;
+}
--- a/arch/northstar/northstar.h
+++ b/arch/northstar/northstar.h
@@ -0,0 +1,72 @@
+#ifndef NORTHSTAR_H
+#define NORTHSTAR_H
+
+/* Northstar floppies are 10-hard sectored disks with a sector format as follows:
+ *
+ * |----------------------------------|
+ * | SYNC Byte  | Payload  | Checksum |
+ * |------------+----------+----------|
+ * | 1 (0xFB)   | 256 (SD) |    1     |
+ * | 2 (0xFBFB) | 512 (DD) |          |
+ * |----------------------------------|
+ *
+ */
+
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+
+#define NORTHSTAR_PREAMBLE_SIZE_SD		(16)
+#define NORTHSTAR_PREAMBLE_SIZE_DD		(32)
+#define NORTHSTAR_HEADER_SIZE_SD		(1)
+#define NORTHSTAR_HEADER_SIZE_DD		(2)
+#define NORTHSTAR_PAYLOAD_SIZE_SD		(256)
+#define NORTHSTAR_PAYLOAD_SIZE_DD		(512)
+#define NORTHSTAR_CHECKSUM_SIZE		(1)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD	(NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + NORTHSTAR_CHECKSUM_SIZE)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD	(NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + NORTHSTAR_CHECKSUM_SIZE)
+
+#define SECTOR_TYPE_MFM			(0)
+#define SECTOR_TYPE_FM				(1)
+
+class NorthstarEncoderProto;
+class NorthstarDecoderProto;
+
+class NorthstarDecoder : public AbstractDecoder
+{
+public:
+	NorthstarDecoder(const NorthstarDecoderProto& config):
+		_config(config)
+	{
+		_sectorType = SECTOR_TYPE_MFM;
+	}
+
+	virtual ~NorthstarDecoder() {}
+
+	RecordType advanceToNextRecord();
+	void decodeSectorRecord();
+	std::set<unsigned> requiredSectors(Track& track) const;
+
+private:
+	const NorthstarDecoderProto& _config;
+	uint8_t _sectorType;
+	uint8_t _hardSectorId;
+};
+
+class NorthstarEncoder : public AbstractEncoder
+{
+public:
+	NorthstarEncoder(const NorthstarEncoderProto& config):
+		_config(config)
+	{}
+
+	virtual ~NorthstarEncoder() {}
+	std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+
+private:
+	const NorthstarEncoderProto& _config;
+};
+
+extern FlagGroup northstarEncoderFlags;
+extern uint8_t northstarChecksum(const Bytes& bytes);
+
+#endif /* NORTHSTAR */
--- a/arch/northstar/northstar.proto
+++ b/arch/northstar/northstar.proto
@@ -0,0 +1,5 @@
+syntax = "proto2";
+
+message NorthstarDecoderProto {}
+message NorthstarEncoderProto {}
+
--- a/arch/tids990/decoder.cc
+++ b/arch/tids990/decoder.cc
@@ -40,7 +40,7 @@ const FluxPattern DATA_RECORD_PATTERN(32, 0x11112245);

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

-AbstractDecoder::RecordType TiDs990Decoder::advanceToNextRecord()
+AbstractDecoder::RecordType Tids990Decoder::advanceToNextRecord()
 {
 	const FluxMatcher* matcher = nullptr;
 	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
@@ -51,7 +51,7 @@ AbstractDecoder::RecordType TiDs990Decoder::advanceToNextRecord()
 	return RecordType::UNKNOWN_RECORD;
 }

-void TiDs990Decoder::decodeSectorRecord()
+void Tids990Decoder::decodeSectorRecord()
 {
    auto bits = readRawBits(TIDS990_SECTOR_RECORD_SIZE*16);
    auto bytes = decodeFmMfm(bits).slice(0, TIDS990_SECTOR_RECORD_SIZE);
@@ -71,7 +71,7 @@ void TiDs990Decoder::decodeSectorRecord()
        _sector->status = Sector::DATA_MISSING; /* correct but unintuitive */
 }

-void TiDs990Decoder::decodeDataRecord()
+void Tids990Decoder::decodeDataRecord()
 {
 	auto bits = readRawBits(TIDS990_DATA_RECORD_SIZE*16);
 	auto bytes = decodeFmMfm(bits).slice(0, TIDS990_DATA_RECORD_SIZE);
--- a/arch/tids990/encoder.cc
+++ b/arch/tids990/encoder.cc
@@ -6,55 +6,9 @@
 #include "crc.h"
 #include "sectorset.h"
 #include "writer.h"
+#include "arch/tids990/tids990.pb.h"
 #include <fmt/format.h>

-FlagGroup tids990EncoderFlags;
-
-static IntFlag trackLengthMs(
-	{ "--tids990-track-length-ms" },
-	"Length of a track in milliseconds.",
-	166);
-
-static IntFlag sectorCount(
-	{ "--tids990-sector-count" },
-	"Number of sectors per track.",
-	26);
-
-static IntFlag clockRateKhz(
-	{ "--tids990-clock-rate-khz" },
-	"Clock rate of data to write.",
-	500);
-
-static HexIntFlag am1Byte(
-	{ "--tids990-am1-byte" },
-	"16-bit RAW bit pattern to use for the AM1 ID byte",
-	0x2244);
-
-static HexIntFlag am2Byte(
-	{ "--tids990-am2-byte" },
-	"16-bit RAW bit pattern to use for the AM2 ID byte",
-	0x2245);
-
-static IntFlag gap1(
-	{ "--tids990-gap1-bytes" },
-	"Size of gap 1 (the post-index gap).",
-	80);
-
-static IntFlag gap2(
-	{ "--tids990-gap2-bytes" },
-	"Size of gap 2 (the post-ID gap).",
-	21);
-
-static IntFlag gap3(
-	{ "--tids990-gap3-bytes" },
-	"Size of gap 3 (the post-data or format gap).",
-	51);
-
-static StringFlag sectorSkew(
-	{ "--tids990-sector-skew" },
-	"Order to emit sectors.",
-	"1mhc72nid83oje94pkfa50lgb6");
-
 static int charToInt(char c)
 {
 	if (isdigit(c))
@@ -62,7 +16,7 @@ static int charToInt(char c)
 	return 10 + tolower(c) - 'a';
 }

-void TiDs990Encoder::writeRawBits(uint32_t data, int width)
+void Tids990Encoder::writeRawBits(uint32_t data, int width)
 {
 	_cursor += width;
 	_lastBit = data & 1;
@@ -75,12 +29,12 @@ void TiDs990Encoder::writeRawBits(uint32_t data, int width)
 	}
 }

-void TiDs990Encoder::writeBytes(const Bytes& bytes)
+void Tids990Encoder::writeBytes(const Bytes& bytes)
 {
 	encodeMfm(_bits, _cursor, bytes, _lastBit);
 }

-void TiDs990Encoder::writeBytes(int count, uint8_t byte)
+void Tids990Encoder::writeBytes(int count, uint8_t byte)
 {
 	Bytes bytes = { byte };
 	for (int i=0; i<count; i++)
@@ -95,25 +49,25 @@ static uint8_t decodeUint16(uint16_t raw)
 	return decodeFmMfm(b.toBits())[0];
 }

-std::unique_ptr<Fluxmap> TiDs990Encoder::encode(
+std::unique_ptr<Fluxmap> Tids990Encoder::encode(
 	int physicalTrack, int physicalSide, const SectorSet& allSectors)
 {
-	double clockRateUs = 1e3 / clockRateKhz / 2.0;
-	int bitsPerRevolution = (trackLengthMs * 1000.0) / clockRateUs;
+	double clockRateUs = 1e3 / _config.clock_rate_khz() / 2.0;
+	int bitsPerRevolution = (_config.track_length_ms() * 1000.0) / clockRateUs;
 	_bits.resize(bitsPerRevolution);
 	_cursor = 0;

-	uint8_t am1Unencoded = decodeUint16(am1Byte);
-	uint8_t am2Unencoded = decodeUint16(am2Byte);
+	uint8_t am1Unencoded = decodeUint16(_config.am1_byte());
+	uint8_t am2Unencoded = decodeUint16(_config.am2_byte());

-	writeBytes(gap1, 0x55);
+	writeBytes(_config.gap1_bytes(), 0x55);

 	bool first = true;
-	for (char sectorChar : sectorSkew.get())
+	for (char sectorChar : _config.sector_skew())
 	{
 		int sectorId = charToInt(sectorChar);
 		if (!first)
-			writeBytes(gap3, 0x55);
+			writeBytes(_config.gap3_bytes(), 0x55);
 		first = false;

 		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
@@ -136,17 +90,17 @@ std::unique_ptr<Fluxmap> TiDs990Encoder::encode(
 			bw.write_8(am1Unencoded);
 			bw.write_8(sectorData->logicalSide << 3);
 			bw.write_8(sectorData->logicalTrack);
-			bw.write_8(sectorCount);
+			bw.write_8(_config.sector_count());
 			bw.write_8(sectorData->logicalSector);
 			bw.write_be16(sectorData->data.size());
 			uint16_t crc = crc16(CCITT_POLY, header);
 			bw.write_be16(crc);

-			writeRawBits(am1Byte, 16);
+			writeRawBits(_config.am1_byte(), 16);
 			writeBytes(header.slice(1));
 		}

-		writeBytes(gap2, 0x55);
+		writeBytes(_config.gap2_bytes(), 0x55);

 		{
 			Bytes data;
@@ -159,7 +113,7 @@ std::unique_ptr<Fluxmap> TiDs990Encoder::encode(
 			uint16_t crc = crc16(CCITT_POLY, data);
 			bw.write_be16(crc);

-			writeRawBits(am2Byte, 16);
+			writeRawBits(_config.am2_byte(), 16);
 			writeBytes(data.slice(1));
 		}
    }
--- a/arch/tids990/tids990.h
+++ b/arch/tids990/tids990.h
@@ -9,21 +9,27 @@ class Sector;
 class SectorSet;
 class Fluxmap;
 class Track;
+class Tids990DecoderProto;
+class Tids990EncoderProto;

-class TiDs990Decoder : public AbstractDecoder
+class Tids990Decoder : public AbstractDecoder
 {
 public:
-    virtual ~TiDs990Decoder() {}
+	Tids990Decoder(const Tids990DecoderProto&) {}
+    virtual ~Tids990Decoder() {}

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

-class TiDs990Encoder : public AbstractEncoder
+class Tids990Encoder : public AbstractEncoder
 {
 public:
-	virtual ~TiDs990Encoder() {}
+	Tids990Encoder(const Tids990EncoderProto& config):
+		_config(config)
+	{}
+	virtual ~Tids990Encoder() {}

 private:
 	void writeRawBits(uint32_t data, int width);
@@ -35,6 +41,7 @@ public:
    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);

 private:
+	const Tids990EncoderProto& _config;
 	std::vector<bool> _bits;
 	unsigned _cursor;
 	bool _lastBit;
--- a/arch/tids990/tids990.proto
+++ b/arch/tids990/tids990.proto
@@ -0,0 +1,26 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Tids990DecoderProto {}
+message Tids990EncoderProto {
+	optional double track_length_ms = 1 [ default = 166,
+		(help) = "length of a track" ];
+	optional int32 sector_count = 2 [ default = 26,
+		(help) = "number of sectors per track" ];
+	optional double clock_rate_khz = 3 [ default = 500,
+		(help) = "clock rate of data to write" ];
+	optional int32 am1_byte = 4 [ default = 0x2244,
+		(help) = "16-bit RAW bit pattern to use for the AM1 ID byte" ];
+	optional int32 am2_byte = 5 [ default = 0x2245,
+		(help) = "16-bit RAW bit pattern to use for the AM2 ID byte" ];
+	optional int32 gap1_bytes = 6 [ default = 80,
+		(help) = "size of gap 1 (the post-index gap)" ];
+	optional int32 gap2_bytes = 7 [ default = 21,
+		(help) = "size of gap 2 (the post-ID gap)" ];
+	optional int32 gap3_bytes = 8 [ default = 51,
+		(help) = "size of gap 3 (the post-data or format gap)" ];
+	optional string sector_skew = 9 [ default = "1mhc72nid83oje94pkfa50lgb6",
+		(help) = "order to emit sectors" ];
+}
+
--- a/arch/victor9k/victor9k.h
+++ b/arch/victor9k/victor9k.h
@@ -8,10 +8,12 @@

 class Sector;
 class Fluxmap;
+class Victor9kDecoderProto;

 class Victor9kDecoder : public AbstractDecoder
 {
 public:
+	Victor9kDecoder(const Victor9kDecoderProto&) {}
    virtual ~Victor9kDecoder() {}

    RecordType advanceToNextRecord();
--- a/arch/victor9k/victor9k.proto
+++ b/arch/victor9k/victor9k.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message Victor9kDecoderProto {}
+
--- a/arch/zilogmcz/zilogmcz.h
+++ b/arch/zilogmcz/zilogmcz.h
@@ -3,10 +3,12 @@

 class Sector;
 class Fluxmap;
+class ZilogMczDecoderProto;

 class ZilogMczDecoder : public AbstractDecoder
 {
 public:
+	ZilogMczDecoder(const ZilogMczDecoderProto&) {}
    virtual ~ZilogMczDecoder() {}

    RecordType advanceToNextRecord();
--- a/arch/zilogmcz/zilogmcz.proto
+++ b/arch/zilogmcz/zilogmcz.proto
@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message ZilogMczDecoderProto {}
+
--- a/dep/agg/AUTHORS
+++ b/dep/agg/AUTHORS
@@ -0,0 +1,2 @@
+Anti-Grain Geometry - Version 2.4
+Copyright (C) 2002-2005 Maxim Shemanarev (McSeem) 
--- a/dep/agg/README
+++ b/dep/agg/README
@@ -0,0 +1,63 @@
+The Anti-Grain Geometry Project
+A high quality rendering engine for C++
+http://antigrain.com
+
+Anti-Grain Geometry - Version 2.4
+Copyright (C) 2002-2005 Maxim Shemanarev (McSeem)
+
+Permission to copy, use, modify, sell and distribute this software
+is granted provided this copyright notice appears in all copies.
+This software is provided "as is" without express or implied
+warranty, and with no claim as to its suitability for any purpose.
+
+---------------------------------
+
+Use automake to build the library.
+
+If automake is not available you still can use the old make.
+There is a very simple Makefile that can be used. Note that
+if you use automake it will overwrite Makefile.
+
+---------------------------------
+
+If building on AmigaOS 4.0 or higher type the following for
+instructions on what targets are available.
+ make -f Makefile.AmigaOS
+
+To just build and install AGG into the standard AmigaOS SDK
+ready for use type:
+ make -f Makefile.AmigaOS install
+
+If you just want to build one demo (e.g. lion) use:
+ make -f Makefile.AmigaOS bin/lion
+
+If you have any questions about the AmigaOS port please
+contact Steven Solie (ssolie@telus.net) for help.
+
+---------------------------------
+
+To build all examples using SDL (Mac or Linux) just type:
+
+cd /examples/sdl
+make
+
+Individual examples can be built with
+
+make aa_test
+
+In the same way the native Carbon examples can be built with
+
+cd /examples/macosx_carbon
+make
+
+In both cases the static library will be built (if it was not already) 
+from the existing global Makefile in /src/.
+
+The Makefiles for both SDL and Carbon will also attempt to download the 
+required .bmp files if they are not found in the system for a given 
+example. If the files could not be fetched (wget) the user will receive 
+a message explaining where to download the samples from (sphere.bmp, 
+etc.)  Since all programs reside in the same directory there is no need 
+to duplicate the .bmp files for each program that needs to use them.
+
+---------------------------------
--- a/dep/agg/README.md
+++ b/dep/agg/README.md
@@ -0,0 +1,7 @@
+This is a vary stripped down copy of the Anti-Grain Antialiasing graphics
+rendering library --- I've removed all the platform-specific and control stuff
+so that it can be used to generate memory images only.
+
+The original AGG site is dead, so this version is cloned from
+https://github.com/NNemec/antigrain.
+
--- a/dep/agg/UPSTREAM.md
+++ b/dep/agg/UPSTREAM.md
@@ -0,0 +1,7 @@
+This is a vary stripped down copy of the Anti-Grain Antialiasing graphics
+rendering library --- I've removed all the platform-specific and control stuff
+so that it can be used to generate memory images only.
+
+The original AGG site is dead, so this version is cloned from
+https://github.com/NNemec/antigrain.
+
--- a/dep/agg/include/Makefile.am
+++ b/dep/agg/include/Makefile.am
@@ -0,0 +1,49 @@
+SUBDIRS = ctrl util platform 
+
+aggincludedir = $(includedir)/agg2
+agginclude_HEADERS = \
+	agg_alpha_mask_u8.h          agg_glyph_raster_bin.h          agg_span_allocator.h \
+	agg_arc.h                    agg_gsv_text.h                  agg_span_converter.h \
+	agg_array.h                  agg_image_accessors.h           agg_span_gouraud.h \
+	agg_arrowhead.h              agg_image_filters.h             agg_span_gouraud_gray.h \
+	agg_basics.h                 agg_line_aa_basics.h            agg_span_gouraud_rgba.h \
+	agg_bezier_arc.h             agg_math.h                      agg_span_gradient.h \
+	agg_bitset_iterator.h        agg_blur.h                      agg_math_stroke.h \
+	agg_span_gradient_alpha.h    agg_gradient_lut.h \
+	agg_bounding_rect.h          agg_path_length.h               agg_span_image_filter.h \
+	agg_bspline.h                agg_path_storage.h              agg_span_image_filter_gray.h \
+	agg_clip_liang_barsky.h      agg_path_storage_integer.h      agg_span_image_filter_rgb.h \
+	agg_color_gray.h             agg_pattern_filters_rgba.h      agg_span_image_filter_rgba.h \
+	agg_color_rgba.h             agg_pixfmt_amask_adaptor.h      agg_span_interpolator_adaptor.h \
+	agg_config.h                 agg_pixfmt_gray.h               agg_span_interpolator_linear.h \
+	agg_conv_adaptor_vcgen.h     agg_pixfmt_rgb.h                agg_span_interpolator_persp.h \
+	agg_conv_adaptor_vpgen.h     agg_pixfmt_rgb_packed.h         agg_span_interpolator_trans.h \
+	agg_conv_bspline.h           agg_pixfmt_rgba.h               agg_pixfmt_transposer.h \
+	agg_span_pattern_gray.h \
+	agg_conv_clip_polygon.h      agg_rasterizer_cells_aa.h       agg_span_pattern_rgb.h \
+	agg_conv_clip_polyline.h     agg_rasterizer_compound_aa.h    agg_span_pattern_rgba.h \
+	agg_conv_close_polygon.h     agg_rasterizer_outline.h        agg_span_solid.h \
+	agg_conv_concat.h            agg_rasterizer_outline_aa.h     agg_span_subdiv_adaptor.h \
+	agg_conv_contour.h           agg_rasterizer_scanline_aa.h    agg_trans_affine.h \
+	agg_conv_curve.h             agg_rasterizer_sl_clip.h        agg_trans_bilinear.h \
+	agg_conv_dash.h              agg_renderer_base.h             agg_trans_double_path.h \
+	agg_conv_gpc.h               agg_renderer_markers.h \
+	agg_conv_marker.h            agg_renderer_mclip.h            agg_trans_perspective.h \
+	agg_conv_marker_adaptor.h    agg_renderer_outline_aa.h       agg_trans_single_path.h \
+	agg_conv_segmentator.h       agg_renderer_outline_image.h    agg_trans_viewport.h \
+	agg_conv_shorten_path.h      agg_renderer_primitives.h       agg_trans_warp_magnifier.h \
+	agg_conv_smooth_poly1.h      agg_renderer_raster_text.h      agg_vcgen_bspline.h \
+	agg_conv_stroke.h            agg_renderer_scanline.h         agg_vcgen_contour.h \
+	agg_conv_transform.h         agg_rendering_buffer.h          agg_vcgen_dash.h \
+	agg_conv_unclose_polygon.h   agg_rendering_buffer_dynarow.h  agg_vcgen_markers_term.h \
+	agg_curves.h                 agg_rounded_rect.h              agg_vcgen_smooth_poly1.h \
+	                             agg_scanline_bin.h              agg_vcgen_stroke.h \
+	agg_dda_line.h               agg_scanline_boolean_algebra.h  agg_vcgen_vertex_sequence.h \
+	agg_ellipse.h                agg_scanline_p.h                agg_vertex_sequence.h \
+	agg_ellipse_bresenham.h      agg_scanline_storage_aa.h       agg_vpgen_clip_polygon.h \
+	agg_embedded_raster_fonts.h  agg_scanline_storage_bin.h      agg_vpgen_clip_polyline.h \
+	agg_font_cache_manager.h     agg_scanline_u.h                agg_vpgen_segmentator.h \
+	agg_gamma_functions.h        agg_shorten_path.h \
+	agg_gamma_lut.h              agg_simul_eq.h \
+	agg_font_cache_manager2.h    agg_pixfmt_base.h               agg_rasterizer_scanline_aa_nogamma.h \
+	agg_span_gradient_contour.h  agg_span_gradient_image.h
--- a/dep/agg/include/agg2d.h
+++ b/dep/agg/include/agg2d.h
@@ -0,0 +1,568 @@
+//----------------------------------------------------------------------------
+// Agg2D - Version 1.0
+// Based on Anti-Grain Geometry
+// Copyright (C) 2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//
+//	25 Jan 2007 - Ported to AGG 2.4 Jerry Evans (jerry@novadsp.com)
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG2D_INCLUDED
+#define AGG2D_INCLUDED
+
+// With this define uncommented you can use floating-point pixel format
+//#define AGG2D_USE_FLOAT_FORMAT
+
+#include "agg_basics.h"
+#include "agg_trans_affine.h"
+#include "agg_trans_viewport.h"
+#include "agg_path_storage.h"
+#include "agg_conv_stroke.h"
+#include "agg_conv_transform.h"
+#include "agg_conv_curve.h"
+#include "agg_rendering_buffer.h"
+#include "agg_renderer_base.h"
+#include "agg_renderer_scanline.h"
+#include "agg_span_gradient.h"
+#include "agg_span_image_filter_rgba.h"
+#include "agg_span_allocator.h"
+#include "agg_span_converter.h"
+#include "agg_span_interpolator_linear.h"
+#include "agg_rasterizer_scanline_aa.h"
+#include "agg_gamma_functions.h"
+#include "agg_scanline_u.h"
+#include "agg_bezier_arc.h"
+#include "agg_rounded_rect.h"
+#include "agg_font_cache_manager.h"
+
+#include "agg_pixfmt_rgba.h"
+#include "agg_image_accessors.h"
+#include <string>
+
+class Agg2D
+{
+#ifdef AGG2D_USE_FLOAT_FORMAT
+    typedef agg::rgba32 ColorType;
+#else
+    typedef agg::rgba8  ColorType;
+#endif
+    typedef agg::order_bgra ComponentOrder; // Platform dependent!
+    typedef agg::blender_rgba<ColorType, ComponentOrder>             Blender;
+    typedef agg::comp_op_adaptor_rgba<ColorType, ComponentOrder>     BlenderComp;
+    typedef agg::blender_rgba_pre<ColorType, ComponentOrder>         BlenderPre;
+    typedef agg::comp_op_adaptor_rgba_pre<ColorType, ComponentOrder> BlenderCompPre;
+
+    typedef agg::pixfmt_alpha_blend_rgba<Blender, agg::rendering_buffer>         PixFormat;
+    typedef agg::pixfmt_custom_blend_rgba<BlenderComp, agg::rendering_buffer>    PixFormatComp;
+    typedef agg::pixfmt_alpha_blend_rgba<BlenderPre, agg::rendering_buffer>      PixFormatPre;
+    typedef agg::pixfmt_custom_blend_rgba<BlenderCompPre, agg::rendering_buffer> PixFormatCompPre;
+
+    typedef agg::renderer_base<PixFormat>        RendererBase;
+    typedef agg::renderer_base<PixFormatComp>    RendererBaseComp;
+    typedef agg::renderer_base<PixFormatPre>     RendererBasePre;
+    typedef agg::renderer_base<PixFormatCompPre> RendererBaseCompPre;
+
+    typedef agg::renderer_scanline_aa_solid<RendererBase>     RendererSolid;
+    typedef agg::renderer_scanline_aa_solid<RendererBaseComp> RendererSolidComp;
+
+    typedef agg::span_allocator<ColorType> SpanAllocator;
+    typedef agg::pod_auto_array<ColorType, 256> GradientArray;
+
+    typedef agg::span_gradient<ColorType, agg::span_interpolator_linear<>, agg::gradient_x,      GradientArray> LinearGradientSpan;
+    typedef agg::span_gradient<ColorType, agg::span_interpolator_linear<>, agg::gradient_circle, GradientArray> RadialGradientSpan;
+
+    typedef agg::conv_curve<agg::path_storage>    ConvCurve;
+    typedef agg::conv_stroke<ConvCurve>           ConvStroke;
+    typedef agg::conv_transform<ConvCurve>        PathTransform;
+    typedef agg::conv_transform<ConvStroke>       StrokeTransform;
+
+    enum Gradient
+    {
+        Solid,
+        Linear,
+        Radial
+    };
+
+public:
+    friend class Agg2DRenderer;
+
+    // Use srgba8 as the "user" color type, even though the underlying color type 
+    // might be something else, such as rgba32. This allows code based on 
+    // 8-bit sRGB values to carry on working as before.
+    typedef agg::srgba8       Color;
+    typedef agg::rect_i       Rect;
+    typedef agg::rect_d       RectD;
+    typedef agg::trans_affine Affine;
+
+    enum LineJoin
+    {
+        JoinMiter = agg::miter_join,
+        JoinRound = agg::round_join,
+        JoinBevel = agg::bevel_join
+    };
+
+    enum LineCap
+    {
+        CapButt   = agg::butt_cap,
+        CapSquare = agg::square_cap,
+        CapRound  = agg::round_cap
+    };
+
+    enum TextAlignment
+    {
+        AlignLeft,
+        AlignRight,
+        AlignCenter,
+    };
+
+
+    enum DrawPathFlag
+    {
+        FillOnly,
+        StrokeOnly,
+        FillAndStroke,
+        FillWithLineColor
+    };
+
+    enum ViewportOption
+    {
+        Anisotropic,
+        XMinYMin,
+        XMidYMin,
+        XMaxYMin,
+        XMinYMid,
+        XMidYMid,
+        XMaxYMid,
+        XMinYMax,
+        XMidYMax,
+        XMaxYMax
+    };
+
+    struct Transformations
+    {
+        double affineMatrix[6];
+    };
+
+
+    struct Image
+    {
+        agg::rendering_buffer renBuf;
+
+        Image() {}
+        Image(unsigned char* buf, unsigned width, unsigned height, int stride) :
+            renBuf(buf, width, height, stride) {}
+        void attach(unsigned char* buf, unsigned width, unsigned height, int stride)
+        {
+            renBuf.attach(buf, width, height, stride);
+        }
+        int width()  const { return renBuf.width(); }
+        int height() const { return renBuf.height(); }
+        void premultiply();
+        void demultiply();
+    };
+
+    enum ImageFilter
+    {
+        NoFilter,
+        Bilinear,
+        Hanning,
+        Hermite,
+        Quadric,
+        Bicubic,
+        Catrom,
+        Spline16,
+        Spline36,
+        Blackman144
+    };
+
+    enum ImageResample
+    {
+        NoResample,
+        ResampleAlways,
+        ResampleOnZoomOut
+    };
+
+    enum FontCacheType
+    {
+        RasterFontCache,
+        VectorFontCache
+    };
+
+    enum BlendMode
+    {
+        BlendAlpha      = agg::end_of_comp_op_e,
+        BlendClear      = agg::comp_op_clear,
+        BlendSrc        = agg::comp_op_src,
+        BlendDst        = agg::comp_op_dst,
+        BlendSrcOver    = agg::comp_op_src_over,
+        BlendDstOver    = agg::comp_op_dst_over,
+        BlendSrcIn      = agg::comp_op_src_in,
+        BlendDstIn      = agg::comp_op_dst_in,
+        BlendSrcOut     = agg::comp_op_src_out,
+        BlendDstOut     = agg::comp_op_dst_out,
+        BlendSrcAtop    = agg::comp_op_src_atop,
+        BlendDstAtop    = agg::comp_op_dst_atop,
+        BlendXor        = agg::comp_op_xor,
+        BlendAdd        = agg::comp_op_plus,
+        BlendMultiply   = agg::comp_op_multiply,
+        BlendScreen     = agg::comp_op_screen,
+        BlendOverlay    = agg::comp_op_overlay,
+        BlendDarken     = agg::comp_op_darken,
+        BlendLighten    = agg::comp_op_lighten,
+        BlendColorDodge = agg::comp_op_color_dodge,
+        BlendColorBurn  = agg::comp_op_color_burn,
+        BlendHardLight  = agg::comp_op_hard_light,
+        BlendSoftLight  = agg::comp_op_soft_light,
+        BlendDifference = agg::comp_op_difference,
+        BlendExclusion  = agg::comp_op_exclusion,
+    };
+
+    enum Direction
+    {
+        CW, CCW
+    };
+
+    ~Agg2D();
+    Agg2D();
+
+    // Setup
+    //-----------------------
+    void  attach(unsigned char* buf, unsigned width, unsigned height, int stride);
+    void  attach(Image& img);
+
+    void  clipBox(double x1, double y1, double x2, double y2);
+    RectD clipBox() const;
+
+    void  clearAll(Color c);
+    void  clearAll(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+
+    void  clearClipBox(Color c);
+    void  clearClipBox(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+
+    // Conversions
+    //-----------------------
+    void   worldToScreen(double& x, double& y) const;
+    void   screenToWorld(double& x, double& y) const;
+    double worldToScreen(double scalar) const;
+    double screenToWorld(double scalar) const;
+    void   alignPoint(double& x, double& y) const;
+    bool   inBox(double worldX, double worldY) const;
+
+    // General Attributes
+    //-----------------------
+    void blendMode(BlendMode m);
+    BlendMode blendMode() const;
+
+    void imageBlendMode(BlendMode m);
+    BlendMode imageBlendMode() const;
+
+    void imageBlendColor(Color c);
+    void imageBlendColor(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+    Color imageBlendColor() const;
+
+    void masterAlpha(double a);
+    double masterAlpha() const;
+
+    void antiAliasGamma(double g);
+    double antiAliasGamma() const;
+
+    void fillColor(Color c);
+    void fillColor(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+    void noFill();
+
+    void lineColor(Color c);
+    void lineColor(unsigned r, unsigned g, unsigned b, unsigned a = 255);
+    void noLine();
+
+    Color fillColor() const;
+    Color lineColor() const;
+
+    void fillLinearGradient(double x1, double y1, double x2, double y2, Color c1, Color c2, double profile=1.0);
+    void lineLinearGradient(double x1, double y1, double x2, double y2, Color c1, Color c2, double profile=1.0);
+
+    void fillRadialGradient(double x, double y, double r, Color c1, Color c2, double profile=1.0);
+    void lineRadialGradient(double x, double y, double r, Color c1, Color c2, double profile=1.0);
+
+    void fillRadialGradient(double x, double y, double r, Color c1, Color c2, Color c3);
+    void lineRadialGradient(double x, double y, double r, Color c1, Color c2, Color c3);
+
+    void fillRadialGradient(double x, double y, double r);
+    void lineRadialGradient(double x, double y, double r);
+
+    void lineWidth(double w);
+    double lineWidth(double w) const;
+
+    void lineCap(LineCap cap);
+    LineCap lineCap() const;
+
+    void lineJoin(LineJoin join);
+    LineJoin lineJoin() const;
+
+    void fillEvenOdd(bool evenOddFlag);
+    bool fillEvenOdd() const;
+
+	void textAlignment(TextAlignment alignment);
+	void textSize(double sizeX, double sizeY);
+	inline void textSize(double size) { textSize(size, size); }
+
+    // Transformations
+    //-----------------------
+    Transformations transformations() const;
+    void transformations(const Transformations& tr);
+    void resetTransformations();
+    void affine(const Affine& tr);
+    void affine(const Transformations& tr);
+    void rotate(double angle);
+    void scale(double sx, double sy);
+    void skew(double sx, double sy);
+    void translate(double x, double y);
+    void parallelogram(double x1, double y1, double x2, double y2, const double* para);
+    void viewport(double worldX1,  double worldY1,  double worldX2,  double worldY2,
+                  double screenX1, double screenY1, double screenX2, double screenY2,
+                  ViewportOption opt=XMidYMid);
+
+    // Basic Shapes
+    //-----------------------
+    void line(double x1, double y1, double x2, double y2);
+    void triangle(double x1, double y1, double x2, double y2, double x3, double y3);
+    void rectangle(double x1, double y1, double x2, double y2);
+    void roundedRect(double x1, double y1, double x2, double y2, double r);
+    void roundedRect(double x1, double y1, double x2, double y2, double rx, double ry);
+    void roundedRect(double x1, double y1, double x2, double y2,
+                     double rxBottom, double ryBottom,
+                     double rxTop,    double ryTop);
+    void ellipse(double cx, double cy, double rx, double ry);
+    void arc(double cx, double cy, double rx, double ry, double start, double sweep);
+    void star(double cx, double cy, double r1, double r2, double startAngle, int numRays);
+    void curve(double x1, double y1, double x2, double y2, double x3, double y3);
+    void curve(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
+    void polygon(double* xy, int numPoints);
+    void polyline(double* xy, int numPoints);
+
+    // Path commands
+    //-----------------------
+    void resetPath();
+
+    void moveTo(double x, double y);
+    void moveRel(double dx, double dy);
+
+    void lineTo(double x, double y);
+    void lineRel(double dx, double dy);
+
+    void horLineTo(double x);
+    void horLineRel(double dx);
+
+    void verLineTo(double y);
+    void verLineRel(double dy);
+
+    void arcTo(double rx, double ry,
+               double angle,
+               bool largeArcFlag,
+               bool sweepFlag,
+               double x, double y);
+
+    void arcRel(double rx, double ry,
+                double angle,
+                bool largeArcFlag,
+                bool sweepFlag,
+                double dx, double dy);
+
+    void quadricCurveTo(double xCtrl, double yCtrl,
+                         double xTo,   double yTo);
+    void quadricCurveRel(double dxCtrl, double dyCtrl,
+                         double dxTo,   double dyTo);
+    void quadricCurveTo(double xTo, double yTo);
+    void quadricCurveRel(double dxTo, double dyTo);
+
+    void cubicCurveTo(double xCtrl1, double yCtrl1,
+                      double xCtrl2, double yCtrl2,
+                      double xTo,    double yTo);
+
+    void cubicCurveRel(double dxCtrl1, double dyCtrl1,
+                       double dxCtrl2, double dyCtrl2,
+                       double dxTo,    double dyTo);
+
+    void cubicCurveTo(double xCtrl2, double yCtrl2,
+                      double xTo,    double yTo);
+
+    void cubicCurveRel(double xCtrl2, double yCtrl2,
+                       double xTo,    double yTo);
+
+    void addEllipse(double cx, double cy, double rx, double ry, Direction dir);
+	void text(double x, double y, const std::string& text);
+    void closePolygon();
+
+    void drawPath(DrawPathFlag flag = FillAndStroke);
+    void drawPathNoTransform(DrawPathFlag flag = FillAndStroke);
+
+
+    // Image Transformations
+    //-----------------------
+    void imageFilter(ImageFilter f);
+    ImageFilter imageFilter() const;
+
+    void imageResample(ImageResample f);
+    ImageResample imageResample() const;
+
+    void transformImage(const Image& img,
+                           int imgX1,    int imgY1,    int imgX2,    int imgY2,
+                        double dstX1, double dstY1, double dstX2, double dstY2);
+
+    void transformImage(const Image& img,
+                        double dstX1, double dstY1, double dstX2, double dstY2);
+
+    void transformImage(const Image& img,
+                        int imgX1, int imgY1, int imgX2, int imgY2,
+                        const double* parallelogram);
+
+    void transformImage(const Image& img, const double* parallelogram);
+
+
+    void transformImagePath(const Image& img,
+                               int imgX1,    int imgY1,    int imgX2,    int imgY2,
+                            double dstX1, double dstY1, double dstX2, double dstY2);
+
+    void transformImagePath(const Image& img,
+                            double dstX1, double dstY1, double dstX2, double dstY2);
+
+    void transformImagePath(const Image& img,
+                            int imgX1, int imgY1, int imgX2, int imgY2,
+                            const double* parallelogram);
+
+    void transformImagePath(const Image& img, const double* parallelogram);
+
+
+    // Image Blending (no transformations available)
+    void blendImage(Image& img,
+                    int imgX1, int imgY1, int imgX2, int imgY2,
+                    double dstX, double dstY, unsigned alpha=255);
+    void blendImage(Image& img, double dstX, double dstY, unsigned alpha=255);
+
+
+    // Copy image directly, together with alpha-channel
+    void copyImage(Image& img,
+                   int imgX1, int imgY1, int imgX2, int imgY2,
+                   double dstX, double dstY);
+    void copyImage(Image& img, double dstX, double dstY);
+
+
+    // Auxiliary
+    //-----------------------
+    static double pi() { return agg::pi; }
+    static double deg2Rad(double v) { return v * agg::pi / 180.0; }
+    static double rad2Deg(double v) { return v * 180.0 / agg::pi; }
+
+private:
+    void render(bool fillColor);
+#ifdef AGG_USE_FONTS
+    void render(FontRasterizer& ras, FontScanline& sl);
+#endif // AGG_USE_FONTS
+
+    void addLine(double x1, double y1, double x2, double y2);
+    void updateRasterizerGamma();
+    void renderImage(const Image& img, int x1, int y1, int x2, int y2, const double* parl);
+
+    agg::rendering_buffer           m_rbuf;
+    PixFormat                       m_pixFormat;
+    PixFormatComp                   m_pixFormatComp;
+    PixFormatPre                    m_pixFormatPre;
+    PixFormatCompPre                m_pixFormatCompPre;
+    RendererBase                    m_renBase;
+    RendererBaseComp                m_renBaseComp;
+    RendererBasePre                 m_renBasePre;
+    RendererBaseCompPre             m_renBaseCompPre;
+    RendererSolid                   m_renSolid;
+    RendererSolidComp               m_renSolidComp;
+
+    SpanAllocator                   m_allocator;
+    RectD                           m_clipBox;
+
+    BlendMode                       m_blendMode;
+    BlendMode                       m_imageBlendMode;
+    Color                           m_imageBlendColor;
+
+    agg::scanline_u8                m_scanline;
+    agg::rasterizer_scanline_aa<>   m_rasterizer;
+
+    double                          m_masterAlpha;
+    double                          m_antiAliasGamma;
+
+    Color                           m_fillColor;
+    Color                           m_lineColor;
+    GradientArray                   m_fillGradient;
+    GradientArray                   m_lineGradient;
+
+    LineCap                         m_lineCap;
+    LineJoin                        m_lineJoin;
+
+    Gradient                        m_fillGradientFlag;
+    Gradient                        m_lineGradientFlag;
+    agg::trans_affine               m_fillGradientMatrix;
+    agg::trans_affine               m_lineGradientMatrix;
+    double                          m_fillGradientD1;
+    double                          m_lineGradientD1;
+    double                          m_fillGradientD2;
+    double                          m_lineGradientD2;
+
+    TextAlignment                   m_textAlignment;
+    double                          m_textSizeX;
+    double                          m_textSizeY;
+
+    ImageFilter                     m_imageFilter;
+    ImageResample                   m_imageResample;
+    agg::image_filter_lut           m_imageFilterLut;
+
+    agg::span_interpolator_linear<> m_fillGradientInterpolator;
+    agg::span_interpolator_linear<> m_lineGradientInterpolator;
+
+    agg::gradient_x                 m_linearGradientFunction;
+    agg::gradient_circle            m_radialGradientFunction;
+
+    double                          m_lineWidth;
+    bool                            m_evenOddFlag;
+
+    agg::path_storage               m_path;
+    agg::trans_affine               m_transform;
+
+    ConvCurve                       m_convCurve;
+    ConvStroke                      m_convStroke;
+
+    PathTransform                   m_pathTransform;
+    StrokeTransform                 m_strokeTransform;
+
+#ifdef AGG_USE_FONTS
+#ifndef AGG2D_USE_FREETYPE
+    HDC                             m_fontDC;
+#endif
+    FontEngine                      m_fontEngine;
+    FontCacheManager                m_fontCacheManager;
+#endif
+};
+
+
+inline bool operator == (const Agg2D::Color& c1, const Agg2D::Color& c2)
+{
+   return c1.r == c2.r && c1.g == c2.g && c1.b == c2.b && c1.a == c2.a;
+}
+
+inline bool operator != (const Agg2D::Color& c1, const Agg2D::Color& c2)
+{
+   return !(c1 == c2);
+}
+
+
+#endif
+
+
--- a/dep/agg/include/agg_alpha_mask_u8.h
+++ b/dep/agg/include/agg_alpha_mask_u8.h
@@ -0,0 +1,499 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// scanline_u8 class
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_ALPHA_MASK_U8_INCLUDED
+#define AGG_ALPHA_MASK_U8_INCLUDED
+
+#include <cstring>
+#include "agg_basics.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+    //===================================================one_component_mask_u8
+    struct one_component_mask_u8
+    {
+        static unsigned calculate(const int8u* p) { return *p; }
+    };
+    
+
+    //=====================================================rgb_to_gray_mask_u8
+    template<unsigned R, unsigned G, unsigned B>
+    struct rgb_to_gray_mask_u8
+    {
+        static unsigned calculate(const int8u* p) 
+        { 
+            return (p[R]*77 + p[G]*150 + p[B]*29) >> 8; 
+        }
+    };
+
+    //==========================================================alpha_mask_u8
+    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
+    class alpha_mask_u8
+    {
+    public:
+        typedef int8u cover_type;
+        typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
+        enum cover_scale_e
+        { 
+            cover_shift = 8,
+            cover_none  = 0,
+            cover_full  = 255
+        };
+
+        alpha_mask_u8() : m_rbuf(0) {}
+        explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+
+        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+        MaskF& mask_function() { return m_mask_function; }
+        const MaskF& mask_function() const { return m_mask_function; }
+
+        
+        //--------------------------------------------------------------------
+        cover_type pixel(int x, int y) const
+        {
+            if(x >= 0 && y >= 0 && 
+               x < (int)m_rbuf->width() && 
+               y < (int)m_rbuf->height())
+            {
+                return (cover_type)m_mask_function.calculate(
+                                        m_rbuf->row_ptr(y) + x * Step + Offset);
+            }
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        cover_type combine_pixel(int x, int y, cover_type val) const
+        {
+            if(x >= 0 && y >= 0 && 
+               x < (int)m_rbuf->width() && 
+               y < (int)m_rbuf->height())
+            {
+                return (cover_type)((cover_full + val * 
+                                     m_mask_function.calculate(
+                                        m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
+                                     cover_shift);
+            }
+            return 0;
+        }
+
+
+        //--------------------------------------------------------------------
+        void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(y < 0 || y > ymax)
+            {
+                std::memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(x < 0)
+            {
+                count += x;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers, 0, -x * sizeof(cover_type));
+                covers -= x;
+                x = 0;
+            }
+
+            if(x + count > xmax)
+            {
+                int rest = x + count - xmax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers++ = (cover_type)m_mask_function.calculate(mask);
+                mask += Step;
+            }
+            while(--count);
+        }
+
+
+        //--------------------------------------------------------------------
+        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(y < 0 || y > ymax)
+            {
+                std::memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(x < 0)
+            {
+                count += x;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers, 0, -x * sizeof(cover_type));
+                covers -= x;
+                x = 0;
+            }
+
+            if(x + count > xmax)
+            {
+                int rest = x + count - xmax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers = (cover_type)((cover_full + (*covers) * 
+                                       m_mask_function.calculate(mask)) >> 
+                                       cover_shift);
+                ++covers;
+                mask += Step;
+            }
+            while(--count);
+        }
+
+        //--------------------------------------------------------------------
+        void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(x < 0 || x > xmax)
+            {
+                std::memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(y < 0)
+            {
+                count += y;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers, 0, -y * sizeof(cover_type));
+                covers -= y;
+                y = 0;
+            }
+
+            if(y + count > ymax)
+            {
+                int rest = y + count - ymax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers++ = (cover_type)m_mask_function.calculate(mask);
+                mask += m_rbuf->stride();
+            }
+            while(--count);
+        }
+
+        //--------------------------------------------------------------------
+        void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            int xmax = m_rbuf->width() - 1;
+            int ymax = m_rbuf->height() - 1;
+
+            int count = num_pix;
+            cover_type* covers = dst;
+
+            if(x < 0 || x > xmax)
+            {
+                std::memset(dst, 0, num_pix * sizeof(cover_type));
+                return;
+            }
+
+            if(y < 0)
+            {
+                count += y;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers, 0, -y * sizeof(cover_type));
+                covers -= y;
+                y = 0;
+            }
+
+            if(y + count > ymax)
+            {
+                int rest = y + count - ymax - 1;
+                count -= rest;
+                if(count <= 0) 
+                {
+                    std::memset(dst, 0, num_pix * sizeof(cover_type));
+                    return;
+                }
+                std::memset(covers + count, 0, rest * sizeof(cover_type));
+            }
+
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *covers = (cover_type)((cover_full + (*covers) * 
+                                       m_mask_function.calculate(mask)) >> 
+                                       cover_shift);
+                ++covers;
+                mask += m_rbuf->stride();
+            }
+            while(--count);
+        }
+
+
+    private:
+        alpha_mask_u8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        rendering_buffer* m_rbuf;
+        MaskF             m_mask_function;
+    };
+    
+
+    typedef alpha_mask_u8<1, 0> alpha_mask_gray8;   //----alpha_mask_gray8
+
+    typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r;  //----alpha_mask_rgb24r
+    typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g;  //----alpha_mask_rgb24g
+    typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b;  //----alpha_mask_rgb24b
+
+    typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r;  //----alpha_mask_bgr24r
+    typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g;  //----alpha_mask_bgr24g
+    typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b;  //----alpha_mask_bgr24b
+
+    typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
+    typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
+    typedef alpha_mask_u8<4, 2> alpha_mask_rgba32b; //----alpha_mask_rgba32b
+    typedef alpha_mask_u8<4, 3> alpha_mask_rgba32a; //----alpha_mask_rgba32a
+
+    typedef alpha_mask_u8<4, 1> alpha_mask_argb32r; //----alpha_mask_argb32r
+    typedef alpha_mask_u8<4, 2> alpha_mask_argb32g; //----alpha_mask_argb32g
+    typedef alpha_mask_u8<4, 3> alpha_mask_argb32b; //----alpha_mask_argb32b
+    typedef alpha_mask_u8<4, 0> alpha_mask_argb32a; //----alpha_mask_argb32a
+
+    typedef alpha_mask_u8<4, 2> alpha_mask_bgra32r; //----alpha_mask_bgra32r
+    typedef alpha_mask_u8<4, 1> alpha_mask_bgra32g; //----alpha_mask_bgra32g
+    typedef alpha_mask_u8<4, 0> alpha_mask_bgra32b; //----alpha_mask_bgra32b
+    typedef alpha_mask_u8<4, 3> alpha_mask_bgra32a; //----alpha_mask_bgra32a
+
+    typedef alpha_mask_u8<4, 3> alpha_mask_abgr32r; //----alpha_mask_abgr32r
+    typedef alpha_mask_u8<4, 2> alpha_mask_abgr32g; //----alpha_mask_abgr32g
+    typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
+    typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
+
+    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgb24gray;  //----alpha_mask_rgb24gray
+    typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgr24gray;  //----alpha_mask_bgr24gray
+    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
+    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_argb32gray; //----alpha_mask_argb32gray
+    typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
+    typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
+
+
+
+    //==========================================================amask_no_clip_u8
+    template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
+    class amask_no_clip_u8
+    {
+    public:
+        typedef int8u cover_type;
+        typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
+        enum cover_scale_e
+        { 
+            cover_shift = 8,
+            cover_none  = 0,
+            cover_full  = 255
+        };
+
+        amask_no_clip_u8() : m_rbuf(0) {}
+        explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+
+        void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+        MaskF& mask_function() { return m_mask_function; }
+        const MaskF& mask_function() const { return m_mask_function; }
+
+
+        //--------------------------------------------------------------------
+        cover_type pixel(int x, int y) const
+        {
+            return (cover_type)m_mask_function.calculate(
+                                   m_rbuf->row_ptr(y) + x * Step + Offset);
+        }
+
+        
+        //--------------------------------------------------------------------
+        cover_type combine_pixel(int x, int y, cover_type val) const
+        {
+            return (cover_type)((cover_full + val * 
+                                 m_mask_function.calculate(
+                                    m_rbuf->row_ptr(y) + x * Step + Offset)) >> 
+                                 cover_shift);
+        }
+
+
+        //--------------------------------------------------------------------
+        void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst++ = (cover_type)m_mask_function.calculate(mask);
+                mask += Step;
+            }
+            while(--num_pix);
+        }
+
+
+
+        //--------------------------------------------------------------------
+        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst = (cover_type)((cover_full + (*dst) * 
+                                    m_mask_function.calculate(mask)) >> 
+                                    cover_shift);
+                ++dst;
+                mask += Step;
+            }
+            while(--num_pix);
+        }
+
+
+        //--------------------------------------------------------------------
+        void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst++ = (cover_type)m_mask_function.calculate(mask);
+                mask += m_rbuf->stride();
+            }
+            while(--num_pix);
+        }
+
+
+        //--------------------------------------------------------------------
+        void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
+        {
+            const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+            do
+            {
+                *dst = (cover_type)((cover_full + (*dst) * 
+                                    m_mask_function.calculate(mask)) >> 
+                                    cover_shift);
+                ++dst;
+                mask += m_rbuf->stride();
+            }
+            while(--num_pix);
+        }
+
+    private:
+        amask_no_clip_u8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        rendering_buffer* m_rbuf;
+        MaskF             m_mask_function;
+    };
+    
+
+    typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8;   //----amask_no_clip_gray8
+
+    typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r;  //----amask_no_clip_rgb24r
+    typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g;  //----amask_no_clip_rgb24g
+    typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b;  //----amask_no_clip_rgb24b
+
+    typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r;  //----amask_no_clip_bgr24r
+    typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g;  //----amask_no_clip_bgr24g
+    typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b;  //----amask_no_clip_bgr24b
+
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
+
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
+
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
+
+    typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
+    typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
+    typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
+    typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
+
+    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgb24gray;  //----amask_no_clip_rgb24gray
+    typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgr24gray;  //----amask_no_clip_bgr24gray
+    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
+    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
+    typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
+    typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
+
+
+}
+
+
+
+#endif
--- a/dep/agg/include/agg_arc.h
+++ b/dep/agg/include/agg_arc.h
@@ -0,0 +1,73 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Arc vertex generator
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_ARC_INCLUDED
+#define AGG_ARC_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //=====================================================================arc
+    //
+    // See Implementation agg_arc.cpp 
+    //
+    class arc
+    {
+    public:
+        arc() : m_scale(1.0), m_initialized(false) {}
+        arc(double x,  double y, 
+            double rx, double ry, 
+            double a1, double a2, 
+            bool ccw=true);
+
+        void init(double x,  double y, 
+                  double rx, double ry, 
+                  double a1, double a2, 
+                  bool ccw=true);
+
+        void approximation_scale(double s);
+        double approximation_scale() const { return m_scale;  }
+
+        void rewind(unsigned);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        void normalize(double a1, double a2, bool ccw);
+
+        double   m_x;
+        double   m_y;
+        double   m_rx;
+        double   m_ry;
+        double   m_angle;
+        double   m_start;
+        double   m_end;
+        double   m_scale;
+        double   m_da;
+        bool     m_ccw;
+        bool     m_initialized;
+        unsigned m_path_cmd;
+    };
+
+
+}
+
+
+#endif
--- a/dep/agg/include/agg_array.h
+++ b/dep/agg/include/agg_array.h
--- a/dep/agg/include/agg_arrowhead.h
+++ b/dep/agg/include/agg_arrowhead.h
@@ -0,0 +1,82 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Simple arrowhead/arrowtail generator 
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_ARROWHEAD_INCLUDED
+#define AGG_ARROWHEAD_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //===============================================================arrowhead
+    //
+    // See implementation agg_arrowhead.cpp 
+    //
+    class arrowhead
+    {
+    public:
+        arrowhead();
+
+        void head(double d1, double d2, double d3, double d4)
+        {
+            m_head_d1 = d1;
+            m_head_d2 = d2;
+            m_head_d3 = d3;
+            m_head_d4 = d4;
+            m_head_flag = true;
+        }
+
+        void head()    { m_head_flag = true; }
+        void no_head() { m_head_flag = false; }
+
+        void tail(double d1, double d2, double d3, double d4)
+        {
+            m_tail_d1 = d1;
+            m_tail_d2 = d2;
+            m_tail_d3 = d3;
+            m_tail_d4 = d4;
+            m_tail_flag = true;
+        }
+
+        void tail()    { m_tail_flag = true;  }
+        void no_tail() { m_tail_flag = false; }
+
+        void rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        double   m_head_d1;
+        double   m_head_d2;
+        double   m_head_d3;
+        double   m_head_d4;
+        double   m_tail_d1;
+        double   m_tail_d2;
+        double   m_tail_d3;
+        double   m_tail_d4;
+        bool     m_head_flag;
+        bool     m_tail_flag;
+        double   m_coord[16];
+        unsigned m_cmd[8];
+        unsigned m_curr_id;
+        unsigned m_curr_coord;
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_basics.h
+++ b/dep/agg/include/agg_basics.h
@@ -0,0 +1,574 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BASICS_INCLUDED
+#define AGG_BASICS_INCLUDED
+
+#include <cmath>
+#include "agg_config.h"
+
+//---------------------------------------------------------AGG_CUSTOM_ALLOCATOR
+#ifdef AGG_CUSTOM_ALLOCATOR
+#include "agg_allocator.h"
+#else
+namespace agg
+{
+    // The policy of all AGG containers and memory allocation strategy 
+    // in general is that no allocated data requires explicit construction.
+    // It means that the allocator can be really simple; you can even
+    // replace new/delete to malloc/free. The constructors and destructors 
+    // won't be called in this case, however everything will remain working. 
+    // The second argument of deallocate() is the size of the allocated 
+    // block. You can use this information if you wish.
+    //------------------------------------------------------------pod_allocator
+    template<class T> struct pod_allocator
+    {
+        static T*   allocate(unsigned num)       { return new T [num]; }
+        static void deallocate(T* ptr, unsigned) { delete [] ptr;      }
+    };
+
+    // Single object allocator. It's also can be replaced with your custom
+    // allocator. The difference is that it can only allocate a single 
+    // object and the constructor and destructor must be called. 
+    // In AGG there is no need to allocate an array of objects with
+    // calling their constructors (only single ones). So that, if you
+    // replace these new/delete to malloc/free make sure that the in-place
+    // new is called and take care of calling the destructor too.
+    //------------------------------------------------------------obj_allocator
+    template<class T> struct obj_allocator
+    {
+        static T*   allocate()         { return new T; }
+        static void deallocate(T* ptr) { delete ptr;   }
+    };
+}
+#endif
+
+
+//-------------------------------------------------------- Default basic types
+//
+// If the compiler has different capacity of the basic types you can redefine
+// them via the compiler command line or by generating agg_config.h that is
+// empty by default.
+//
+#ifndef AGG_INT8
+#define AGG_INT8 signed char
+#endif
+
+#ifndef AGG_INT8U
+#define AGG_INT8U unsigned char
+#endif
+
+#ifndef AGG_INT16
+#define AGG_INT16 short
+#endif
+
+#ifndef AGG_INT16U
+#define AGG_INT16U unsigned short
+#endif
+
+#ifndef AGG_INT32
+#define AGG_INT32 int
+#endif
+
+#ifndef AGG_INT32U
+#define AGG_INT32U unsigned
+#endif
+
+#ifndef AGG_INT64
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define AGG_INT64 signed __int64
+#else
+#define AGG_INT64 signed long long
+#endif
+#endif
+
+#ifndef AGG_INT64U
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define AGG_INT64U unsigned __int64
+#else
+#define AGG_INT64U unsigned long long
+#endif
+#endif
+
+//------------------------------------------------ Some fixes for MS Visual C++
+#if defined(_MSC_VER)
+#pragma warning(disable:4786) // Identifier was truncated...
+#endif
+
+#if defined(_MSC_VER)
+#define AGG_INLINE __forceinline
+#else
+#define AGG_INLINE inline
+#endif
+
+namespace agg
+{
+    //-------------------------------------------------------------------------
+    typedef AGG_INT8   int8;         //----int8
+    typedef AGG_INT8U  int8u;        //----int8u
+    typedef AGG_INT16  int16;        //----int16
+    typedef AGG_INT16U int16u;       //----int16u
+    typedef AGG_INT32  int32;        //----int32
+    typedef AGG_INT32U int32u;       //----int32u
+    typedef AGG_INT64  int64;        //----int64
+    typedef AGG_INT64U int64u;       //----int64u
+
+#if defined(AGG_FISTP)
+#pragma warning(push)
+#pragma warning(disable : 4035) //Disable warning "no return value"
+    AGG_INLINE int iround(double v)              //-------iround
+    {
+        int t;
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
+    }
+    AGG_INLINE unsigned uround(double v)         //-------uround
+    {
+        unsigned t;
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
+    }
+#pragma warning(pop)
+    AGG_INLINE int ifloor(double v)
+    {
+        return int(floor(v));
+    }
+    AGG_INLINE unsigned ufloor(double v)         //-------ufloor
+    {
+        return unsigned(floor(v));
+    }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
+    AGG_INLINE unsigned uceil(double v)          //--------uceil
+    {
+        return unsigned(ceil(v));
+    }
+#elif defined(AGG_QIFIST)
+    AGG_INLINE int iround(double v)
+    {
+        return int(v);
+    }
+    AGG_INLINE int uround(double v)
+    {
+        return unsigned(v);
+    }
+    AGG_INLINE int ifloor(double v)
+    {
+        return int(std::floor(v));
+    }
+    AGG_INLINE unsigned ufloor(double v)
+    {
+        return unsigned(std::floor(v));
+    }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(std::ceil(v));
+    }
+    AGG_INLINE unsigned uceil(double v)
+    {
+        return unsigned(std::ceil(v));
+    }
+#else
+    AGG_INLINE int iround(double v)
+    {
+        return int((v < 0.0) ? v - 0.5 : v + 0.5);
+    }
+    AGG_INLINE int uround(double v)
+    {
+        return unsigned(v + 0.5);
+    }
+    AGG_INLINE int ifloor(double v)
+    {
+        int i = int(v);
+        return i - (i > v);
+    }
+    AGG_INLINE unsigned ufloor(double v)
+    {
+        return unsigned(v);
+    }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(std::ceil(v));
+    }
+    AGG_INLINE unsigned uceil(double v)
+    {
+        return unsigned(std::ceil(v));
+    }
+#endif
+
+    //---------------------------------------------------------------saturation
+    template<int Limit> struct saturation
+    {
+        AGG_INLINE static int iround(double v)
+        {
+            if(v < double(-Limit)) return -Limit;
+            if(v > double( Limit)) return  Limit;
+            return agg::iround(v);
+        }
+    };
+
+    //------------------------------------------------------------------mul_one
+    template<unsigned Shift> struct mul_one
+    {
+        AGG_INLINE static unsigned mul(unsigned a, unsigned b)
+        {
+            unsigned q = a * b + (1 << (Shift-1));
+            return (q + (q >> Shift)) >> Shift;
+        }
+    };
+
+    //-------------------------------------------------------------------------
+    typedef unsigned char cover_type;    //----cover_type
+    enum cover_scale_e
+    {
+        cover_shift = 8,                 //----cover_shift
+        cover_size  = 1 << cover_shift,  //----cover_size 
+        cover_mask  = cover_size - 1,    //----cover_mask 
+        cover_none  = 0,                 //----cover_none 
+        cover_full  = cover_mask         //----cover_full 
+    };
+
+    //----------------------------------------------------poly_subpixel_scale_e
+    // These constants determine the subpixel accuracy, to be more precise, 
+    // the number of bits of the fractional part of the coordinates. 
+    // The possible coordinate capacity in bits can be calculated by formula:
+    // sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
+    // 8-bits fractional part the capacity is 24 bits.
+    enum poly_subpixel_scale_e
+    {
+        poly_subpixel_shift = 8,                      //----poly_subpixel_shift
+        poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 
+        poly_subpixel_mask  = poly_subpixel_scale-1   //----poly_subpixel_mask 
+    };
+
+    //----------------------------------------------------------filling_rule_e
+    enum filling_rule_e
+    {
+        fill_non_zero,
+        fill_even_odd
+    };
+
+    //-----------------------------------------------------------------------pi
+    const double pi = 3.14159265358979323846;
+
+    //------------------------------------------------------------------deg2rad
+    inline double deg2rad(double deg)
+    {
+        return deg * pi / 180.0;
+    }
+
+    //------------------------------------------------------------------rad2deg
+    inline double rad2deg(double rad)
+    {
+        return rad * 180.0 / pi;
+    }
+ 
+    //----------------------------------------------------------------rect_base
+    template<class T> struct rect_base
+    {
+        typedef T            value_type;
+        typedef rect_base<T> self_type;
+        T x1, y1, x2, y2;
+
+        rect_base() {}
+        rect_base(T x1_, T y1_, T x2_, T y2_) :
+            x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
+
+        void init(T x1_, T y1_, T x2_, T y2_) 
+        {
+            x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; 
+        }
+
+        const self_type& normalize()
+        {
+            T t;
+            if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
+            if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
+            return *this;
+        }
+
+        bool clip(const self_type& r)
+        {
+            if(x2 > r.x2) x2 = r.x2;
+            if(y2 > r.y2) y2 = r.y2;
+            if(x1 < r.x1) x1 = r.x1;
+            if(y1 < r.y1) y1 = r.y1;
+            return x1 <= x2 && y1 <= y2;
+        }
+
+        bool is_valid() const
+        {
+            return x1 <= x2 && y1 <= y2;
+        }
+
+        bool hit_test(T x, T y) const
+        {
+            return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
+        }
+        
+        bool overlaps(const self_type& r) const
+        {
+            return !(r.x1 > x2 || r.x2 < x1
+                  || r.y1 > y2 || r.y2 < y1);
+        }
+    };
+
+    //-----------------------------------------------------intersect_rectangles
+    template<class Rect> 
+    inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
+    {
+        Rect r = r1;
+
+        // First process x2,y2 because the other order 
+        // results in Internal Compiler Error under 
+        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 
+        // case of "Maximize Speed" optimization option.
+        //-----------------
+        if(r.x2 > r2.x2) r.x2 = r2.x2; 
+        if(r.y2 > r2.y2) r.y2 = r2.y2;
+        if(r.x1 < r2.x1) r.x1 = r2.x1;
+        if(r.y1 < r2.y1) r.y1 = r2.y1;
+        return r;
+    }
+
+
+    //---------------------------------------------------------unite_rectangles
+    template<class Rect> 
+    inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
+    {
+        Rect r = r1;
+        if(r.x2 < r2.x2) r.x2 = r2.x2;
+        if(r.y2 < r2.y2) r.y2 = r2.y2;
+        if(r.x1 > r2.x1) r.x1 = r2.x1;
+        if(r.y1 > r2.y1) r.y1 = r2.y1;
+        return r;
+    }
+
+    typedef rect_base<int>    rect_i; //----rect_i
+    typedef rect_base<float>  rect_f; //----rect_f
+    typedef rect_base<double> rect_d; //----rect_d
+
+    //---------------------------------------------------------path_commands_e
+    enum path_commands_e
+    {
+        path_cmd_stop     = 0,        //----path_cmd_stop    
+        path_cmd_move_to  = 1,        //----path_cmd_move_to 
+        path_cmd_line_to  = 2,        //----path_cmd_line_to 
+        path_cmd_curve3   = 3,        //----path_cmd_curve3  
+        path_cmd_curve4   = 4,        //----path_cmd_curve4  
+        path_cmd_curveN   = 5,        //----path_cmd_curveN
+        path_cmd_catrom   = 6,        //----path_cmd_catrom
+        path_cmd_ubspline = 7,        //----path_cmd_ubspline
+        path_cmd_end_poly = 0x0F,     //----path_cmd_end_poly
+        path_cmd_mask     = 0x0F      //----path_cmd_mask    
+    };
+
+    //------------------------------------------------------------path_flags_e
+    enum path_flags_e
+    {
+        path_flags_none  = 0,         //----path_flags_none 
+        path_flags_ccw   = 0x10,      //----path_flags_ccw  
+        path_flags_cw    = 0x20,      //----path_flags_cw   
+        path_flags_close = 0x40,      //----path_flags_close
+        path_flags_mask  = 0xF0       //----path_flags_mask 
+    };
+
+    //---------------------------------------------------------------is_vertex
+    inline bool is_vertex(unsigned c)
+    {
+        return c >= path_cmd_move_to && c < path_cmd_end_poly;
+    }
+
+    //--------------------------------------------------------------is_drawing
+    inline bool is_drawing(unsigned c)
+    {
+        return c >= path_cmd_line_to && c < path_cmd_end_poly;
+    }
+
+    //-----------------------------------------------------------------is_stop
+    inline bool is_stop(unsigned c)
+    { 
+        return c == path_cmd_stop;
+    }
+
+    //--------------------------------------------------------------is_move_to
+    inline bool is_move_to(unsigned c)
+    {
+        return c == path_cmd_move_to;
+    }
+
+    //--------------------------------------------------------------is_line_to
+    inline bool is_line_to(unsigned c)
+    {
+        return c == path_cmd_line_to;
+    }
+
+    //----------------------------------------------------------------is_curve
+    inline bool is_curve(unsigned c)
+    {
+        return c == path_cmd_curve3 || c == path_cmd_curve4;
+    }
+
+    //---------------------------------------------------------------is_curve3
+    inline bool is_curve3(unsigned c)
+    {
+        return c == path_cmd_curve3;
+    }
+
+    //---------------------------------------------------------------is_curve4
+    inline bool is_curve4(unsigned c)
+    {
+        return c == path_cmd_curve4;
+    }
+
+    //-------------------------------------------------------------is_end_poly
+    inline bool is_end_poly(unsigned c)
+    {
+        return (c & path_cmd_mask) == path_cmd_end_poly;
+    }
+
+    //----------------------------------------------------------------is_close
+    inline bool is_close(unsigned c)
+    {
+        return (c & ~(path_flags_cw | path_flags_ccw)) ==
+               (path_cmd_end_poly | path_flags_close); 
+    }
+
+    //------------------------------------------------------------is_next_poly
+    inline bool is_next_poly(unsigned c)
+    {
+        return is_stop(c) || is_move_to(c) || is_end_poly(c);
+    }
+
+    //-------------------------------------------------------------------is_cw
+    inline bool is_cw(unsigned c)
+    {
+        return (c & path_flags_cw) != 0;
+    }
+
+    //------------------------------------------------------------------is_ccw
+    inline bool is_ccw(unsigned c)
+    {
+        return (c & path_flags_ccw) != 0;
+    }
+
+    //-------------------------------------------------------------is_oriented
+    inline bool is_oriented(unsigned c)
+    {
+        return (c & (path_flags_cw | path_flags_ccw)) != 0; 
+    }
+
+    //---------------------------------------------------------------is_closed
+    inline bool is_closed(unsigned c)
+    {
+        return (c & path_flags_close) != 0; 
+    }
+
+    //----------------------------------------------------------get_close_flag
+    inline unsigned get_close_flag(unsigned c)
+    {
+        return c & path_flags_close; 
+    }
+
+    //-------------------------------------------------------clear_orientation
+    inline unsigned clear_orientation(unsigned c)
+    {
+        return c & ~(path_flags_cw | path_flags_ccw);
+    }
+
+    //---------------------------------------------------------get_orientation
+    inline unsigned get_orientation(unsigned c)
+    {
+        return c & (path_flags_cw | path_flags_ccw);
+    }
+
+    //---------------------------------------------------------set_orientation
+    inline unsigned set_orientation(unsigned c, unsigned o)
+    {
+        return clear_orientation(c) | o;
+    }
+
+    //--------------------------------------------------------------point_base
+    template<class T> struct point_base
+    {
+        typedef T value_type;
+        T x,y;
+        point_base() {}
+        point_base(T x_, T y_) : x(x_), y(y_) {}
+    };
+    typedef point_base<int>    point_i; //-----point_i
+    typedef point_base<float>  point_f; //-----point_f
+    typedef point_base<double> point_d; //-----point_d
+
+    //-------------------------------------------------------------vertex_base
+    template<class T> struct vertex_base
+    {
+        typedef T value_type;
+        T x,y;
+        unsigned cmd;
+        vertex_base() {}
+        vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
+    };
+    typedef vertex_base<int>    vertex_i; //-----vertex_i
+    typedef vertex_base<float>  vertex_f; //-----vertex_f
+    typedef vertex_base<double> vertex_d; //-----vertex_d
+
+    //----------------------------------------------------------------row_info
+    template<class T> struct row_info
+    {
+        int x1, x2;
+        T* ptr;
+        row_info() {}
+        row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {}
+    };
+
+    //----------------------------------------------------------const_row_info
+    template<class T> struct const_row_info
+    {
+        int x1, x2;
+        const T* ptr;
+        const_row_info() {}
+        const_row_info(int x1_, int x2_, const T* ptr_) : 
+            x1(x1_), x2(x2_), ptr(ptr_) {}
+    };
+
+    //------------------------------------------------------------is_equal_eps
+    template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
+    {
+	bool neg1 = v1 < 0.0;
+	bool neg2 = v2 < 0.0;
+
+	if (neg1 != neg2)
+	    return std::fabs(v1) < epsilon && std::fabs(v2) < epsilon;
+
+        int int1, int2;
+	std::frexp(v1, &int1);
+	std::frexp(v2, &int2);
+	int min12 = int1 < int2 ? int1 : int2;
+
+	v1 = std::ldexp(v1, -min12);
+	v2 = std::ldexp(v2, -min12);
+
+	return std::fabs(v1 - v2) < epsilon;
+    }
+}
+
+
+#endif
+
--- a/dep/agg/include/agg_bezier_arc.h
+++ b/dep/agg/include/agg_bezier_arc.h
@@ -0,0 +1,159 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
+// 4, 7, 10, or 13 vertices.
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BEZIER_ARC_INCLUDED
+#define AGG_BEZIER_ARC_INCLUDED
+
+#include "agg_conv_transform.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------------------
+    void arc_to_bezier(double cx, double cy, double rx, double ry, 
+                       double start_angle, double sweep_angle,
+                       double* curve);
+
+
+    //==============================================================bezier_arc
+    // 
+    // See implemantaion agg_bezier_arc.cpp
+    //
+    class bezier_arc
+    {
+    public:
+        //--------------------------------------------------------------------
+        bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
+        bezier_arc(double x,  double y, 
+                   double rx, double ry, 
+                   double start_angle, 
+                   double sweep_angle)
+        {
+            init(x, y, rx, ry, start_angle, sweep_angle);
+        }
+
+        //--------------------------------------------------------------------
+        void init(double x,  double y, 
+                  double rx, double ry, 
+                  double start_angle, 
+                  double sweep_angle);
+
+        //--------------------------------------------------------------------
+        void rewind(unsigned)
+        {
+            m_vertex = 0;
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_vertex >= m_num_vertices) return path_cmd_stop;
+            *x = m_vertices[m_vertex];
+            *y = m_vertices[m_vertex + 1];
+            m_vertex += 2;
+            return (m_vertex == 2) ? unsigned(path_cmd_move_to) : m_cmd;
+        }
+
+        // Supplemantary functions. num_vertices() actually returns doubled 
+        // number of vertices. That is, for 1 vertex it returns 2.
+        //--------------------------------------------------------------------
+        unsigned  num_vertices() const { return m_num_vertices; }
+        const double* vertices() const { return m_vertices;     }
+        double*       vertices()       { return m_vertices;     }
+ 
+    private:
+        unsigned m_vertex;
+        unsigned m_num_vertices;
+        double   m_vertices[26];
+        unsigned m_cmd;
+    };
+
+
+
+    //==========================================================bezier_arc_svg
+    // Compute an SVG-style bezier arc. 
+    //
+    // Computes an elliptical arc from (x1, y1) to (x2, y2). The size and 
+    // orientation of the ellipse are defined by two radii (rx, ry) 
+    // and an x-axis-rotation, which indicates how the ellipse as a whole 
+    // is rotated relative to the current coordinate system. The center 
+    // (cx, cy) of the ellipse is calculated automatically to satisfy the 
+    // constraints imposed by the other parameters. 
+    // large-arc-flag and sweep-flag contribute to the automatic calculations 
+    // and help determine how the arc is drawn.
+    class bezier_arc_svg
+    {
+    public:
+        //--------------------------------------------------------------------
+        bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
+
+        bezier_arc_svg(double x1, double y1, 
+                       double rx, double ry, 
+                       double angle,
+                       bool large_arc_flag,
+                       bool sweep_flag,
+                       double x2, double y2) : 
+            m_arc(), m_radii_ok(false)
+        {
+            init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
+        }
+
+        //--------------------------------------------------------------------
+        void init(double x1, double y1, 
+                  double rx, double ry, 
+                  double angle,
+                  bool large_arc_flag,
+                  bool sweep_flag,
+                  double x2, double y2);
+
+        //--------------------------------------------------------------------
+        bool radii_ok() const { return m_radii_ok; }
+
+        //--------------------------------------------------------------------
+        void rewind(unsigned)
+        {
+            m_arc.rewind(0);
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            return m_arc.vertex(x, y);
+        }
+
+        // Supplemantary functions. num_vertices() actually returns doubled 
+        // number of vertices. That is, for 1 vertex it returns 2.
+        //--------------------------------------------------------------------
+        unsigned  num_vertices() const { return m_arc.num_vertices(); }
+        const double* vertices() const { return m_arc.vertices();     }
+        double*       vertices()       { return m_arc.vertices();     }
+
+    private:
+        bezier_arc m_arc;
+        bool       m_radii_ok;
+    };
+
+
+
+
+}
+
+
+#endif
--- a/dep/agg/include/agg_bitset_iterator.h
+++ b/dep/agg/include/agg_bitset_iterator.h
@@ -0,0 +1,54 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BITSET_ITERATOR_INCLUDED
+#define AGG_BITSET_ITERATOR_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    
+    class bitset_iterator
+    {
+    public:
+        bitset_iterator(const int8u* bits, unsigned offset = 0) :
+            m_bits(bits + (offset >> 3)),
+            m_mask(0x80 >> (offset & 7))
+        {}
+
+        void operator ++ ()
+        {
+            m_mask >>= 1;
+            if(m_mask == 0)
+            {
+                ++m_bits;
+                m_mask = 0x80;
+            }
+        }
+
+        unsigned bit() const
+        {
+            return (*m_bits) & m_mask;
+        }
+
+    private:
+        const int8u* m_bits;
+        int8u        m_mask;
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_blur.h
+++ b/dep/agg/include/agg_blur.h
--- a/dep/agg/include/agg_bounding_rect.h
+++ b/dep/agg/include/agg_bounding_rect.h
@@ -0,0 +1,116 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// bounding_rect function template
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_BOUNDING_RECT_INCLUDED
+#define AGG_BOUNDING_RECT_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------bounding_rect
+    template<class VertexSource, class GetId, class CoordT>
+    bool bounding_rect(VertexSource& vs, GetId& gi, 
+                       unsigned start, unsigned num, 
+                       CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
+    {
+        unsigned i;
+        double x;
+        double y;
+        bool first = true;
+
+        *x1 = CoordT(1);
+        *y1 = CoordT(1);
+        *x2 = CoordT(0);
+        *y2 = CoordT(0);
+
+        for(i = 0; i < num; i++)
+        {
+            vs.rewind(gi[start + i]);
+            unsigned cmd;
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
+            {
+                if(is_vertex(cmd))
+                {
+                    if(first)
+                    {
+                        *x1 = CoordT(x);
+                        *y1 = CoordT(y);
+                        *x2 = CoordT(x);
+                        *y2 = CoordT(y);
+                        first = false;
+                    }
+                    else
+                    {
+                        if(CoordT(x) < *x1) *x1 = CoordT(x);
+                        if(CoordT(y) < *y1) *y1 = CoordT(y);
+                        if(CoordT(x) > *x2) *x2 = CoordT(x);
+                        if(CoordT(y) > *y2) *y2 = CoordT(y);
+                    }
+                }
+            }
+        }
+        return *x1 <= *x2 && *y1 <= *y2;
+    }
+
+
+    //-----------------------------------------------------bounding_rect_single
+    template<class VertexSource, class CoordT> 
+    bool bounding_rect_single(VertexSource& vs, unsigned path_id,
+                              CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
+    {
+        double x;
+        double y;
+        bool first = true;
+
+        *x1 = CoordT(1);
+        *y1 = CoordT(1);
+        *x2 = CoordT(0);
+        *y2 = CoordT(0);
+
+        vs.rewind(path_id);
+        unsigned cmd;
+        while(!is_stop(cmd = vs.vertex(&x, &y)))
+        {
+            if(is_vertex(cmd))
+            {
+                if(first)
+                {
+                    *x1 = CoordT(x);
+                    *y1 = CoordT(y);
+                    *x2 = CoordT(x);
+                    *y2 = CoordT(y);
+                    first = false;
+                }
+                else
+                {
+                    if(CoordT(x) < *x1) *x1 = CoordT(x);
+                    if(CoordT(y) < *y1) *y1 = CoordT(y);
+                    if(CoordT(x) > *x2) *x2 = CoordT(x);
+                    if(CoordT(y) > *y2) *y2 = CoordT(y);
+                }
+            }
+        }
+        return *x1 <= *x2 && *y1 <= *y2;
+    }
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_bspline.h
+++ b/dep/agg/include/agg_bspline.h
@@ -0,0 +1,76 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class bspline
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BSPLINE_INCLUDED
+#define AGG_BSPLINE_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+    //----------------------------------------------------------------bspline
+    // A very simple class of Bi-cubic Spline interpolation.
+    // First call init(num, x[], y[]) where num - number of source points, 
+    // x, y - arrays of X and Y values respectively. Here Y must be a function 
+    // of X. It means that all the X-coordinates must be arranged in the ascending
+    // order. 
+    // Then call get(x) that calculates a value Y for the respective X. 
+    // The class supports extrapolation, i.e. you can call get(x) where x is
+    // outside the given with init() X-range. Extrapolation is a simple linear 
+    // function.
+    //
+    //  See Implementation agg_bspline.cpp
+    //------------------------------------------------------------------------
+    class bspline 
+    {
+    public:
+        bspline();
+        bspline(int num);
+        bspline(int num, const double* x, const double* y);
+
+        void   init(int num);
+        void   add_point(double x, double y);
+        void   prepare();
+
+        void   init(int num, const double* x, const double* y);
+
+        double get(double x) const;
+        double get_stateful(double x) const;
+    
+    private:
+        bspline(const bspline&);
+        const bspline& operator = (const bspline&);
+
+        static void bsearch(int n, const double *x, double x0, int *i);
+        double extrapolation_left(double x) const;
+        double extrapolation_right(double x) const;
+        double interpolation(double x, int i) const;
+
+        int               m_max;
+        int               m_num;
+        double*           m_x;
+        double*           m_y;
+        pod_array<double> m_am;
+        mutable int       m_last_idx;
+    };
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_clip_liang_barsky.h
+++ b/dep/agg/include/agg_clip_liang_barsky.h
@@ -0,0 +1,333 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Liang-Barsky clipping 
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CLIP_LIANG_BARSKY_INCLUDED
+#define AGG_CLIP_LIANG_BARSKY_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    enum clipping_flags_e
+    {
+        clipping_flags_x1_clipped = 4,
+        clipping_flags_x2_clipped = 1,
+        clipping_flags_y1_clipped = 8,
+        clipping_flags_y2_clipped = 2,
+        clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
+        clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
+    };
+
+    //----------------------------------------------------------clipping_flags
+    // Determine the clipping code of the vertex according to the 
+    // Cyrus-Beck line clipping algorithm
+    //
+    //        |        |
+    //  0110  |  0010  | 0011
+    //        |        |
+    // -------+--------+-------- clip_box.y2
+    //        |        |
+    //  0100  |  0000  | 0001
+    //        |        |
+    // -------+--------+-------- clip_box.y1
+    //        |        |
+    //  1100  |  1000  | 1001
+    //        |        |
+    //  clip_box.x1  clip_box.x2
+    //
+    // 
+    template<class T>
+    inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
+    {
+        return  (x > clip_box.x2) |
+               ((y > clip_box.y2) << 1) |
+               ((x < clip_box.x1) << 2) |
+               ((y < clip_box.y1) << 3);
+    }
+
+    //--------------------------------------------------------clipping_flags_x
+    template<class T>
+    inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
+    {
+        return  (x > clip_box.x2) | ((x < clip_box.x1) << 2);
+    }
+
+
+    //--------------------------------------------------------clipping_flags_y
+    template<class T>
+    inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
+    {
+        return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
+    }
+
+
+    //-------------------------------------------------------clip_liang_barsky
+    template<class T>
+    inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
+                                      const rect_base<T>& clip_box,
+                                      T* x, T* y)
+    {
+        const double nearzero = 1e-30;
+
+        double deltax = x2 - x1;
+        double deltay = y2 - y1; 
+        double xin;
+        double xout;
+        double yin;
+        double yout;
+        double tinx;
+        double tiny;
+        double toutx;
+        double touty;  
+        double tin1;
+        double tin2;
+        double tout1;
+        unsigned np = 0;
+
+        if(deltax == 0.0) 
+        {   
+            // bump off of the vertical
+            deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
+        }
+
+        if(deltay == 0.0) 
+        { 
+            // bump off of the horizontal 
+            deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
+        }
+        
+        if(deltax > 0.0) 
+        {                
+            // points to right
+            xin  = clip_box.x1;
+            xout = clip_box.x2;
+        }
+        else 
+        {
+            xin  = clip_box.x2;
+            xout = clip_box.x1;
+        }
+
+        if(deltay > 0.0) 
+        {
+            // points up
+            yin  = clip_box.y1;
+            yout = clip_box.y2;
+        }
+        else 
+        {
+            yin  = clip_box.y2;
+            yout = clip_box.y1;
+        }
+        
+        tinx = (xin - x1) / deltax;
+        tiny = (yin - y1) / deltay;
+        
+        if (tinx < tiny) 
+        {
+            // hits x first
+            tin1 = tinx;
+            tin2 = tiny;
+        }
+        else
+        {
+            // hits y first
+            tin1 = tiny;
+            tin2 = tinx;
+        }
+        
+        if(tin1 <= 1.0) 
+        {
+            if(0.0 < tin1) 
+            {
+                *x++ = (T)xin;
+                *y++ = (T)yin;
+                ++np;
+            }
+
+            if(tin2 <= 1.0)
+            {
+                toutx = (xout - x1) / deltax;
+                touty = (yout - y1) / deltay;
+                
+                tout1 = (toutx < touty) ? toutx : touty;
+                
+                if(tin2 > 0.0 || tout1 > 0.0) 
+                {
+                    if(tin2 <= tout1) 
+                    {
+                        if(tin2 > 0.0) 
+                        {
+                            if(tinx > tiny) 
+                            {
+                                *x++ = (T)xin;
+                                *y++ = (T)(y1 + tinx * deltay);
+                            }
+                            else 
+                            {
+                                *x++ = (T)(x1 + tiny * deltax);
+                                *y++ = (T)yin;
+                            }
+                            ++np;
+                        }
+
+                        if(tout1 < 1.0) 
+                        {
+                            if(toutx < touty) 
+                            {
+                                *x++ = (T)xout;
+                                *y++ = (T)(y1 + toutx * deltay);
+                            }
+                            else 
+                            {
+                                *x++ = (T)(x1 + touty * deltax);
+                                *y++ = (T)yout;
+                            }
+                        }
+                        else 
+                        {
+                            *x++ = x2;
+                            *y++ = y2;
+                        }
+                        ++np;
+                    }
+                    else 
+                    {
+                        if(tinx > tiny) 
+                        {
+                            *x++ = (T)xin;
+                            *y++ = (T)yout;
+                        }
+                        else 
+                        {
+                            *x++ = (T)xout;
+                            *y++ = (T)yin;
+                        }
+                        ++np;
+                    }
+                }
+            }
+        }
+        return np;
+    }
+
+
+    //----------------------------------------------------------------------------
+    template<class T>
+    bool clip_move_point(T x1, T y1, T x2, T y2, 
+                         const rect_base<T>& clip_box, 
+                         T* x, T* y, unsigned flags)
+    {
+       T bound;
+
+       if(flags & clipping_flags_x_clipped)
+       {
+           if(x1 == x2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
+           *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
+           *x = bound;
+       }
+
+       flags = clipping_flags_y(*y, clip_box);
+       if(flags & clipping_flags_y_clipped)
+       {
+           if(y1 == y2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
+           *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
+           *y = bound;
+       }
+       return true;
+    }
+
+    //-------------------------------------------------------clip_line_segment
+    // Returns: ret >= 4        - Fully clipped
+    //          (ret & 1) != 0  - First point has been moved
+    //          (ret & 2) != 0  - Second point has been moved
+    //
+    template<class T>
+    unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
+                               const rect_base<T>& clip_box)
+    {
+        unsigned f1 = clipping_flags(*x1, *y1, clip_box);
+        unsigned f2 = clipping_flags(*x2, *y2, clip_box);
+        unsigned ret = 0;
+
+        if((f2 | f1) == 0)
+        {
+            // Fully visible
+            return 0;
+        }
+
+        if((f1 & clipping_flags_x_clipped) != 0 && 
+           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
+        {
+            // Fully clipped
+            return 4;
+        }
+
+        if((f1 & clipping_flags_y_clipped) != 0 && 
+           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
+        {
+            // Fully clipped
+            return 4;
+        }
+
+        T tx1 = *x1;
+        T ty1 = *y1;
+        T tx2 = *x2;
+        T ty2 = *y2;
+        if(f1) 
+        {   
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1)) 
+            {
+                return 4;
+            }
+            if(*x1 == *x2 && *y1 == *y2) 
+            {
+                return 4;
+            }
+            ret |= 1;
+        }
+        if(f2) 
+        {
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
+            {
+                return 4;
+            }
+            if(*x1 == *x2 && *y1 == *y2) 
+            {
+                return 4;
+            }
+            ret |= 2;
+        }
+        return ret;
+    }
+
+
+}
+
+
+#endif
--- a/dep/agg/include/agg_color_gray.h
+++ b/dep/agg/include/agg_color_gray.h
--- a/dep/agg/include/agg_color_rgba.h
+++ b/dep/agg/include/agg_color_rgba.h
--- a/dep/agg/include/agg_config.h
+++ b/dep/agg/include/agg_config.h
@@ -0,0 +1,44 @@
+#ifndef AGG_CONFIG_INCLUDED
+#define AGG_CONFIG_INCLUDED
+
+// This file can be used to redefine certain data types.
+
+//---------------------------------------
+// 1. Default basic types such as:
+// 
+// AGG_INT8
+// AGG_INT8U
+// AGG_INT16
+// AGG_INT16U
+// AGG_INT32
+// AGG_INT32U
+// AGG_INT64
+// AGG_INT64U
+//
+// Just replace this file with new defines if necessary. 
+// For example, if your compiler doesn't have a 64 bit integer type
+// you can still use AGG if you define the follows:
+//
+// #define AGG_INT64  int
+// #define AGG_INT64U unsigned
+//
+// It will result in overflow in 16 bit-per-component image/pattern resampling
+// but it won't result any crash and the rest of the library will remain 
+// fully functional.
+
+
+//---------------------------------------
+// 2. Default rendering_buffer type. Can be:
+//
+// Provides faster access for massive pixel operations, 
+// such as blur, image filtering:
+// #define AGG_RENDERING_BUFFER row_ptr_cache<int8u>
+// 
+// Provides cheaper creation and destruction (no mem allocs):
+// #define AGG_RENDERING_BUFFER row_accessor<int8u>
+//
+// You can still use both of them simultaneously in your applications 
+// This #define is used only for default rendering_buffer type,
+// in short hand typedefs like pixfmt_rgba32.
+
+#endif
--- a/dep/agg/include/agg_conv_adaptor_vcgen.h
+++ b/dep/agg/include/agg_conv_adaptor_vcgen.h
@@ -0,0 +1,157 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_ADAPTOR_VCGEN_INCLUDED
+#define AGG_CONV_ADAPTOR_VCGEN_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    //------------------------------------------------------------null_markers
+    struct null_markers
+    {
+        void remove_all() {}
+        void add_vertex(double, double, unsigned) {}
+        void prepare_src() {}
+
+        void rewind(unsigned) {}
+        unsigned vertex(double*, double*) { return path_cmd_stop; }
+    };
+
+
+    //------------------------------------------------------conv_adaptor_vcgen
+    template<class VertexSource, 
+             class Generator, 
+             class Markers=null_markers> class conv_adaptor_vcgen
+    {
+        enum status
+        {
+            initial,
+            accumulate,
+            generate
+        };
+
+    public:
+        explicit conv_adaptor_vcgen(VertexSource& source) :
+            m_source(&source), 
+            m_status(initial)
+        {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        Generator& generator() { return m_generator; }
+        const Generator& generator() const { return m_generator; }
+
+        Markers& markers() { return m_markers; }
+        const Markers& markers() const { return m_markers; }
+        
+        void rewind(unsigned path_id) 
+        { 
+            m_source->rewind(path_id); 
+            m_status = initial;
+        }
+
+        unsigned vertex(double* x, double* y);
+
+    private:
+        // Prohibit copying
+        conv_adaptor_vcgen(const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
+        const conv_adaptor_vcgen<VertexSource, Generator, Markers>& 
+            operator = (const conv_adaptor_vcgen<VertexSource, Generator, Markers>&);
+
+        VertexSource* m_source;
+        Generator     m_generator;
+        Markers       m_markers;
+        status        m_status;
+        unsigned      m_last_cmd;
+        double        m_start_x;
+        double        m_start_y;
+    };
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class Generator, class Markers> 
+    unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_stop;
+        bool done = false;
+        while(!done)
+        {
+            switch(m_status)
+            {
+            case initial:
+                m_markers.remove_all();
+                m_last_cmd = m_source->vertex(&m_start_x, &m_start_y);
+                m_status = accumulate;
+
+            case accumulate:
+                if(is_stop(m_last_cmd)) return path_cmd_stop;
+
+                m_generator.remove_all();
+                m_generator.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
+                m_markers.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
+
+                for(;;)
+                {
+                    cmd = m_source->vertex(x, y);
+                    if(is_vertex(cmd))
+                    {
+                        m_last_cmd = cmd;
+                        if(is_move_to(cmd))
+                        {
+                            m_start_x = *x;
+                            m_start_y = *y;
+                            break;
+                        }
+                        m_generator.add_vertex(*x, *y, cmd);
+                        m_markers.add_vertex(*x, *y, path_cmd_line_to);
+                    }
+                    else
+                    {
+                        if(is_stop(cmd))
+                        {
+                            m_last_cmd = path_cmd_stop;
+                            break;
+                        }
+                        if(is_end_poly(cmd))
+                        {
+                            m_generator.add_vertex(*x, *y, cmd);
+                            break;
+                        }
+                    }
+                }
+                m_generator.rewind(0);
+                m_status = generate;
+
+            case generate:
+                cmd = m_generator.vertex(x, y);
+                if(is_stop(cmd))
+                {
+                    m_status = accumulate;
+                    break;
+                }
+                done = true;
+                break;
+            }
+        }
+        return cmd;
+    }
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_adaptor_vpgen.h
+++ b/dep/agg/include/agg_conv_adaptor_vpgen.h
@@ -0,0 +1,159 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_ADAPTOR_VPGEN_INCLUDED
+#define AGG_CONV_ADAPTOR_VPGEN_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //======================================================conv_adaptor_vpgen
+    template<class VertexSource, class VPGen> class conv_adaptor_vpgen
+    {
+    public:
+        explicit conv_adaptor_vpgen(VertexSource& source) : m_source(&source) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        VPGen& vpgen() { return m_vpgen; }
+        const VPGen& vpgen() const { return m_vpgen; }
+
+        void rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_adaptor_vpgen(const conv_adaptor_vpgen<VertexSource, VPGen>&);
+        const conv_adaptor_vpgen<VertexSource, VPGen>& 
+            operator = (const conv_adaptor_vpgen<VertexSource, VPGen>&);
+
+        VertexSource* m_source;
+        VPGen         m_vpgen;
+        double        m_start_x;
+        double        m_start_y;
+        unsigned      m_poly_flags;
+        int           m_vertices;
+    };
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class VPGen>
+    void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id) 
+    { 
+        m_source->rewind(path_id);
+        m_vpgen.reset();
+        m_start_x    = 0;
+        m_start_y    = 0;
+        m_poly_flags = 0;
+        m_vertices   = 0;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class VPGen>
+    unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_stop;
+        for(;;)
+        {
+            cmd = m_vpgen.vertex(x, y);
+            if(!is_stop(cmd)) break;
+
+            if(m_poly_flags && !m_vpgen.auto_unclose())
+            {
+                *x = 0.0;
+                *y = 0.0;
+                cmd = m_poly_flags;
+                m_poly_flags = 0;
+                break;
+            }
+
+            if(m_vertices < 0)
+            {
+                if(m_vertices < -1) 
+                {
+                    m_vertices = 0;
+                    return path_cmd_stop;
+                }
+                m_vpgen.move_to(m_start_x, m_start_y);
+                m_vertices = 1;
+                continue;
+            }
+
+            double tx, ty;
+            cmd = m_source->vertex(&tx, &ty);
+            if(is_vertex(cmd))
+            {
+                if(is_move_to(cmd)) 
+                {
+                    if(m_vpgen.auto_close() && m_vertices > 2)
+                    {
+                        m_vpgen.line_to(m_start_x, m_start_y);
+                        m_poly_flags = path_cmd_end_poly | path_flags_close;
+                        m_start_x    = tx;
+                        m_start_y    = ty;
+                        m_vertices   = -1;
+                        continue;
+                    }
+                    m_vpgen.move_to(tx, ty);
+                    m_start_x  = tx;
+                    m_start_y  = ty;
+                    m_vertices = 1;
+                }
+                else 
+                {
+                    m_vpgen.line_to(tx, ty);
+                    ++m_vertices;
+                }
+            }
+            else
+            {
+                if(is_end_poly(cmd))
+                {
+                    m_poly_flags = cmd;
+                    if(is_closed(cmd) || m_vpgen.auto_close())
+                    {
+                        if(m_vpgen.auto_close()) m_poly_flags |= path_flags_close;
+                        if(m_vertices > 2)
+                        {
+                            m_vpgen.line_to(m_start_x, m_start_y);
+                        }
+                        m_vertices = 0;
+                    }
+                }
+                else
+                {
+                    // path_cmd_stop
+                    if(m_vpgen.auto_close() && m_vertices > 2)
+                    {
+                        m_vpgen.line_to(m_start_x, m_start_y);
+                        m_poly_flags = path_cmd_end_poly | path_flags_close;
+                        m_vertices   = -2;
+                        continue;
+                    }
+                    break;
+                }
+            }
+        }
+        return cmd;
+    }
+
+
+}
+
+
+#endif
+
--- a/dep/agg/include/agg_conv_bspline.h
+++ b/dep/agg/include/agg_conv_bspline.h
@@ -0,0 +1,48 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_BSPLINE_INCLUDED
+#define AGG_CONV_BSPLINE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_bspline.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+
+namespace agg
+{
+
+    //---------------------------------------------------------conv_bspline
+    template<class VertexSource> 
+    struct conv_bspline : public conv_adaptor_vcgen<VertexSource, vcgen_bspline>
+    {
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_bspline> base_type;
+
+        conv_bspline(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs) {}
+
+        void   interpolation_step(double v) { base_type::generator().interpolation_step(v); }
+        double interpolation_step() const { return base_type::generator().interpolation_step(); }
+
+    private:
+        conv_bspline(const conv_bspline<VertexSource>&);
+        const conv_bspline<VertexSource>& 
+            operator = (const conv_bspline<VertexSource>&);
+    };
+
+}
+
+
+#endif
+
--- a/dep/agg/include/agg_conv_clip_polygon.h
+++ b/dep/agg/include/agg_conv_clip_polygon.h
@@ -0,0 +1,63 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Polygon clipping converter
+// There an optimized Liang-Basky algorithm is used. 
+// The algorithm doesn't optimize the degenerate edges, i.e. it will never
+// break a closed polygon into two or more ones, instead, there will be 
+// degenerate edges coinciding with the respective clipping boundaries.
+// This is a sub-optimal solution, because that optimization would require 
+// extra, rather expensive math while the rasterizer tolerates it quite well, 
+// without any considerable overhead.
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_CLIP_POLYGON_INCLUDED
+#define AGG_CONV_CLIP_POLYGON_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_conv_adaptor_vpgen.h"
+#include "agg_vpgen_clip_polygon.h"
+
+namespace agg
+{
+
+    //=======================================================conv_clip_polygon
+    template<class VertexSource> 
+    struct conv_clip_polygon : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>
+    {
+        typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon> base_type;
+
+        conv_clip_polygon(VertexSource& vs) : 
+            conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs) {}
+
+        void clip_box(double x1, double y1, double x2, double y2)
+        {
+            base_type::vpgen().clip_box(x1, y1, x2, y2);
+        }
+
+        double x1() const { return base_type::vpgen().x1(); }
+        double y1() const { return base_type::vpgen().y1(); }
+        double x2() const { return base_type::vpgen().x2(); }
+        double y2() const { return base_type::vpgen().y2(); }
+
+    private:
+        conv_clip_polygon(const conv_clip_polygon<VertexSource>&);
+        const conv_clip_polygon<VertexSource>& 
+            operator = (const conv_clip_polygon<VertexSource>&);
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_clip_polyline.h
+++ b/dep/agg/include/agg_conv_clip_polyline.h
@@ -0,0 +1,63 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// polyline clipping converter
+// There an optimized Liang-Basky algorithm is used. 
+// The algorithm doesn't optimize the degenerate edges, i.e. it will never
+// break a closed polyline into two or more ones, instead, there will be 
+// degenerate edges coinciding with the respective clipping boundaries.
+// This is a sub-optimal solution, because that optimization would require 
+// extra, rather expensive math while the rasterizer tolerates it quite well, 
+// without any considerable overhead.
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_CLIP_polyline_INCLUDED
+#define AGG_CONV_CLIP_polyline_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_conv_adaptor_vpgen.h"
+#include "agg_vpgen_clip_polyline.h"
+
+namespace agg
+{
+
+    //=======================================================conv_clip_polyline
+    template<class VertexSource> 
+    struct conv_clip_polyline : public conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>
+    {
+        typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline> base_type;
+
+        conv_clip_polyline(VertexSource& vs) : 
+            conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs) {}
+
+        void clip_box(double x1, double y1, double x2, double y2)
+        {
+            base_type::vpgen().clip_box(x1, y1, x2, y2);
+        }
+
+        double x1() const { return base_type::vpgen().x1(); }
+        double y1() const { return base_type::vpgen().y1(); }
+        double x2() const { return base_type::vpgen().x2(); }
+        double y2() const { return base_type::vpgen().y2(); }
+
+    private:
+        conv_clip_polyline(const conv_clip_polyline<VertexSource>&);
+        const conv_clip_polyline<VertexSource>& 
+            operator = (const conv_clip_polyline<VertexSource>&);
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_close_polygon.h
+++ b/dep/agg/include/agg_conv_close_polygon.h
@@ -0,0 +1,125 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_CLOSE_POLYGON_INCLUDED
+#define AGG_CONV_CLOSE_POLYGON_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //======================================================conv_close_polygon
+    template<class VertexSource> class conv_close_polygon
+    {
+    public:
+        explicit conv_close_polygon(VertexSource& vs) : m_source(&vs) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_close_polygon(const conv_close_polygon<VertexSource>&);
+        const conv_close_polygon<VertexSource>& 
+            operator = (const conv_close_polygon<VertexSource>&);
+
+        VertexSource* m_source;
+        unsigned      m_cmd[2];
+        double        m_x[2];
+        double        m_y[2];
+        unsigned      m_vertex;
+        bool          m_line_to;
+    };
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource> 
+    void conv_close_polygon<VertexSource>::rewind(unsigned path_id)
+    {
+        m_source->rewind(path_id);
+        m_vertex = 2;
+        m_line_to = false;
+    }
+
+
+    
+    //------------------------------------------------------------------------
+    template<class VertexSource> 
+    unsigned conv_close_polygon<VertexSource>::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_stop;
+        for(;;)
+        {
+            if(m_vertex < 2)
+            {
+                *x = m_x[m_vertex];
+                *y = m_y[m_vertex];
+                cmd = m_cmd[m_vertex];
+                ++m_vertex;
+                break;
+            }
+
+            cmd = m_source->vertex(x, y);
+
+            if(is_end_poly(cmd))
+            {
+                cmd |= path_flags_close;
+                break;
+            }
+
+            if(is_stop(cmd))
+            {
+                if(m_line_to)
+                {
+                    m_cmd[0]  = path_cmd_end_poly | path_flags_close;
+                    m_cmd[1]  = path_cmd_stop;
+                    m_vertex  = 0;
+                    m_line_to = false;
+                    continue;
+                }
+                break;
+            }
+
+            if(is_move_to(cmd))
+            {
+                if(m_line_to)
+                {
+                    m_x[0]    = 0.0;
+                    m_y[0]    = 0.0;
+                    m_cmd[0]  = path_cmd_end_poly | path_flags_close;
+                    m_x[1]    = *x;
+                    m_y[1]    = *y;
+                    m_cmd[1]  = cmd;
+                    m_vertex  = 0;
+                    m_line_to = false;
+                    continue;
+                }
+                break;
+            }
+
+            if(is_vertex(cmd))
+            {
+                m_line_to = true;
+                break;
+            }
+        }
+        return cmd;
+    }
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_concat.h
+++ b/dep/agg/include/agg_conv_concat.h
@@ -0,0 +1,73 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_CONCAT_INCLUDED
+#define AGG_CONV_CONCAT_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    //=============================================================conv_concat
+    // Concatenation of two paths. Usually used to combine lines or curves 
+    // with markers such as arrowheads
+    template<class VS1, class VS2> class conv_concat
+    {
+    public:
+        conv_concat(VS1& source1, VS2& source2) :
+            m_source1(&source1), m_source2(&source2), m_status(2) {}
+        void attach1(VS1& source) { m_source1 = &source; }
+        void attach2(VS2& source) { m_source2 = &source; }
+
+
+        void rewind(unsigned path_id)
+        { 
+            m_source1->rewind(path_id);
+            m_source2->rewind(0);
+            m_status = 0;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            unsigned cmd;
+            if(m_status == 0)
+            {
+                cmd = m_source1->vertex(x, y);
+                if(!is_stop(cmd)) return cmd;
+                m_status = 1;
+            }
+            if(m_status == 1)
+            {
+                cmd = m_source2->vertex(x, y);
+                if(!is_stop(cmd)) return cmd;
+                m_status = 2;
+            }
+            return path_cmd_stop;
+        }
+
+    private:
+        conv_concat(const conv_concat<VS1, VS2>&);
+        const conv_concat<VS1, VS2>& 
+            operator = (const conv_concat<VS1, VS2>&);
+
+        VS1* m_source1;
+        VS2* m_source2;
+        int  m_status;
+
+    };
+}
+
+
+#endif
--- a/dep/agg/include/agg_conv_contour.h
+++ b/dep/agg/include/agg_conv_contour.h
@@ -0,0 +1,65 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_stroke
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_CONTOUR_INCLUDED
+#define AGG_CONV_CONTOUR_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_contour.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------conv_contour
+    template<class VertexSource> 
+    struct conv_contour : public conv_adaptor_vcgen<VertexSource, vcgen_contour>
+    {
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_contour> base_type;
+
+        conv_contour(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
+        {
+        }
+
+        void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
+        void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
+        void width(double w) { base_type::generator().width(w); }
+        void miter_limit(double ml) { base_type::generator().miter_limit(ml); }
+        void miter_limit_theta(double t) { base_type::generator().miter_limit_theta(t); }
+        void inner_miter_limit(double ml) { base_type::generator().inner_miter_limit(ml); }
+        void approximation_scale(double as) { base_type::generator().approximation_scale(as); }
+        void auto_detect_orientation(bool v) { base_type::generator().auto_detect_orientation(v); }
+
+        line_join_e line_join() const { return base_type::generator().line_join(); }
+        inner_join_e inner_join() const { return base_type::generator().inner_join(); }
+        double width() const { return base_type::generator().width(); }
+        double miter_limit() const { return base_type::generator().miter_limit(); }
+        double inner_miter_limit() const { return base_type::generator().inner_miter_limit(); }
+        double approximation_scale() const { return base_type::generator().approximation_scale(); }
+        bool auto_detect_orientation() const { return base_type::generator().auto_detect_orientation(); }
+
+    private:
+        conv_contour(const conv_contour<VertexSource>&);
+        const conv_contour<VertexSource>& 
+            operator = (const conv_contour<VertexSource>&);
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_curve.h
+++ b/dep/agg/include/agg_conv_curve.h
@@ -0,0 +1,201 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// classes conv_curve
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_CURVE_INCLUDED
+#define AGG_CONV_CURVE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_curves.h"
+
+namespace agg
+{
+
+
+    //---------------------------------------------------------------conv_curve
+    // Curve converter class. Any path storage can have Bezier curves defined 
+    // by their control points. There're two types of curves supported: curve3 
+    // and curve4. Curve3 is a conic Bezier curve with 2 endpoints and 1 control
+    // point. Curve4 has 2 control points (4 points in total) and can be used
+    // to interpolate more complicated curves. Curve4, unlike curve3 can be used 
+    // to approximate arcs, both circular and elliptical. Curves are approximated 
+    // with straight lines and one of the approaches is just to store the whole 
+    // sequence of vertices that approximate our curve. It takes additional 
+    // memory, and at the same time the consecutive vertices can be calculated 
+    // on demand. 
+    //
+    // Initially, path storages are not suppose to keep all the vertices of the
+    // curves (although, nothing prevents us from doing so). Instead, path_storage
+    // keeps only vertices, needed to calculate a curve on demand. Those vertices
+    // are marked with special commands. So, if the path_storage contains curves 
+    // (which are not real curves yet), and we render this storage directly, 
+    // all we will see is only 2 or 3 straight line segments (for curve3 and 
+    // curve4 respectively). If we need to see real curves drawn we need to 
+    // include this class into the conversion pipeline. 
+    //
+    // Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4 
+    // and converts these vertices into a move_to/line_to sequence. 
+    //-----------------------------------------------------------------------
+    template<class VertexSource, 
+             class Curve3=curve3, 
+             class Curve4=curve4> class conv_curve
+    {
+    public:
+        typedef Curve3 curve3_type;
+        typedef Curve4 curve4_type;
+        typedef conv_curve<VertexSource, Curve3, Curve4> self_type;
+
+        explicit conv_curve(VertexSource& source) :
+          m_source(&source), m_last_x(0.0), m_last_y(0.0) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void approximation_method(curve_approximation_method_e v) 
+        { 
+            m_curve3.approximation_method(v);
+            m_curve4.approximation_method(v);
+        }
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return m_curve4.approximation_method();
+        }
+
+        void approximation_scale(double s) 
+        { 
+            m_curve3.approximation_scale(s); 
+            m_curve4.approximation_scale(s); 
+        }
+
+        double approximation_scale() const 
+        { 
+            return m_curve4.approximation_scale();  
+        }
+
+        void angle_tolerance(double v) 
+        { 
+            m_curve3.angle_tolerance(v); 
+            m_curve4.angle_tolerance(v); 
+        }
+
+        double angle_tolerance() const 
+        { 
+            return m_curve4.angle_tolerance();  
+        }
+
+        void cusp_limit(double v) 
+        { 
+            m_curve3.cusp_limit(v); 
+            m_curve4.cusp_limit(v); 
+        }
+
+        double cusp_limit() const 
+        { 
+            return m_curve4.cusp_limit();  
+        }
+
+        void     rewind(unsigned path_id); 
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_curve(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        VertexSource* m_source;
+        double        m_last_x;
+        double        m_last_y;
+        curve3_type   m_curve3;
+        curve4_type   m_curve4;
+    };
+
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class Curve3, class Curve4>
+    void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
+    {
+        m_source->rewind(path_id);
+        m_last_x = 0.0;
+        m_last_y = 0.0;
+        m_curve3.reset();
+        m_curve4.reset();
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VertexSource, class Curve3, class Curve4>
+    unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
+    {
+        if(!is_stop(m_curve3.vertex(x, y)))
+        {
+            m_last_x = *x;
+            m_last_y = *y;
+            return path_cmd_line_to;
+        }
+
+        if(!is_stop(m_curve4.vertex(x, y)))
+        {
+            m_last_x = *x;
+            m_last_y = *y;
+            return path_cmd_line_to;
+        }
+
+        double ct2_x = 0;
+        double ct2_y = 0;
+        double end_x = 0;
+        double end_y = 0;
+
+        unsigned cmd = m_source->vertex(x, y);
+        switch(cmd)
+        {
+        case path_cmd_curve3:
+            m_source->vertex(&end_x, &end_y);
+
+            m_curve3.init(m_last_x, m_last_y, 
+                          *x,       *y, 
+                          end_x,     end_y);
+
+            m_curve3.vertex(x, y);    // First call returns path_cmd_move_to
+            m_curve3.vertex(x, y);    // This is the first vertex of the curve
+            cmd = path_cmd_line_to;
+            break;
+
+        case path_cmd_curve4:
+            m_source->vertex(&ct2_x, &ct2_y);
+            m_source->vertex(&end_x, &end_y);
+
+            m_curve4.init(m_last_x, m_last_y, 
+                          *x,       *y, 
+                          ct2_x,    ct2_y, 
+                          end_x,    end_y);
+
+            m_curve4.vertex(x, y);    // First call returns path_cmd_move_to
+            m_curve4.vertex(x, y);    // This is the first vertex of the curve
+            cmd = path_cmd_line_to;
+            break;
+        }
+        m_last_x = *x;
+        m_last_y = *y;
+        return cmd;
+    }
+
+
+}
+
+
+
+#endif
--- a/dep/agg/include/agg_conv_dash.h
+++ b/dep/agg/include/agg_conv_dash.h
@@ -0,0 +1,68 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_dash
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_DASH_INCLUDED
+#define AGG_CONV_DASH_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_dash.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+namespace agg
+{
+
+    //---------------------------------------------------------------conv_dash
+    template<class VertexSource, class Markers=null_markers> 
+    struct conv_dash : public conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>
+    {
+        typedef Markers marker_type;
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers> base_type;
+
+        conv_dash(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
+        {
+        }
+
+        void remove_all_dashes() 
+        { 
+            base_type::generator().remove_all_dashes(); 
+        }
+
+        void add_dash(double dash_len, double gap_len) 
+        { 
+            base_type::generator().add_dash(dash_len, gap_len); 
+        }
+
+        void dash_start(double ds) 
+        { 
+            base_type::generator().dash_start(ds); 
+        }
+
+        void shorten(double s) { base_type::generator().shorten(s); }
+        double shorten() const { return base_type::generator().shorten(); }
+
+    private:
+        conv_dash(const conv_dash<VertexSource, Markers>&);
+        const conv_dash<VertexSource, Markers>& 
+            operator = (const conv_dash<VertexSource, Markers>&);
+    };
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_gpc.h
+++ b/dep/agg/include/agg_conv_gpc.h
@@ -0,0 +1,432 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// General Polygon Clipper based on the GPC library by Alan Murta 
+// Union, Intersection, XOR, A-B, B-A
+// Contact the author if you intend to use it in commercial applications!
+// http://www.cs.man.ac.uk/aig/staff/alan/software/
+// Alan Murta (email: gpc@cs.man.ac.uk)
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_GPC_INCLUDED
+#define AGG_CONV_GPC_INCLUDED
+
+#include <cstring>
+#include "agg_basics.h"
+#include "agg_array.h"
+
+extern "C" 
+{ 
+#include "gpc.h" 
+}
+
+namespace agg
+{
+    enum gpc_op_e
+    {
+        gpc_or,
+        gpc_and,
+        gpc_xor,
+        gpc_a_minus_b,
+        gpc_b_minus_a
+    };
+
+
+    //================================================================conv_gpc
+    template<class VSA, class VSB> class conv_gpc
+    {
+        enum status
+        {
+            status_move_to,
+            status_line_to,
+            status_stop
+        };
+
+        struct contour_header_type
+        {
+            int num_vertices;
+            int hole_flag;
+            gpc_vertex* vertices;
+        };
+
+        typedef pod_bvector<gpc_vertex, 8>          vertex_array_type;
+        typedef pod_bvector<contour_header_type, 6> contour_header_array_type;
+
+
+    public:
+        typedef VSA source_a_type;
+        typedef VSB source_b_type;
+        typedef conv_gpc<source_a_type, source_b_type> self_type;
+
+        ~conv_gpc()
+        {
+            free_gpc_data();
+        }
+
+        conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or) :
+            m_src_a(&a),
+            m_src_b(&b),
+            m_status(status_move_to),
+            m_vertex(-1),
+            m_contour(-1),
+            m_operation(op)
+        {
+            std::memset(&m_poly_a, 0, sizeof(m_poly_a));
+            std::memset(&m_poly_b, 0, sizeof(m_poly_b));
+            std::memset(&m_result, 0, sizeof(m_result));
+        }
+
+        void attach1(VSA& source) { m_src_a = &source; }
+        void attach2(VSB& source) { m_src_b = &source; }
+
+        void operation(gpc_op_e v) { m_operation = v; }
+
+        // Vertex Source Interface
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_gpc(const conv_gpc<VSA, VSB>&);
+        const conv_gpc<VSA, VSB>& operator = (const conv_gpc<VSA, VSB>&);
+
+        //--------------------------------------------------------------------
+        void free_polygon(gpc_polygon& p);
+        void free_result();
+        void free_gpc_data();
+        void start_contour();
+        void add_vertex(double x, double y);
+        void end_contour(unsigned orientation);
+        void make_polygon(gpc_polygon& p);
+        void start_extracting();
+        bool next_contour();
+        bool next_vertex(double* x, double* y);
+
+
+        //--------------------------------------------------------------------
+        template<class VS> void add(VS& src, gpc_polygon& p)
+        {
+            unsigned cmd;
+            double x, y;
+            double start_x = 0.0;
+            double start_y = 0.0;
+            bool line_to = false;
+            unsigned orientation = 0;
+
+            m_contour_accumulator.remove_all();
+
+            while(!is_stop(cmd = src.vertex(&x, &y)))
+            {
+                if(is_vertex(cmd))
+                {
+                    if(is_move_to(cmd))
+                    {
+                        if(line_to)
+                        {
+                            end_contour(orientation);
+                            orientation = 0;
+                        }
+                        start_contour();
+                        start_x = x;
+                        start_y = y;
+                    }
+                    add_vertex(x, y);
+                    line_to = true;
+                }
+                else
+                {
+                    if(is_end_poly(cmd))
+                    {
+                        orientation = get_orientation(cmd);
+                        if(line_to && is_closed(cmd))
+                        {
+                            add_vertex(start_x, start_y);
+                        }
+                    }
+                }
+            }
+            if(line_to)
+            {
+                end_contour(orientation);
+            }
+            make_polygon(p);
+        }
+
+
+    private:
+        //--------------------------------------------------------------------
+        source_a_type*             m_src_a;
+        source_b_type*             m_src_b;
+        status                     m_status;
+        int                        m_vertex;
+        int                        m_contour;
+        gpc_op_e                   m_operation;
+        vertex_array_type          m_vertex_accumulator;
+        contour_header_array_type  m_contour_accumulator;
+        gpc_polygon                m_poly_a;
+        gpc_polygon                m_poly_b;
+        gpc_polygon                m_result;
+    };
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::free_polygon(gpc_polygon& p)
+    {
+        int i;
+        for(i = 0; i < p.num_contours; i++)
+        {
+            pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex, 
+                                                  p.contour[i].num_vertices);
+        }
+        pod_allocator<gpc_vertex_list>::deallocate(p.contour, p.num_contours);
+        std::memset(&p, 0, sizeof(gpc_polygon));
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::free_result()
+    {
+        if(m_result.contour)
+        {
+            gpc_free_polygon(&m_result);
+        }
+        std::memset(&m_result, 0, sizeof(m_result));
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::free_gpc_data()
+    {
+        free_polygon(m_poly_a);
+        free_polygon(m_poly_b);
+        free_result();
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::start_contour()
+    {
+        contour_header_type h;
+        std::memset(&h, 0, sizeof(h));
+        m_contour_accumulator.add(h);
+        m_vertex_accumulator.remove_all();
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    inline void conv_gpc<VSA, VSB>::add_vertex(double x, double y)
+    {
+        gpc_vertex v;
+        v.x = x;
+        v.y = y;
+        m_vertex_accumulator.add(v);
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::end_contour(unsigned /*orientation*/)
+    {
+        if(m_contour_accumulator.size())
+        {
+            if(m_vertex_accumulator.size() > 2)
+            {
+                contour_header_type& h = 
+                    m_contour_accumulator[m_contour_accumulator.size() - 1];
+
+                h.num_vertices = m_vertex_accumulator.size();
+                h.hole_flag = 0;
+
+                // TO DO: Clarify the "holes"
+                //if(is_cw(orientation)) h.hole_flag = 1;
+
+                h.vertices = pod_allocator<gpc_vertex>::allocate(h.num_vertices);
+                gpc_vertex* d = h.vertices;
+                int i;
+                for(i = 0; i < h.num_vertices; i++)
+                {
+                    const gpc_vertex& s = m_vertex_accumulator[i];
+                    d->x = s.x;
+                    d->y = s.y;
+                    ++d;
+                }
+            }
+            else
+            {
+                m_vertex_accumulator.remove_last();
+            }
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::make_polygon(gpc_polygon& p)
+    {
+        free_polygon(p);
+        if(m_contour_accumulator.size())
+        {
+            p.num_contours = m_contour_accumulator.size();
+
+            p.hole = 0;
+            p.contour = pod_allocator<gpc_vertex_list>::allocate(p.num_contours);
+
+            int i;
+            gpc_vertex_list* pv = p.contour;
+            for(i = 0; i < p.num_contours; i++)
+            {
+                const contour_header_type& h = m_contour_accumulator[i];
+                pv->num_vertices = h.num_vertices;
+                pv->vertex = h.vertices;
+                ++pv;
+            }
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::start_extracting()
+    {
+        m_status = status_move_to;
+        m_contour = -1;
+        m_vertex = -1;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    bool conv_gpc<VSA, VSB>::next_contour()
+    {
+        if(++m_contour < m_result.num_contours)
+        {
+            m_vertex = -1;
+            return true;
+        }
+        return false;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    inline bool conv_gpc<VSA, VSB>::next_vertex(double* x, double* y)
+    {
+        const gpc_vertex_list& vlist = m_result.contour[m_contour];
+        if(++m_vertex < vlist.num_vertices)
+        {
+            const gpc_vertex& v = vlist.vertex[m_vertex];
+            *x = v.x;
+            *y = v.y;
+            return true;
+        }
+        return false;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    void conv_gpc<VSA, VSB>::rewind(unsigned path_id)
+    {
+        free_result();
+        m_src_a->rewind(path_id);
+        m_src_b->rewind(path_id);
+        add(*m_src_a, m_poly_a);
+        add(*m_src_b, m_poly_b);
+        switch(m_operation)
+        {
+           case gpc_or:
+                gpc_polygon_clip(GPC_UNION,
+                                 &m_poly_a,
+                                 &m_poly_b,
+                                 &m_result);
+               break;
+
+           case gpc_and:
+                gpc_polygon_clip(GPC_INT,
+                                 &m_poly_a,
+                                 &m_poly_b,
+                                 &m_result);
+               break;
+
+           case gpc_xor:
+                gpc_polygon_clip(GPC_XOR,
+                                 &m_poly_a,
+                                 &m_poly_b,
+                                 &m_result);
+               break;
+
+           case gpc_a_minus_b:
+                gpc_polygon_clip(GPC_DIFF,
+                                 &m_poly_a,
+                                 &m_poly_b,
+                                 &m_result);
+               break;
+
+           case gpc_b_minus_a:
+                gpc_polygon_clip(GPC_DIFF,
+                                 &m_poly_b,
+                                 &m_poly_a,
+                                 &m_result);
+               break;
+        }
+        start_extracting();
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class VSA, class VSB> 
+    unsigned conv_gpc<VSA, VSB>::vertex(double* x, double* y)
+    {
+        if(m_status == status_move_to)
+        {
+            if(next_contour()) 
+            {
+                if(next_vertex(x, y))
+                {
+                    m_status = status_line_to;
+                    return path_cmd_move_to;
+                }
+                m_status = status_stop;
+                return path_cmd_end_poly | path_flags_close;
+            }
+        }
+        else
+        {
+            if(next_vertex(x, y))
+            {
+                return path_cmd_line_to;
+            }
+            else
+            {
+                m_status = status_move_to;
+            }
+            return path_cmd_end_poly | path_flags_close;
+        }
+        return path_cmd_stop;
+    }
+
+   
+}
+
+
+#endif
--- a/dep/agg/include/agg_conv_marker.h
+++ b/dep/agg/include/agg_conv_marker.h
@@ -0,0 +1,149 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_marker
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_MARKER_INCLUDED
+#define AGG_CONV_MARKER_INCLUDED
+
+#include <cmath>
+#include "agg_basics.h"
+#include "agg_trans_affine.h"
+
+namespace agg
+{
+    //-------------------------------------------------------------conv_marker
+    template<class MarkerLocator, class MarkerShapes>
+    class conv_marker
+    {
+    public:
+        conv_marker(MarkerLocator& ml, MarkerShapes& ms);
+
+        trans_affine& transform() { return m_transform; }
+        const trans_affine& transform() const { return m_transform; }
+
+        void rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        conv_marker(const conv_marker<MarkerLocator, MarkerShapes>&);
+        const conv_marker<MarkerLocator, MarkerShapes>& 
+            operator = (const conv_marker<MarkerLocator, MarkerShapes>&);
+
+        enum status_e 
+        {
+            initial,
+            markers,
+            polygon,
+            stop
+        };
+
+        MarkerLocator* m_marker_locator;
+        MarkerShapes*  m_marker_shapes;
+        trans_affine   m_transform;
+        trans_affine   m_mtx;
+        status_e       m_status;
+        unsigned       m_marker;
+        unsigned       m_num_markers;
+    };
+
+
+    //------------------------------------------------------------------------
+    template<class MarkerLocator, class MarkerShapes> 
+    conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms) :
+        m_marker_locator(&ml),
+        m_marker_shapes(&ms),
+        m_status(initial),
+        m_marker(0),
+        m_num_markers(1)
+    {
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class MarkerLocator, class MarkerShapes> 
+    void conv_marker<MarkerLocator, MarkerShapes>::rewind(unsigned)
+    {
+        m_status = initial;
+        m_marker = 0;
+        m_num_markers = 1;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class MarkerLocator, class MarkerShapes> 
+    unsigned conv_marker<MarkerLocator, MarkerShapes>::vertex(double* x, double* y)
+    {
+        unsigned cmd = path_cmd_move_to;
+        double x1, y1, x2, y2;
+
+        while(!is_stop(cmd))
+        {
+            switch(m_status)
+            {
+            case initial:
+                if(m_num_markers == 0)
+                {
+                   cmd = path_cmd_stop;
+                   break;
+                }
+                m_marker_locator->rewind(m_marker);
+                ++m_marker;
+                m_num_markers = 0;
+                m_status = markers;
+
+            case markers:
+                if(is_stop(m_marker_locator->vertex(&x1, &y1)))
+                {
+                    m_status = initial;
+                    break;
+                }
+                if(is_stop(m_marker_locator->vertex(&x2, &y2)))
+                {
+                    m_status = initial;
+                    break;
+                }
+                ++m_num_markers;
+                m_mtx = m_transform;
+                m_mtx *= trans_affine_rotation(std::atan2(y2 - y1, x2 - x1));
+                m_mtx *= trans_affine_translation(x1, y1);
+                m_marker_shapes->rewind(m_marker - 1);
+                m_status = polygon;
+
+            case polygon:
+                cmd = m_marker_shapes->vertex(x, y);
+                if(is_stop(cmd))
+                {
+                    cmd = path_cmd_move_to;
+                    m_status = markers;
+                    break;
+                }
+                m_mtx.transform(x, y);
+                return cmd;
+
+            case stop:
+                cmd = path_cmd_stop;
+                break;
+            }
+        }
+        return cmd;
+    }
+
+}
+
+
+#endif
+
--- a/dep/agg/include/agg_conv_marker_adaptor.h
+++ b/dep/agg/include/agg_conv_marker_adaptor.h
@@ -0,0 +1,51 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_MARKER_ADAPTOR_INCLUDED
+#define AGG_CONV_MARKER_ADAPTOR_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_conv_adaptor_vcgen.h"
+#include "agg_vcgen_vertex_sequence.h"
+
+namespace agg
+{
+
+    //=====================================================conv_marker_adaptor
+    template<class VertexSource, class Markers=null_markers>
+    struct conv_marker_adaptor : 
+    public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
+    {
+        typedef Markers marker_type;
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers> base_type;
+
+        conv_marker_adaptor(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
+        {
+        }
+
+        void shorten(double s) { base_type::generator().shorten(s); }
+        double shorten() const { return base_type::generator().shorten(); }
+
+    private:
+        conv_marker_adaptor(const conv_marker_adaptor<VertexSource, Markers>&);
+        const conv_marker_adaptor<VertexSource, Markers>& 
+            operator = (const conv_marker_adaptor<VertexSource, Markers>&);
+    };
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_segmentator.h
+++ b/dep/agg/include/agg_conv_segmentator.h
@@ -0,0 +1,48 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_SEGMENTATOR_INCLUDED
+#define AGG_CONV_SEGMENTATOR_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_conv_adaptor_vpgen.h"
+#include "agg_vpgen_segmentator.h"
+
+namespace agg
+{
+
+    //========================================================conv_segmentator
+    template<class VertexSource> 
+    struct conv_segmentator : public conv_adaptor_vpgen<VertexSource, vpgen_segmentator>
+    {
+        typedef conv_adaptor_vpgen<VertexSource, vpgen_segmentator> base_type;
+
+        conv_segmentator(VertexSource& vs) : 
+            conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs) {}
+
+        void approximation_scale(double s) { base_type::vpgen().approximation_scale(s);        }
+        double approximation_scale() const { return base_type::vpgen().approximation_scale();  }
+
+    private:
+        conv_segmentator(const conv_segmentator<VertexSource>&);
+        const conv_segmentator<VertexSource>& 
+            operator = (const conv_segmentator<VertexSource>&);
+    };
+
+
+}
+
+#endif
+
--- a/dep/agg/include/agg_conv_shorten_path.h
+++ b/dep/agg/include/agg_conv_shorten_path.h
@@ -0,0 +1,50 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_SHORTEN_PATH_INCLUDED
+#define AGG_CONV_SHORTEN_PATH_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_conv_adaptor_vcgen.h"
+#include "agg_vcgen_vertex_sequence.h"
+
+namespace agg
+{
+
+    //=======================================================conv_shorten_path
+    template<class VertexSource>  class conv_shorten_path : 
+    public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
+    {
+    public:
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence> base_type;
+
+        conv_shorten_path(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
+        {
+        }
+
+        void shorten(double s) { base_type::generator().shorten(s); }
+        double shorten() const { return base_type::generator().shorten(); }
+
+    private:
+        conv_shorten_path(const conv_shorten_path<VertexSource>&);
+        const conv_shorten_path<VertexSource>& 
+            operator = (const conv_shorten_path<VertexSource>&);
+    };
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_smooth_poly1.h
+++ b/dep/agg/include/agg_conv_smooth_poly1.h
@@ -0,0 +1,80 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Smooth polygon generator
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_SMOOTH_POLY1_INCLUDED
+#define AGG_CONV_SMOOTH_POLY1_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_smooth_poly1.h"
+#include "agg_conv_adaptor_vcgen.h"
+#include "agg_conv_curve.h"
+
+
+namespace agg
+{
+
+    //-------------------------------------------------------conv_smooth_poly1
+    template<class VertexSource> 
+    struct conv_smooth_poly1 : 
+    public conv_adaptor_vcgen<VertexSource, vcgen_smooth_poly1>
+    {
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_smooth_poly1> base_type;
+
+        conv_smooth_poly1(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_smooth_poly1>(vs)
+        {
+        }
+
+        void   smooth_value(double v) { base_type::generator().smooth_value(v); }
+        double smooth_value() const { return base_type::generator().smooth_value(); }
+
+    private:
+        conv_smooth_poly1(const conv_smooth_poly1<VertexSource>&);
+        const conv_smooth_poly1<VertexSource>& 
+            operator = (const conv_smooth_poly1<VertexSource>&);
+    };
+
+
+
+    //-------------------------------------------------conv_smooth_poly1_curve
+    template<class VertexSource> 
+    struct conv_smooth_poly1_curve : 
+    public conv_curve<conv_smooth_poly1<VertexSource> >
+    {
+        conv_smooth_poly1_curve(VertexSource& vs) :
+            conv_curve<conv_smooth_poly1<VertexSource> >(m_smooth),
+            m_smooth(vs)
+        {
+        }
+
+        void   smooth_value(double v) { m_smooth.generator().smooth_value(v); }
+        double smooth_value() const { return m_smooth.generator().smooth_value(); }
+
+    private:
+        conv_smooth_poly1_curve(const conv_smooth_poly1_curve<VertexSource>&);
+        const conv_smooth_poly1_curve<VertexSource>& 
+            operator = (const conv_smooth_poly1_curve<VertexSource>&);
+
+        conv_smooth_poly1<VertexSource> m_smooth;
+    };
+
+}
+
+
+#endif
+
--- a/dep/agg/include/agg_conv_stroke.h
+++ b/dep/agg/include/agg_conv_stroke.h
@@ -0,0 +1,73 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// conv_stroke
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_STROKE_INCLUDED
+#define AGG_CONV_STROKE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_vcgen_stroke.h"
+#include "agg_conv_adaptor_vcgen.h"
+
+namespace agg
+{
+
+    //-------------------------------------------------------------conv_stroke
+    template<class VertexSource, class Markers=null_markers> 
+    struct conv_stroke : 
+    public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
+    {
+        typedef Markers marker_type;
+        typedef conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers> base_type;
+
+        conv_stroke(VertexSource& vs) : 
+            conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
+        {
+        }
+
+        void line_cap(line_cap_e lc)     { base_type::generator().line_cap(lc);  }
+        void line_join(line_join_e lj)   { base_type::generator().line_join(lj); }
+        void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
+
+        line_cap_e   line_cap()   const { return base_type::generator().line_cap();  }
+        line_join_e  line_join()  const { return base_type::generator().line_join(); }
+        inner_join_e inner_join() const { return base_type::generator().inner_join(); }
+
+        void width(double w) { base_type::generator().width(w); }
+        void miter_limit(double ml) { base_type::generator().miter_limit(ml); }
+        void miter_limit_theta(double t) { base_type::generator().miter_limit_theta(t); }
+        void inner_miter_limit(double ml) { base_type::generator().inner_miter_limit(ml); }
+        void approximation_scale(double as) { base_type::generator().approximation_scale(as); }
+
+        double width() const { return base_type::generator().width(); }
+        double miter_limit() const { return base_type::generator().miter_limit(); }
+        double inner_miter_limit() const { return base_type::generator().inner_miter_limit(); }
+        double approximation_scale() const { return base_type::generator().approximation_scale(); }
+
+        void shorten(double s) { base_type::generator().shorten(s); }
+        double shorten() const { return base_type::generator().shorten(); }
+
+    private:
+       conv_stroke(const conv_stroke<VertexSource, Markers>&);
+       const conv_stroke<VertexSource, Markers>& 
+           operator = (const conv_stroke<VertexSource, Markers>&);
+
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_transform.h
+++ b/dep/agg/include/agg_conv_transform.h
@@ -0,0 +1,68 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class conv_transform
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_TRANSFORM_INCLUDED
+#define AGG_CONV_TRANSFORM_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_trans_affine.h"
+
+namespace agg
+{
+
+    //----------------------------------------------------------conv_transform
+    template<class VertexSource, class Transformer=trans_affine> class conv_transform
+    {
+    public:
+        conv_transform(VertexSource& source, Transformer& tr) :
+            m_source(&source), m_trans(&tr) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void rewind(unsigned path_id) 
+        { 
+            m_source->rewind(path_id); 
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            unsigned cmd = m_source->vertex(x, y);
+            if(is_vertex(cmd))
+            {
+                m_trans->transform(x, y);
+            }
+            return cmd;
+        }
+
+        void transformer(Transformer& tr)
+        {
+            m_trans = &tr;
+        }
+
+    private:
+        conv_transform(const conv_transform<VertexSource>&);
+        const conv_transform<VertexSource>& 
+            operator = (const conv_transform<VertexSource>&);
+
+        VertexSource*      m_source;
+        Transformer* m_trans;
+    };
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_conv_unclose_polygon.h
+++ b/dep/agg/include/agg_conv_unclose_polygon.h
@@ -0,0 +1,52 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CONV_UNCLOSE_POLYGON_INCLUDED
+#define AGG_CONV_UNCLOSE_POLYGON_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    //====================================================conv_unclose_polygon
+    template<class VertexSource> class conv_unclose_polygon
+    {
+    public:
+        explicit conv_unclose_polygon(VertexSource& vs) : m_source(&vs) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void rewind(unsigned path_id)
+        {
+            m_source->rewind(path_id);
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            unsigned cmd = m_source->vertex(x, y);
+            if(is_end_poly(cmd)) cmd &= ~path_flags_close;
+            return cmd;
+        }
+
+    private:
+        conv_unclose_polygon(const conv_unclose_polygon<VertexSource>&);
+        const conv_unclose_polygon<VertexSource>& 
+            operator = (const conv_unclose_polygon<VertexSource>&);
+
+        VertexSource* m_source;
+    };
+
+}
+
+#endif
--- a/dep/agg/include/agg_curves.h
+++ b/dep/agg/include/agg_curves.h
@@ -0,0 +1,693 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+// Copyright (C) 2005 Tony Juricic (tonygeek@yahoo.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_CURVES_INCLUDED
+#define AGG_CURVES_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    // See Implementation agg_curves.cpp
+
+    //--------------------------------------------curve_approximation_method_e
+    enum curve_approximation_method_e
+    {
+        curve_inc,
+        curve_div
+    };
+    
+    //--------------------------------------------------------------curve3_inc
+    class curve3_inc
+    {
+    public:
+        curve3_inc() :
+          m_num_steps(0), m_step(0), m_scale(1.0) { }
+
+        curve3_inc(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3) :
+            m_num_steps(0), m_step(0), m_scale(1.0) 
+        { 
+            init(x1, y1, x2, y2, x3, y3);
+        }
+
+        void reset() { m_num_steps = 0; m_step = -1; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3);
+
+        void approximation_method(curve_approximation_method_e) {}
+        curve_approximation_method_e approximation_method() const { return curve_inc; }
+
+        void approximation_scale(double s);
+        double approximation_scale() const;
+
+        void angle_tolerance(double) {}
+        double angle_tolerance() const { return 0.0; }
+
+        void cusp_limit(double) {}
+        double cusp_limit() const { return 0.0; }
+
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        int      m_num_steps;
+        int      m_step;
+        double   m_scale;
+        double   m_start_x; 
+        double   m_start_y;
+        double   m_end_x; 
+        double   m_end_y;
+        double   m_fx; 
+        double   m_fy;
+        double   m_dfx; 
+        double   m_dfy;
+        double   m_ddfx; 
+        double   m_ddfy;
+        double   m_saved_fx; 
+        double   m_saved_fy;
+        double   m_saved_dfx; 
+        double   m_saved_dfy;
+    };
+
+
+
+
+
+    //-------------------------------------------------------------curve3_div
+    class curve3_div
+    {
+    public:
+        curve3_div() : 
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_count(0)
+        {}
+
+        curve3_div(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3) :
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_count(0)
+        { 
+            init(x1, y1, x2, y2, x3, y3);
+        }
+
+        void reset() { m_points.remove_all(); m_count = 0; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3);
+
+        void approximation_method(curve_approximation_method_e) {}
+        curve_approximation_method_e approximation_method() const { return curve_div; }
+
+        void approximation_scale(double s) { m_approximation_scale = s; }
+        double approximation_scale() const { return m_approximation_scale;  }
+
+        void angle_tolerance(double a) { m_angle_tolerance = a; }
+        double angle_tolerance() const { return m_angle_tolerance;  }
+
+        void cusp_limit(double) {}
+        double cusp_limit() const { return 0.0; }
+
+        void rewind(unsigned)
+        {
+            m_count = 0;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_count >= m_points.size()) return path_cmd_stop;
+            const point_d& p = m_points[m_count++];
+            *x = p.x;
+            *y = p.y;
+            return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
+        }
+
+    private:
+        void bezier(double x1, double y1, 
+                    double x2, double y2, 
+                    double x3, double y3);
+        void recursive_bezier(double x1, double y1, 
+                              double x2, double y2, 
+                              double x3, double y3,
+                              unsigned level);
+
+        double               m_approximation_scale;
+        double               m_distance_tolerance_square;
+        double               m_angle_tolerance;
+        unsigned             m_count;
+        pod_bvector<point_d> m_points;
+    };
+
+
+
+
+
+
+
+    //-------------------------------------------------------------curve4_points
+    struct curve4_points
+    {
+        double cp[8];
+        curve4_points() {}
+        curve4_points(double x1, double y1,
+                      double x2, double y2,
+                      double x3, double y3,
+                      double x4, double y4)
+        {
+            cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
+            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
+        }
+        void init(double x1, double y1,
+                  double x2, double y2,
+                  double x3, double y3,
+                  double x4, double y4)
+        {
+            cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
+            cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
+        }
+        double  operator [] (unsigned i) const { return cp[i]; }
+        double& operator [] (unsigned i)       { return cp[i]; }
+    };
+
+
+
+    //-------------------------------------------------------------curve4_inc
+    class curve4_inc
+    {
+    public:
+        curve4_inc() :
+            m_num_steps(0), m_step(0), m_scale(1.0) { }
+
+        curve4_inc(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3,
+                   double x4, double y4) :
+            m_num_steps(0), m_step(0), m_scale(1.0) 
+        { 
+            init(x1, y1, x2, y2, x3, y3, x4, y4);
+        }
+
+        curve4_inc(const curve4_points& cp) :
+            m_num_steps(0), m_step(0), m_scale(1.0) 
+        { 
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void reset() { m_num_steps = 0; m_step = -1; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3,
+                  double x4, double y4);
+
+        void init(const curve4_points& cp)
+        {
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void approximation_method(curve_approximation_method_e) {}
+        curve_approximation_method_e approximation_method() const { return curve_inc; }
+
+        void approximation_scale(double s);
+        double approximation_scale() const;
+
+        void angle_tolerance(double) {}
+        double angle_tolerance() const { return 0.0; }
+
+        void cusp_limit(double) {}
+        double cusp_limit() const { return 0.0; }
+
+        void     rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        int      m_num_steps;
+        int      m_step;
+        double   m_scale;
+        double   m_start_x; 
+        double   m_start_y;
+        double   m_end_x; 
+        double   m_end_y;
+        double   m_fx; 
+        double   m_fy;
+        double   m_dfx; 
+        double   m_dfy;
+        double   m_ddfx; 
+        double   m_ddfy;
+        double   m_dddfx; 
+        double   m_dddfy;
+        double   m_saved_fx; 
+        double   m_saved_fy;
+        double   m_saved_dfx; 
+        double   m_saved_dfy;
+        double   m_saved_ddfx; 
+        double   m_saved_ddfy;
+    };
+
+
+
+    //-------------------------------------------------------catrom_to_bezier
+    inline curve4_points catrom_to_bezier(double x1, double y1, 
+                                          double x2, double y2, 
+                                          double x3, double y3,
+                                          double x4, double y4)
+    {
+        // Trans. matrix Catmull-Rom to Bezier
+        //
+        //  0       1       0       0
+        //  -1/6    1       1/6     0
+        //  0       1/6     1       -1/6
+        //  0       0       1       0
+        //
+        return curve4_points(
+            x2,
+            y2,
+            (-x1 + 6*x2 + x3) / 6,
+            (-y1 + 6*y2 + y3) / 6,
+            ( x2 + 6*x3 - x4) / 6,
+            ( y2 + 6*y3 - y4) / 6,
+            x3,
+            y3);
+    }
+
+
+    //-----------------------------------------------------------------------
+    inline curve4_points
+    catrom_to_bezier(const curve4_points& cp)
+    {
+        return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+                                cp[4], cp[5], cp[6], cp[7]);
+    }
+
+
+
+    //-----------------------------------------------------ubspline_to_bezier
+    inline curve4_points ubspline_to_bezier(double x1, double y1, 
+                                            double x2, double y2, 
+                                            double x3, double y3,
+                                            double x4, double y4)
+    {
+        // Trans. matrix Uniform BSpline to Bezier
+        //
+        //  1/6     4/6     1/6     0
+        //  0       4/6     2/6     0
+        //  0       2/6     4/6     0
+        //  0       1/6     4/6     1/6
+        //
+        return curve4_points(
+            (x1 + 4*x2 + x3) / 6,
+            (y1 + 4*y2 + y3) / 6,
+            (4*x2 + 2*x3) / 6,
+            (4*y2 + 2*y3) / 6,
+            (2*x2 + 4*x3) / 6,
+            (2*y2 + 4*y3) / 6,
+            (x2 + 4*x3 + x4) / 6,
+            (y2 + 4*y3 + y4) / 6);
+    }
+
+
+    //-----------------------------------------------------------------------
+    inline curve4_points 
+    ubspline_to_bezier(const curve4_points& cp)
+    {
+        return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+                                  cp[4], cp[5], cp[6], cp[7]);
+    }
+
+
+
+
+    //------------------------------------------------------hermite_to_bezier
+    inline curve4_points hermite_to_bezier(double x1, double y1, 
+                                           double x2, double y2, 
+                                           double x3, double y3,
+                                           double x4, double y4)
+    {
+        // Trans. matrix Hermite to Bezier
+        //
+        //  1       0       0       0
+        //  1       0       1/3     0
+        //  0       1       0       -1/3
+        //  0       1       0       0
+        //
+        return curve4_points(
+            x1,
+            y1,
+            (3*x1 + x3) / 3,
+            (3*y1 + y3) / 3,
+            (3*x2 - x4) / 3,
+            (3*y2 - y4) / 3,
+            x2,
+            y2);
+    }
+
+
+
+    //-----------------------------------------------------------------------
+    inline curve4_points 
+    hermite_to_bezier(const curve4_points& cp)
+    {
+        return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], 
+                                 cp[4], cp[5], cp[6], cp[7]);
+    }
+
+
+    //-------------------------------------------------------------curve4_div
+    class curve4_div
+    {
+    public:
+        curve4_div() : 
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_cusp_limit(0.0),
+            m_count(0)
+        {}
+
+        curve4_div(double x1, double y1, 
+                   double x2, double y2, 
+                   double x3, double y3,
+                   double x4, double y4) :
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_cusp_limit(0.0),
+            m_count(0)
+        { 
+            init(x1, y1, x2, y2, x3, y3, x4, y4);
+        }
+
+        curve4_div(const curve4_points& cp) :
+            m_approximation_scale(1.0),
+            m_angle_tolerance(0.0),
+            m_count(0)
+        { 
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void reset() { m_points.remove_all(); m_count = 0; }
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3,
+                  double x4, double y4);
+
+        void init(const curve4_points& cp)
+        {
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void approximation_method(curve_approximation_method_e) {}
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return curve_div; 
+        }
+
+        void approximation_scale(double s) { m_approximation_scale = s; }
+        double approximation_scale() const { return m_approximation_scale;  }
+
+        void angle_tolerance(double a) { m_angle_tolerance = a; }
+        double angle_tolerance() const { return m_angle_tolerance;  }
+
+        void cusp_limit(double v) 
+        { 
+            m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; 
+        }
+
+        double cusp_limit() const 
+        { 
+            return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; 
+        }
+
+        void rewind(unsigned)
+        {
+            m_count = 0;
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_count >= m_points.size()) return path_cmd_stop;
+            const point_d& p = m_points[m_count++];
+            *x = p.x;
+            *y = p.y;
+            return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to;
+        }
+
+    private:
+        void bezier(double x1, double y1, 
+                    double x2, double y2, 
+                    double x3, double y3, 
+                    double x4, double y4);
+
+        void recursive_bezier(double x1, double y1, 
+                              double x2, double y2, 
+                              double x3, double y3, 
+                              double x4, double y4,
+                              unsigned level);
+
+        double               m_approximation_scale;
+        double               m_distance_tolerance_square;
+        double               m_angle_tolerance;
+        double               m_cusp_limit;
+        unsigned             m_count;
+        pod_bvector<point_d> m_points;
+    };
+
+
+    //-----------------------------------------------------------------curve3
+    class curve3
+    {
+    public:
+        curve3() : m_approximation_method(curve_div) {}
+        curve3(double x1, double y1, 
+               double x2, double y2, 
+               double x3, double y3) :
+            m_approximation_method(curve_div)
+        { 
+            init(x1, y1, x2, y2, x3, y3);
+        }
+
+        void reset() 
+        { 
+            m_curve_inc.reset();
+            m_curve_div.reset();
+        }
+
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.init(x1, y1, x2, y2, x3, y3);
+            }
+            else
+            {
+                m_curve_div.init(x1, y1, x2, y2, x3, y3);
+            }
+        }
+
+        void approximation_method(curve_approximation_method_e v) 
+        { 
+            m_approximation_method = v; 
+        }
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return m_approximation_method; 
+        }
+
+        void approximation_scale(double s) 
+        { 
+            m_curve_inc.approximation_scale(s);
+            m_curve_div.approximation_scale(s);
+        }
+
+        double approximation_scale() const 
+        { 
+            return m_curve_inc.approximation_scale(); 
+        }
+
+        void angle_tolerance(double a) 
+        { 
+            m_curve_div.angle_tolerance(a); 
+        }
+
+        double angle_tolerance() const 
+        { 
+            return m_curve_div.angle_tolerance(); 
+        }
+
+        void cusp_limit(double v) 
+        { 
+            m_curve_div.cusp_limit(v); 
+        }
+
+        double cusp_limit() const 
+        { 
+            return m_curve_div.cusp_limit();  
+        }
+
+        void rewind(unsigned path_id)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.rewind(path_id);
+            }
+            else
+            {
+                m_curve_div.rewind(path_id);
+            }
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                return m_curve_inc.vertex(x, y);
+            }
+            return m_curve_div.vertex(x, y);
+        }
+
+    private:
+        curve3_inc m_curve_inc;
+        curve3_div m_curve_div;
+        curve_approximation_method_e m_approximation_method;
+    };
+
+
+
+
+
+    //-----------------------------------------------------------------curve4
+    class curve4
+    {
+    public:
+        curve4() : m_approximation_method(curve_div) {}
+        curve4(double x1, double y1, 
+               double x2, double y2, 
+               double x3, double y3,
+               double x4, double y4) : 
+            m_approximation_method(curve_div)
+        { 
+            init(x1, y1, x2, y2, x3, y3, x4, y4);
+        }
+
+        curve4(const curve4_points& cp) :
+            m_approximation_method(curve_div)
+        { 
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void reset() 
+        { 
+            m_curve_inc.reset();
+            m_curve_div.reset();
+        }
+
+        void init(double x1, double y1, 
+                  double x2, double y2, 
+                  double x3, double y3,
+                  double x4, double y4)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.init(x1, y1, x2, y2, x3, y3, x4, y4);
+            }
+            else
+            {
+                m_curve_div.init(x1, y1, x2, y2, x3, y3, x4, y4);
+            }
+        }
+
+        void init(const curve4_points& cp)
+        {
+            init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
+        }
+
+        void approximation_method(curve_approximation_method_e v) 
+        { 
+            m_approximation_method = v; 
+        }
+
+        curve_approximation_method_e approximation_method() const 
+        { 
+            return m_approximation_method; 
+        }
+
+        void approximation_scale(double s) 
+        { 
+            m_curve_inc.approximation_scale(s);
+            m_curve_div.approximation_scale(s);
+        }
+        double approximation_scale() const { return m_curve_inc.approximation_scale(); }
+
+        void angle_tolerance(double v) 
+        { 
+            m_curve_div.angle_tolerance(v); 
+        }
+
+        double angle_tolerance() const 
+        { 
+            return m_curve_div.angle_tolerance();  
+        }
+
+        void cusp_limit(double v) 
+        { 
+            m_curve_div.cusp_limit(v); 
+        }
+
+        double cusp_limit() const 
+        { 
+            return m_curve_div.cusp_limit();  
+        }
+
+        void rewind(unsigned path_id)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                m_curve_inc.rewind(path_id);
+            }
+            else
+            {
+                m_curve_div.rewind(path_id);
+            }
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_approximation_method == curve_inc) 
+            {
+                return m_curve_inc.vertex(x, y);
+            }
+            return m_curve_div.vertex(x, y);
+        }
+
+    private:
+        curve4_inc m_curve_inc;
+        curve4_div m_curve_div;
+        curve_approximation_method_e m_approximation_method;
+    };
+
+
+
+
+}
+
+#endif
--- a/dep/agg/include/agg_dda_line.h
+++ b/dep/agg/include/agg_dda_line.h
@@ -0,0 +1,290 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// classes dda_line_interpolator, dda2_line_interpolator
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_DDA_LINE_INCLUDED
+#define AGG_DDA_LINE_INCLUDED
+
+#include <cstdlib>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //===================================================dda_line_interpolator
+    template<int FractionShift, int YShift=0> class dda_line_interpolator
+    {
+    public:
+        //--------------------------------------------------------------------
+        dda_line_interpolator() {}
+
+        //--------------------------------------------------------------------
+        dda_line_interpolator(int y1, int y2, unsigned count) :
+            m_y(y1),
+            m_inc(((y2 - y1) << FractionShift) / int(count)),
+            m_dy(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void operator ++ ()
+        {
+            m_dy += m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        void operator -- ()
+        {
+            m_dy -= m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        void operator += (unsigned n)
+        {
+            m_dy += m_inc * n;
+        }
+
+        //--------------------------------------------------------------------
+        void operator -= (unsigned n)
+        {
+            m_dy -= m_inc * n;
+        }
+
+
+        //--------------------------------------------------------------------
+        int y()  const { return m_y + (m_dy >> (FractionShift-YShift)); }
+        int dy() const { return m_dy; }
+
+
+    private:
+        int m_y;
+        int m_inc;
+        int m_dy;
+    };
+
+
+
+
+
+    //=================================================dda2_line_interpolator
+    class dda2_line_interpolator
+    {
+    public:
+        typedef int save_data_type;
+        enum save_size_e { save_size = 2 };
+
+        //--------------------------------------------------------------------
+        dda2_line_interpolator() {}
+
+        //-------------------------------------------- Forward-adjusted line
+        dda2_line_interpolator(int y1, int y2, int count) :
+            m_cnt(count <= 0 ? 1 : count),
+            m_lft((y2 - y1) / m_cnt),
+            m_rem((y2 - y1) % m_cnt),
+            m_mod(m_rem),
+            m_y(y1)
+        {
+            if(m_mod <= 0)
+            {
+                m_mod += count;
+                m_rem += count;
+                m_lft--;
+            }
+            m_mod -= count;
+        }
+
+        //-------------------------------------------- Backward-adjusted line
+        dda2_line_interpolator(int y1, int y2, int count, int) :
+            m_cnt(count <= 0 ? 1 : count),
+            m_lft((y2 - y1) / m_cnt),
+            m_rem((y2 - y1) % m_cnt),
+            m_mod(m_rem),
+            m_y(y1)
+        {
+            if(m_mod <= 0)
+            {
+                m_mod += count;
+                m_rem += count;
+                m_lft--;
+            }
+        }
+
+        //-------------------------------------------- Backward-adjusted line
+        dda2_line_interpolator(int y, int count) :
+            m_cnt(count <= 0 ? 1 : count),
+            m_lft(y / m_cnt),
+            m_rem(y % m_cnt),
+            m_mod(m_rem),
+            m_y(0)
+        {
+            if(m_mod <= 0)
+            {
+                m_mod += count;
+                m_rem += count;
+                m_lft--;
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void save(save_data_type* data) const
+        {
+            data[0] = m_mod;
+            data[1] = m_y;
+        }
+
+        //--------------------------------------------------------------------
+        void load(const save_data_type* data)
+        {
+            m_mod = data[0];
+            m_y   = data[1];
+        }
+
+        //--------------------------------------------------------------------
+        void operator++()
+        {
+            m_mod += m_rem;
+            m_y += m_lft;
+            if(m_mod > 0)
+            {
+                m_mod -= m_cnt;
+                m_y++;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void operator--()
+        {
+            if(m_mod <= m_rem)
+            {
+                m_mod += m_cnt;
+                m_y--;
+            }
+            m_mod -= m_rem;
+            m_y -= m_lft;
+        }
+
+        //--------------------------------------------------------------------
+        void adjust_forward()
+        {
+            m_mod -= m_cnt;
+        }
+
+        //--------------------------------------------------------------------
+        void adjust_backward()
+        {
+            m_mod += m_cnt;
+        }
+
+        //--------------------------------------------------------------------
+        int mod() const { return m_mod; }
+        int rem() const { return m_rem; }
+        int lft() const { return m_lft; }
+
+        //--------------------------------------------------------------------
+        int y() const { return m_y; }
+
+    private:
+        int m_cnt;
+        int m_lft;
+        int m_rem;
+        int m_mod;
+        int m_y;
+    };
+
+
+
+
+
+
+
+    //---------------------------------------------line_bresenham_interpolator
+    class line_bresenham_interpolator
+    {
+    public:
+        enum subpixel_scale_e
+        {
+            subpixel_shift = 8,
+            subpixel_scale = 1 << subpixel_shift,
+            subpixel_mask  = subpixel_scale - 1
+        };
+
+        //--------------------------------------------------------------------
+        static int line_lr(int v) { return v >> subpixel_shift; }
+
+        //--------------------------------------------------------------------
+        line_bresenham_interpolator(int x1, int y1, int x2, int y2) :
+            m_x1_lr(line_lr(x1)),
+            m_y1_lr(line_lr(y1)),
+            m_x2_lr(line_lr(x2)),
+            m_y2_lr(line_lr(y2)),
+            m_ver(std::abs(m_x2_lr - m_x1_lr) < std::abs(m_y2_lr - m_y1_lr)),
+            m_len(m_ver ? std::abs(m_y2_lr - m_y1_lr) : 
+                          std::abs(m_x2_lr - m_x1_lr)),
+            m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
+            m_interpolator(m_ver ? x1 : y1, 
+                           m_ver ? x2 : y2, 
+                           m_len)
+        {
+        }
+    
+        //--------------------------------------------------------------------
+        bool     is_ver() const { return m_ver; }
+        unsigned len()    const { return m_len; }
+        int      inc()    const { return m_inc; }
+
+        //--------------------------------------------------------------------
+        void hstep()
+        {
+            ++m_interpolator;
+            m_x1_lr += m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        void vstep()
+        {
+            ++m_interpolator;
+            m_y1_lr += m_inc;
+        }
+
+        //--------------------------------------------------------------------
+        int x1() const { return m_x1_lr; }
+        int y1() const { return m_y1_lr; }
+        int x2() const { return line_lr(m_interpolator.y()); }
+        int y2() const { return line_lr(m_interpolator.y()); }
+        int x2_hr() const { return m_interpolator.y(); }
+        int y2_hr() const { return m_interpolator.y(); }
+
+    private:
+        int                    m_x1_lr;
+        int                    m_y1_lr;
+        int                    m_x2_lr;
+        int                    m_y2_lr;
+        bool                   m_ver;
+        unsigned               m_len;
+        int                    m_inc;
+        dda2_line_interpolator m_interpolator;
+
+    };
+
+
+}
+
+
+
+#endif
--- a/dep/agg/include/agg_ellipse.h
+++ b/dep/agg/include/agg_ellipse.h
@@ -0,0 +1,123 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class ellipse
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_ELLIPSE_INCLUDED
+#define AGG_ELLIPSE_INCLUDED
+
+#include "agg_basics.h"
+#include <cmath>
+
+namespace agg
+{
+
+    //----------------------------------------------------------------ellipse
+    class ellipse
+    {
+    public:
+        ellipse() : 
+            m_x(0.0), m_y(0.0), m_rx(1.0), m_ry(1.0), m_scale(1.0), 
+            m_num(4), m_step(0), m_cw(false) {}
+
+        ellipse(double x, double y, double rx, double ry, 
+                unsigned num_steps=0, bool cw=false) :
+            m_x(x), m_y(y), m_rx(rx), m_ry(ry), m_scale(1.0), 
+            m_num(num_steps), m_step(0), m_cw(cw) 
+        {
+            if(m_num == 0) calc_num_steps();
+        }
+
+        void init(double x, double y, double rx, double ry, 
+                  unsigned num_steps=0, bool cw=false);
+
+        void approximation_scale(double scale);
+        void rewind(unsigned path_id);
+        unsigned vertex(double* x, double* y);
+
+    private:
+        void calc_num_steps();
+
+        double m_x;
+        double m_y;
+        double m_rx;
+        double m_ry;
+        double m_scale;
+        unsigned m_num;
+        unsigned m_step;
+        bool m_cw;
+    };
+
+    //------------------------------------------------------------------------
+    inline void ellipse::init(double x, double y, double rx, double ry, 
+                              unsigned num_steps, bool cw)
+    {
+        m_x = x;
+        m_y = y;
+        m_rx = rx;
+        m_ry = ry;
+        m_num = num_steps;
+        m_step = 0;
+        m_cw = cw;
+        if(m_num == 0) calc_num_steps();
+    }
+
+    //------------------------------------------------------------------------
+    inline void ellipse::approximation_scale(double scale)
+    {   
+        m_scale = scale;
+        calc_num_steps();
+    }
+
+    //------------------------------------------------------------------------
+    inline void ellipse::calc_num_steps()
+    {
+        double ra = (std::fabs(m_rx) + std::fabs(m_ry)) / 2;
+        double da = std::acos(ra / (ra + 0.125 / m_scale)) * 2;
+        m_num = uround(2*pi / da);
+    }
+
+    //------------------------------------------------------------------------
+    inline void ellipse::rewind(unsigned)
+    {
+        m_step = 0;
+    }
+
+    //------------------------------------------------------------------------
+    inline unsigned ellipse::vertex(double* x, double* y)
+    {
+        if(m_step == m_num) 
+        {
+            ++m_step;
+            return path_cmd_end_poly | path_flags_close | path_flags_ccw;
+        }
+        if(m_step > m_num) return path_cmd_stop;
+        double angle = double(m_step) / double(m_num) * 2.0 * pi;
+        if(m_cw) angle = 2.0 * pi - angle;
+        *x = m_x + std::cos(angle) * m_rx;
+        *y = m_y + std::sin(angle) * m_ry;
+        m_step++;
+        return ((m_step == 1) ? path_cmd_move_to : path_cmd_line_to);
+    }
+
+}
+
+
+
+#endif
+
+
--- a/dep/agg/include/agg_ellipse_bresenham.h
+++ b/dep/agg/include/agg_ellipse_bresenham.h
@@ -0,0 +1,113 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Simple Bresenham interpolator for ellipsees
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_ELLIPSE_BRESENHAM_INCLUDED
+#define AGG_ELLIPSE_BRESENHAM_INCLUDED
+
+
+#include "agg_basics.h"
+
+
+namespace agg
+{
+
+    //------------------------------------------ellipse_bresenham_interpolator
+    class ellipse_bresenham_interpolator
+    {
+    public:
+        ellipse_bresenham_interpolator(int rx, int ry) :
+            m_rx2(rx * rx),
+            m_ry2(ry * ry),
+            m_two_rx2(m_rx2 << 1),
+            m_two_ry2(m_ry2 << 1),
+            m_dx(0),
+            m_dy(0),
+            m_inc_x(0),
+            m_inc_y(-ry * m_two_rx2),
+            m_cur_f(0)
+        {}
+        
+        int dx() const { return m_dx; }
+        int dy() const { return m_dy; }
+
+        void operator++ ()
+        {
+            int  mx, my, mxy, min_m;
+            int  fx, fy, fxy;
+
+            mx = fx = m_cur_f + m_inc_x + m_ry2;
+            if(mx < 0) mx = -mx;
+
+            my = fy = m_cur_f + m_inc_y + m_rx2;
+            if(my < 0) my = -my;
+
+            mxy = fxy = m_cur_f + m_inc_x + m_ry2 + m_inc_y + m_rx2;
+            if(mxy < 0) mxy = -mxy;
+
+            min_m = mx; 
+            bool flag = true;
+
+            if(min_m > my)  
+            { 
+                min_m = my; 
+                flag = false; 
+            }
+
+            m_dx = m_dy = 0;
+
+            if(min_m > mxy) 
+            { 
+                m_inc_x += m_two_ry2;
+                m_inc_y += m_two_rx2;
+                m_cur_f = fxy;
+                m_dx = 1; 
+                m_dy = 1;
+                return;
+            }
+
+            if(flag) 
+            {
+                m_inc_x += m_two_ry2;
+                m_cur_f = fx;
+                m_dx = 1;
+                return;
+            }
+
+            m_inc_y += m_two_rx2;
+            m_cur_f = fy;
+            m_dy = 1;
+        }
+
+    private:
+        int m_rx2;
+        int m_ry2;
+        int m_two_rx2;
+        int m_two_ry2;
+        int m_dx;
+        int m_dy;
+        int m_inc_x;
+        int m_inc_y;
+        int m_cur_f;
+
+    };
+
+}
+
+#endif
+
--- a/dep/agg/include/agg_embedded_raster_fonts.h
+++ b/dep/agg/include/agg_embedded_raster_fonts.h
@@ -0,0 +1,59 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_EMBEDDED_RASTER_FONTS_INCLUDED
+#define AGG_EMBEDDED_RASTER_FONTS_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    extern const int8u gse4x6[];
+    extern const int8u gse4x8[];
+    extern const int8u gse5x7[];
+    extern const int8u gse5x9[];
+    extern const int8u gse6x12[];
+    extern const int8u gse6x9[];
+    extern const int8u gse7x11[];
+    extern const int8u gse7x11_bold[];
+    extern const int8u gse7x15[];
+    extern const int8u gse7x15_bold[];
+    extern const int8u gse8x16[];
+    extern const int8u gse8x16_bold[];
+    extern const int8u mcs11_prop[];
+    extern const int8u mcs11_prop_condensed[];
+    extern const int8u mcs12_prop[];
+    extern const int8u mcs13_prop[];
+    extern const int8u mcs5x10_mono[];
+    extern const int8u mcs5x11_mono[];
+    extern const int8u mcs6x10_mono[];
+    extern const int8u mcs6x11_mono[];
+    extern const int8u mcs7x12_mono_high[];
+    extern const int8u mcs7x12_mono_low[];
+    extern const int8u verdana12[];
+    extern const int8u verdana12_bold[];
+    extern const int8u verdana13[];
+    extern const int8u verdana13_bold[];
+    extern const int8u verdana14[];
+    extern const int8u verdana14_bold[];
+    extern const int8u verdana16[];
+    extern const int8u verdana16_bold[];
+    extern const int8u verdana17[];
+    extern const int8u verdana17_bold[];
+    extern const int8u verdana18[];
+    extern const int8u verdana18_bold[];
+}
+
+#endif
--- a/dep/agg/include/agg_font_cache_manager.h
+++ b/dep/agg/include/agg_font_cache_manager.h
@@ -0,0 +1,409 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_FONT_CACHE_MANAGER_INCLUDED
+#define AGG_FONT_CACHE_MANAGER_INCLUDED
+
+#include <cstring>
+#include "agg_array.h"
+
+namespace agg
+{
+
+    //---------------------------------------------------------glyph_data_type
+    enum glyph_data_type
+    {
+        glyph_data_invalid = 0,
+        glyph_data_mono    = 1,
+        glyph_data_gray8   = 2,
+        glyph_data_outline = 3
+    };
+
+
+    //-------------------------------------------------------------glyph_cache
+    struct glyph_cache
+    {
+        unsigned        glyph_index;
+        int8u*          data;
+        unsigned        data_size;
+        glyph_data_type data_type;
+        rect_i          bounds;
+        double          advance_x;
+        double          advance_y;
+    };
+
+
+    //--------------------------------------------------------------font_cache
+    class font_cache
+    {
+    public:
+        enum block_size_e { block_size = 16384-16 };
+
+        //--------------------------------------------------------------------
+        font_cache() : 
+            m_allocator(block_size),
+            m_font_signature(0)
+        {}
+
+        //--------------------------------------------------------------------
+        void signature(const char* font_signature)
+        {
+            m_font_signature = (char*)m_allocator.allocate(std::strlen(font_signature) + 1);
+            std::strcpy(m_font_signature, font_signature);
+            std::memset(m_glyphs, 0, sizeof(m_glyphs));
+        }
+
+        //--------------------------------------------------------------------
+        bool font_is(const char* font_signature) const
+        {
+            return std::strcmp(font_signature, m_font_signature) == 0;
+        }
+
+        //--------------------------------------------------------------------
+        const glyph_cache* find_glyph(unsigned glyph_code) const
+        {
+            unsigned msb = (glyph_code >> 8) & 0xFF;
+            if(m_glyphs[msb]) 
+            {
+                return m_glyphs[msb][glyph_code & 0xFF];
+            }
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        glyph_cache* cache_glyph(unsigned        glyph_code, 
+                                 unsigned        glyph_index,
+                                 unsigned        data_size,
+                                 glyph_data_type data_type,
+                                 const rect_i&   bounds,
+                                 double          advance_x,
+                                 double          advance_y)
+        {
+            unsigned msb = (glyph_code >> 8) & 0xFF;
+            if(m_glyphs[msb] == 0)
+            {
+                m_glyphs[msb] = 
+                    (glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256, 
+                                                        sizeof(glyph_cache*));
+                std::memset(m_glyphs[msb], 0, sizeof(glyph_cache*) * 256);
+            }
+
+            unsigned lsb = glyph_code & 0xFF;
+            if(m_glyphs[msb][lsb]) return 0; // Already exists, do not overwrite
+
+            glyph_cache* glyph = 
+                (glyph_cache*)m_allocator.allocate(sizeof(glyph_cache),
+                                                   sizeof(double));
+
+            glyph->glyph_index        = glyph_index;
+            glyph->data               = m_allocator.allocate(data_size);
+            glyph->data_size          = data_size;
+            glyph->data_type          = data_type;
+            glyph->bounds             = bounds;
+            glyph->advance_x          = advance_x;
+            glyph->advance_y          = advance_y;
+            return m_glyphs[msb][lsb] = glyph;
+        }
+
+    private:
+        block_allocator m_allocator;
+        glyph_cache**   m_glyphs[256];
+        char*           m_font_signature;
+    };
+
+
+
+
+
+
+    
+    //---------------------------------------------------------font_cache_pool
+    class font_cache_pool
+    {
+    public:
+        //--------------------------------------------------------------------
+        ~font_cache_pool()
+        {
+            unsigned i;
+            for(i = 0; i < m_num_fonts; ++i)
+            {
+                obj_allocator<font_cache>::deallocate(m_fonts[i]);
+            }
+            pod_allocator<font_cache*>::deallocate(m_fonts, m_max_fonts);
+        }
+
+        //--------------------------------------------------------------------
+        font_cache_pool(unsigned max_fonts=32) : 
+            m_fonts(pod_allocator<font_cache*>::allocate(max_fonts)),
+            m_max_fonts(max_fonts),
+            m_num_fonts(0),
+            m_cur_font(0)
+        {}
+
+
+        //--------------------------------------------------------------------
+        void font(const char* font_signature, bool reset_cache = false)
+        {
+            int idx = find_font(font_signature);
+            if(idx >= 0)
+            {
+                if(reset_cache)
+                {
+                    obj_allocator<font_cache>::deallocate(m_fonts[idx]);
+                    m_fonts[idx] = obj_allocator<font_cache>::allocate();
+                    m_fonts[idx]->signature(font_signature);
+                }
+                m_cur_font = m_fonts[idx];
+            }
+            else
+            {
+                if(m_num_fonts >= m_max_fonts)
+                {
+                    obj_allocator<font_cache>::deallocate(m_fonts[0]);
+                    std::memcpy(m_fonts, 
+                           m_fonts + 1, 
+                           (m_max_fonts - 1) * sizeof(font_cache*));
+                    m_num_fonts = m_max_fonts - 1;
+                }
+                m_fonts[m_num_fonts] = obj_allocator<font_cache>::allocate();
+                m_fonts[m_num_fonts]->signature(font_signature);
+                m_cur_font = m_fonts[m_num_fonts];
+                ++m_num_fonts;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        const font_cache* font() const
+        {
+            return m_cur_font;
+        }
+
+        //--------------------------------------------------------------------
+        const glyph_cache* find_glyph(unsigned glyph_code) const
+        {
+            if(m_cur_font) return m_cur_font->find_glyph(glyph_code);
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        glyph_cache* cache_glyph(unsigned        glyph_code, 
+                                 unsigned        glyph_index,
+                                 unsigned        data_size,
+                                 glyph_data_type data_type,
+                                 const rect_i&   bounds,
+                                 double          advance_x,
+                                 double          advance_y)
+        {
+            if(m_cur_font) 
+            {
+                return m_cur_font->cache_glyph(glyph_code,
+                                               glyph_index,
+                                               data_size,
+                                               data_type,
+                                               bounds,
+                                               advance_x,
+                                               advance_y);
+            }
+            return 0;
+        }
+
+
+        //--------------------------------------------------------------------
+        int find_font(const char* font_signature)
+        {
+            unsigned i;
+            for(i = 0; i < m_num_fonts; i++)
+            {
+                if(m_fonts[i]->font_is(font_signature)) return int(i);
+            }
+            return -1;
+        }
+
+    private:
+        font_cache** m_fonts;
+        unsigned     m_max_fonts;
+        unsigned     m_num_fonts;
+        font_cache*  m_cur_font;
+    };
+
+
+
+
+    //------------------------------------------------------------------------
+    enum glyph_rendering
+    {
+        glyph_ren_native_mono,
+        glyph_ren_native_gray8,
+        glyph_ren_outline,
+        glyph_ren_agg_mono,
+        glyph_ren_agg_gray8
+    };
+
+
+
+
+    //------------------------------------------------------font_cache_manager
+    template<class FontEngine> class font_cache_manager
+    {
+    public:
+        typedef FontEngine font_engine_type;
+        typedef font_cache_manager<FontEngine> self_type;
+        typedef typename font_engine_type::path_adaptor_type   path_adaptor_type;
+        typedef typename font_engine_type::gray8_adaptor_type  gray8_adaptor_type;
+        typedef typename gray8_adaptor_type::embedded_scanline gray8_scanline_type;
+        typedef typename font_engine_type::mono_adaptor_type   mono_adaptor_type;
+        typedef typename mono_adaptor_type::embedded_scanline  mono_scanline_type;
+
+        //--------------------------------------------------------------------
+        font_cache_manager(font_engine_type& engine, unsigned max_fonts=32) :
+            m_fonts(max_fonts),
+            m_engine(engine),
+            m_change_stamp(-1),
+            m_prev_glyph(0),
+            m_last_glyph(0)
+        {}
+
+        //--------------------------------------------------------------------
+        void reset_last_glyph()
+        {
+            m_prev_glyph = m_last_glyph = 0;
+        }
+
+        //--------------------------------------------------------------------
+        const glyph_cache* glyph(unsigned glyph_code)
+        {
+            synchronize();
+            const glyph_cache* gl = m_fonts.find_glyph(glyph_code);
+            if(gl) 
+            {
+                m_prev_glyph = m_last_glyph;
+                return m_last_glyph = gl;
+            }
+            else
+            {
+                if(m_engine.prepare_glyph(glyph_code))
+                {
+                    m_prev_glyph = m_last_glyph;
+                    m_last_glyph = m_fonts.cache_glyph(glyph_code, 
+                                                       m_engine.glyph_index(),
+                                                       m_engine.data_size(),
+                                                       m_engine.data_type(),
+                                                       m_engine.bounds(),
+                                                       m_engine.advance_x(),
+                                                       m_engine.advance_y());
+                    m_engine.write_glyph_to(m_last_glyph->data);
+                    return m_last_glyph;
+                }
+            }
+            return 0;
+        }
+
+        //--------------------------------------------------------------------
+        void init_embedded_adaptors(const glyph_cache* gl, 
+                                    double x, double y, 
+                                    double scale=1.0)
+        {
+            if(gl)
+            {
+                switch(gl->data_type)
+                {
+                default: return;
+                case glyph_data_mono:
+                    m_mono_adaptor.init(gl->data, gl->data_size, x, y);
+                    break;
+
+                case glyph_data_gray8:
+                    m_gray8_adaptor.init(gl->data, gl->data_size, x, y);
+                    break;
+
+                case glyph_data_outline:
+                    m_path_adaptor.init(gl->data, gl->data_size, x, y, scale);
+                    break;
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        path_adaptor_type&   path_adaptor()   { return m_path_adaptor;   }
+        gray8_adaptor_type&  gray8_adaptor()  { return m_gray8_adaptor;  }
+        gray8_scanline_type& gray8_scanline() { return m_gray8_scanline; }
+        mono_adaptor_type&   mono_adaptor()   { return m_mono_adaptor;   }
+        mono_scanline_type&  mono_scanline()  { return m_mono_scanline;  }
+
+        //--------------------------------------------------------------------
+        const glyph_cache* perv_glyph() const { return m_prev_glyph; }
+        const glyph_cache* last_glyph() const { return m_last_glyph; }
+
+        //--------------------------------------------------------------------
+        bool add_kerning(double* x, double* y)
+        {
+            if(m_prev_glyph && m_last_glyph)
+            {
+                return m_engine.add_kerning(m_prev_glyph->glyph_index, 
+                                            m_last_glyph->glyph_index,
+                                            x, y);
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        void precache(unsigned from, unsigned to)
+        {
+            for(; from <= to; ++from) glyph(from);
+        }
+
+        //--------------------------------------------------------------------
+        void reset_cache()
+        {
+            m_fonts.font(m_engine.font_signature(), true);
+            m_change_stamp = m_engine.change_stamp();
+            m_prev_glyph = m_last_glyph = 0;
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        font_cache_manager(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        //--------------------------------------------------------------------
+        void synchronize()
+        {
+            if(m_change_stamp != m_engine.change_stamp())
+            {
+                m_fonts.font(m_engine.font_signature());
+                m_change_stamp = m_engine.change_stamp();
+                m_prev_glyph = m_last_glyph = 0;
+            }
+        }
+
+        font_cache_pool     m_fonts;
+        font_engine_type&   m_engine;
+        int                 m_change_stamp;
+        double              m_dx;
+        double              m_dy;
+        const glyph_cache*  m_prev_glyph;
+        const glyph_cache*  m_last_glyph;
+        path_adaptor_type   m_path_adaptor;
+        gray8_adaptor_type  m_gray8_adaptor;
+        gray8_scanline_type m_gray8_scanline;
+        mono_adaptor_type   m_mono_adaptor;
+        mono_scanline_type  m_mono_scanline;
+    };
+
+}
+
+#endif
+
--- a/dep/agg/include/agg_font_cache_manager2.h
+++ b/dep/agg/include/agg_font_cache_manager2.h
@@ -0,0 +1,311 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_FONT_CACHE_MANAGER2_INCLUDED
+#define AGG_FONT_CACHE_MANAGER2_INCLUDED
+
+#include <cassert>
+#include <exception>
+#include <cstring>
+#include "agg_array.h"
+
+namespace agg {
+
+namespace fman {
+  //---------------------------------------------------------glyph_data_type
+  enum glyph_data_type
+  {
+    glyph_data_invalid = 0,
+    glyph_data_mono    = 1,
+    glyph_data_gray8   = 2,
+    glyph_data_outline = 3
+  };
+
+
+  //-------------------------------------------------------------cached_glyph
+  struct cached_glyph
+  {
+    void *			cached_font;
+    unsigned		glyph_code;
+    unsigned        glyph_index;
+    int8u*          data;
+    unsigned        data_size;
+    glyph_data_type data_type;
+    rect_i          bounds;
+    double          advance_x;
+    double          advance_y;
+  };
+
+
+  //--------------------------------------------------------------cached_glyphs
+  class cached_glyphs
+  {
+  public:
+    enum block_size_e { block_size = 16384-16 };
+
+    //--------------------------------------------------------------------
+    cached_glyphs()
+      : m_allocator(block_size)
+    { std::memset(m_glyphs, 0, sizeof(m_glyphs)); }
+
+    //--------------------------------------------------------------------
+    const cached_glyph* find_glyph(unsigned glyph_code) const
+    {
+      unsigned msb = (glyph_code >> 8) & 0xFF;
+      if(m_glyphs[msb])
+      {
+        return m_glyphs[msb][glyph_code & 0xFF];
+      }
+      return 0;
+    }
+
+    //--------------------------------------------------------------------
+    cached_glyph* cache_glyph(
+      void *			cached_font,
+      unsigned        glyph_code,
+      unsigned        glyph_index,
+      unsigned        data_size,
+      glyph_data_type data_type,
+      const rect_i&   bounds,
+      double          advance_x,
+      double          advance_y)
+    {
+      unsigned msb = (glyph_code >> 8) & 0xFF;
+      if(m_glyphs[msb] == 0)
+      {
+        m_glyphs[msb] =
+          (cached_glyph**)m_allocator.allocate(sizeof(cached_glyph*) * 256,
+          sizeof(cached_glyph*));
+        std::memset(m_glyphs[msb], 0, sizeof(cached_glyph*) * 256);
+      }
+
+      unsigned lsb = glyph_code & 0xFF;
+      if(m_glyphs[msb][lsb]) return 0; // Already exists, do not overwrite
+
+      cached_glyph* glyph =
+        (cached_glyph*)m_allocator.allocate(sizeof(cached_glyph),
+        sizeof(double));
+
+      glyph->cached_font		  = cached_font;
+      glyph->glyph_code		  = glyph_code;
+      glyph->glyph_index        = glyph_index;
+      glyph->data               = m_allocator.allocate(data_size);
+      glyph->data_size          = data_size;
+      glyph->data_type          = data_type;
+      glyph->bounds             = bounds;
+      glyph->advance_x          = advance_x;
+      glyph->advance_y          = advance_y;
+      return m_glyphs[msb][lsb] = glyph;
+    }
+
+  private:
+    block_allocator m_allocator;
+    cached_glyph**   m_glyphs[256];
+  };
+
+
+
+  //------------------------------------------------------------------------
+  enum glyph_rendering
+  {
+    glyph_ren_native_mono,
+    glyph_ren_native_gray8,
+    glyph_ren_outline,
+    glyph_ren_agg_mono,
+    glyph_ren_agg_gray8
+  };
+
+
+
+
+  //------------------------------------------------------font_cache_manager
+  template<class FontEngine> class font_cache_manager
+  {
+  public:
+    typedef FontEngine font_engine_type;
+    typedef font_cache_manager<FontEngine> self_type;
+    typedef typename font_engine_type::path_adaptor_type   path_adaptor_type;
+    typedef typename font_engine_type::gray8_adaptor_type  gray8_adaptor_type;
+    typedef typename gray8_adaptor_type::embedded_scanline gray8_scanline_type;
+    typedef typename font_engine_type::mono_adaptor_type   mono_adaptor_type;
+    typedef typename mono_adaptor_type::embedded_scanline  mono_scanline_type;
+
+    struct cached_font
+    {
+      cached_font(
+        font_engine_type& engine,
+        typename FontEngine::loaded_face *face,
+        double height,
+        double width,
+        bool hinting,
+        glyph_rendering rendering )
+        : m_engine( engine )
+        , m_face( face )
+        , m_height( height )
+        , m_width( width )
+        , m_hinting( hinting )
+        , m_rendering( rendering )
+      {
+        select_face();
+        m_face_height=m_face->height();
+        m_face_width=m_face->width();
+        m_face_ascent=m_face->ascent();
+        m_face_descent=m_face->descent();
+        m_face_ascent_b=m_face->ascent_b();
+        m_face_descent_b=m_face->descent_b();
+      }
+
+      double height() const
+      {
+        return m_face_height;
+      }
+
+      double width() const
+      {
+        return m_face_width;
+      }
+
+      double ascent() const
+      {
+        return m_face_ascent;
+      }
+
+      double descent() const
+      {
+        return m_face_descent;
+      }
+
+      double ascent_b() const
+      {
+        return m_face_ascent_b;
+      }
+
+      double descent_b() const
+      {
+        return m_face_descent_b;
+      }
+
+      bool add_kerning( const cached_glyph *first, const cached_glyph *second, double* x, double* y)
+      {
+        if( !first || !second )
+          return false;
+        select_face();
+        return m_face->add_kerning(
+          first->glyph_index, second->glyph_index, x, y );
+      }
+
+      void select_face()
+      {
+        m_face->select_instance( m_height, m_width, m_hinting, m_rendering );
+      }
+
+      const cached_glyph *get_glyph(unsigned cp)
+      {
+        const cached_glyph *glyph=m_glyphs.find_glyph(cp);
+        if( glyph==0 )
+        {
+          typename FontEngine::prepared_glyph prepared;
+          select_face();
+          bool success=m_face->prepare_glyph(cp, &prepared);
+          if( success )
+          {
+            glyph=m_glyphs.cache_glyph(
+              this,
+              prepared.glyph_code,
+              prepared.glyph_index,
+              prepared.data_size,
+              prepared.data_type,
+              prepared.bounds,
+              prepared.advance_x,
+              prepared.advance_y );
+            assert( glyph!=0 );
+            m_face->write_glyph_to(&prepared,glyph->data);
+          }
+        }
+        return glyph;
+      }
+
+      font_engine_type&   m_engine;
+      typename FontEngine::loaded_face *m_face;
+      double				m_height;
+      double				m_width;
+      bool				m_hinting;
+      glyph_rendering		m_rendering;
+      double				m_face_height;
+      double				m_face_width;
+      double				m_face_ascent;
+      double				m_face_descent;
+      double				m_face_ascent_b;
+      double				m_face_descent_b;
+      cached_glyphs		m_glyphs;
+    };
+
+    //--------------------------------------------------------------------
+    font_cache_manager(font_engine_type& engine, unsigned max_fonts=32)
+      :m_engine(engine)
+    { }
+
+    //--------------------------------------------------------------------
+    void init_embedded_adaptors(const cached_glyph* gl,
+      double x, double y,
+      double scale=1.0)
+    {
+      if(gl)
+      {
+        switch(gl->data_type)
+        {
+        default: return;
+        case glyph_data_mono:
+          m_mono_adaptor.init(gl->data, gl->data_size, x, y);
+          break;
+
+        case glyph_data_gray8:
+          m_gray8_adaptor.init(gl->data, gl->data_size, x, y);
+          break;
+
+        case glyph_data_outline:
+          m_path_adaptor.init(gl->data, gl->data_size, x, y, scale);
+          break;
+        }
+      }
+    }
+
+
+    //--------------------------------------------------------------------
+    path_adaptor_type&   path_adaptor()   { return m_path_adaptor;   }
+    gray8_adaptor_type&  gray8_adaptor()  { return m_gray8_adaptor;  }
+    gray8_scanline_type& gray8_scanline() { return m_gray8_scanline; }
+    mono_adaptor_type&   mono_adaptor()   { return m_mono_adaptor;   }
+    mono_scanline_type&  mono_scanline()  { return m_mono_scanline;  }
+
+
+  private:
+    //--------------------------------------------------------------------
+    font_cache_manager(const self_type&);
+    const self_type& operator = (const self_type&);
+
+    font_engine_type&   m_engine;
+    path_adaptor_type   m_path_adaptor;
+    gray8_adaptor_type  m_gray8_adaptor;
+    gray8_scanline_type m_gray8_scanline;
+    mono_adaptor_type   m_mono_adaptor;
+    mono_scanline_type  m_mono_scanline;
+  };
+
+}
+}
+
+#endif
+
--- a/dep/agg/include/agg_gamma_functions.h
+++ b/dep/agg/include/agg_gamma_functions.h
@@ -0,0 +1,131 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GAMMA_FUNCTIONS_INCLUDED
+#define AGG_GAMMA_FUNCTIONS_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+    //===============================================================gamma_none
+    struct gamma_none
+    {
+        double operator()(double x) const { return x; }
+    };
+
+
+    //==============================================================gamma_power
+    class gamma_power
+    {
+    public:
+        gamma_power() : m_gamma(1.0) {}
+        gamma_power(double g) : m_gamma(g) {}
+
+        void gamma(double g) { m_gamma = g; }
+        double gamma() const { return m_gamma; }
+
+        double operator() (double x) const
+        {
+            return pow(x, m_gamma);
+        }
+
+    private:
+        double m_gamma;
+    };
+
+
+    //==========================================================gamma_threshold
+    class gamma_threshold
+    {
+    public:
+        gamma_threshold() : m_threshold(0.5) {}
+        gamma_threshold(double t) : m_threshold(t) {}
+
+        void threshold(double t) { m_threshold = t; }
+        double threshold() const { return m_threshold; }
+
+        double operator() (double x) const
+        {
+            return (x < m_threshold) ? 0.0 : 1.0;
+        }
+
+    private:
+        double m_threshold;
+    };
+
+
+    //============================================================gamma_linear
+    class gamma_linear
+    {
+    public:
+        gamma_linear() : m_start(0.0), m_end(1.0) {}
+        gamma_linear(double s, double e) : m_start(s), m_end(e) {}
+
+        void set(double s, double e) { m_start = s; m_end = e; }
+        void start(double s) { m_start = s; }
+        void end(double e) { m_end = e; }
+        double start() const { return m_start; }
+        double end() const { return m_end; }
+
+        double operator() (double x) const
+        {
+            if(x < m_start) return 0.0;
+            if(x > m_end) return 1.0;
+            return (x - m_start) / (m_end - m_start);
+        }
+
+    private:
+        double m_start;
+        double m_end;
+    };
+
+
+    //==========================================================gamma_multiply
+    class gamma_multiply
+    {
+    public:
+        gamma_multiply() : m_mul(1.0) {}
+        gamma_multiply(double v) : m_mul(v) {}
+
+        void value(double v) { m_mul = v; }
+        double value() const { return m_mul; }
+
+        double operator() (double x) const
+        {
+            double y = x * m_mul;
+            if(y > 1.0) y = 1.0;
+            return y;
+        }
+
+    private:
+        double m_mul;
+    };
+
+    inline double sRGB_to_linear(double x)
+    {
+        return (x <= 0.04045) ? (x / 12.92) : pow((x + 0.055) / (1.055), 2.4);
+    }
+
+    inline double linear_to_sRGB(double x)
+    {
+        return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
+    }
+}
+
+#endif
+
+
+
--- a/dep/agg/include/agg_gamma_lut.h
+++ b/dep/agg/include/agg_gamma_lut.h
@@ -0,0 +1,307 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GAMMA_LUT_INCLUDED
+#define AGG_GAMMA_LUT_INCLUDED
+
+#include <cmath>
+#include "agg_basics.h"
+#include "agg_gamma_functions.h"
+
+namespace agg
+{
+    template<class LoResT=int8u, 
+             class HiResT=int8u, 
+             unsigned GammaShift=8, 
+             unsigned HiResShift=8> class gamma_lut
+    {
+    public:
+        typedef gamma_lut<LoResT, HiResT, GammaShift, HiResShift> self_type;
+
+        enum gamma_scale_e
+        {
+            gamma_shift = GammaShift,
+            gamma_size  = 1 << gamma_shift,
+            gamma_mask  = gamma_size - 1
+        };
+
+        enum hi_res_scale_e
+        {
+            hi_res_shift = HiResShift,
+            hi_res_size  = 1 << hi_res_shift,
+            hi_res_mask  = hi_res_size - 1
+        };
+
+        ~gamma_lut()
+        {
+            pod_allocator<LoResT>::deallocate(m_inv_gamma, hi_res_size);
+            pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
+        }
+
+        gamma_lut() : 
+            m_gamma(1.0), 
+            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        {
+            unsigned i;
+            for(i = 0; i < gamma_size; i++)
+            {
+                m_dir_gamma[i] = HiResT(i << (hi_res_shift - gamma_shift));
+            }
+
+            for(i = 0; i < hi_res_size; i++)
+            {
+                m_inv_gamma[i] = LoResT(i >> (hi_res_shift - gamma_shift));
+            }
+        }
+
+        gamma_lut(double g) :
+            m_gamma(1.0), 
+            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        {
+            gamma(g);
+        }
+
+        void gamma(double g) 
+        {
+            m_gamma = g;
+
+            unsigned i;
+            for(i = 0; i < gamma_size; i++)
+            {
+                m_dir_gamma[i] = (HiResT)
+                    uround(std::pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
+            }
+
+            double inv_g = 1.0 / g;
+            for(i = 0; i < hi_res_size; i++)
+            {
+                m_inv_gamma[i] = (LoResT)
+                    uround(std::pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
+            }
+        }
+
+        double gamma() const
+        {
+            return m_gamma;
+        }
+
+        HiResT dir(LoResT v) const 
+        { 
+            return m_dir_gamma[unsigned(v)]; 
+        }
+
+        LoResT inv(HiResT v) const 
+        { 
+            return m_inv_gamma[unsigned(v)];
+        }
+
+    private:
+        gamma_lut(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        double m_gamma;
+        HiResT* m_dir_gamma;
+        LoResT* m_inv_gamma;
+    };
+
+    //
+    // sRGB support classes
+    //
+
+    // Optimized sRGB lookup table. The direct conversion (sRGB to linear) 
+    // is a straightforward lookup. The inverse conversion (linear to sRGB) 
+    // is implemented using binary search.
+    template<class LinearType>
+    class sRGB_lut_base
+    {
+    public:
+        LinearType dir(int8u v) const
+        {
+            return m_dir_table[v];
+        }
+
+        int8u inv(LinearType v) const
+        {
+            // Unrolled binary search.
+            int8u x = 0;
+            if (v > m_inv_table[128]) x = 128;
+            if (v > m_inv_table[x + 64]) x += 64;
+            if (v > m_inv_table[x + 32]) x += 32;
+            if (v > m_inv_table[x + 16]) x += 16;
+            if (v > m_inv_table[x + 8]) x += 8;
+            if (v > m_inv_table[x + 4]) x += 4;
+            if (v > m_inv_table[x + 2]) x += 2;
+            if (v > m_inv_table[x + 1]) x += 1;
+            return x;
+        }
+
+    protected:
+        LinearType m_dir_table[256];
+        LinearType m_inv_table[256];
+
+        // Only derived classes may instantiate.
+        sRGB_lut_base() 
+        {
+        }
+    };
+
+
+    // sRGB_lut - implements sRGB conversion for the various types.
+    // Base template is undefined, specializations are provided below.
+    template<class LinearType>
+    class sRGB_lut;
+
+    template<>
+    class sRGB_lut<float> : public sRGB_lut_base<float>
+    {
+    public:
+		sRGB_lut()
+		{
+			// Generate lookup tables.
+			m_dir_table[0] = 0;
+			m_inv_table[0] = 0;
+			for (unsigned i = 1; i <= 255; ++i)
+			{
+				// Floating-point RGB is in range [0,1].
+				m_dir_table[i] = float(sRGB_to_linear(i / 255.0));
+				m_inv_table[i] = float(sRGB_to_linear((i - 0.5) / 255.0));
+			}
+		}
+    };
+
+    template<>
+    class sRGB_lut<int16u> : public sRGB_lut_base<int16u>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables.
+            m_dir_table[0] = 0;
+            m_inv_table[0] = 0;
+            for (int i = 1; i <= 255; ++i)
+            {
+                // 16-bit RGB is in range [0,65535].
+                m_dir_table[i] = uround(65535.0 * sRGB_to_linear(i / 255.0));
+                m_inv_table[i] = uround(65535.0 * sRGB_to_linear((i - 0.5) / 255.0));
+            }
+        }
+    };
+
+    template<>
+    class sRGB_lut<int8u> : public sRGB_lut_base<int8u>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables. 
+            m_dir_table[0] = 0;
+            m_inv_table[0] = 0;
+            for (int i = 1; i <= 255; ++i)
+            {
+                // 8-bit RGB is handled with simple bidirectional lookup tables.
+                m_dir_table[i] = uround(255.0 * sRGB_to_linear(i / 255.0));
+                m_inv_table[i] = uround(255.0 * linear_to_sRGB(i / 255.0));
+            }
+        }
+
+        int8u inv(int8u v) const
+        {
+            // In this case, the inverse transform is a simple lookup.
+            return m_inv_table[v];
+        }
+    };
+
+    // Common base class for sRGB_conv objects. Defines an internal 
+    // sRGB_lut object so that users don't have to.
+    template<class T>
+    class sRGB_conv_base
+    {
+    public:
+        static T rgb_from_sRGB(int8u x)
+        {
+            return lut.dir(x);
+        }
+
+        static int8u rgb_to_sRGB(T x)
+        {
+            return lut.inv(x);
+        }
+
+    private:
+        static sRGB_lut<T> lut;
+    };
+
+    // Definition of sRGB_conv_base::lut. Due to the fact that this a template, 
+    // we don't need to place the definition in a cpp file. Hurrah.
+    template<class T>
+    sRGB_lut<T> sRGB_conv_base<T>::lut;
+
+    // Wrapper for sRGB-linear conversion. 
+    // Base template is undefined, specializations are provided below.
+    template<class T>
+    class sRGB_conv;
+
+    template<>
+    class sRGB_conv<float> : public sRGB_conv_base<float>
+    {
+    public:
+        static float alpha_from_sRGB(int8u x)
+        {
+            static const double y = 1 / 255.0;
+            return float(x * y);
+        }
+
+        static int8u alpha_to_sRGB(float x)
+        {
+            if (x < 0) return 0;
+            if (x > 1) return 255;
+            return int8u(0.5 + x * 255);
+        }
+    };
+
+    template<>
+    class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
+    {
+    public:
+        static int16u alpha_from_sRGB(int8u x)
+        {
+            return (x << 8) | x;
+        }
+
+        static int8u alpha_to_sRGB(int16u x)
+        {
+            return x >> 8;
+        }
+    };
+
+    template<>
+    class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
+    {
+    public:
+        static int8u alpha_from_sRGB(int8u x)
+        {
+            return x;
+        }
+
+        static int8u alpha_to_sRGB(int8u x)
+        {
+            return x;
+        }
+    };
+}
+
+#endif
--- a/dep/agg/include/agg_glyph_raster_bin.h
+++ b/dep/agg/include/agg_glyph_raster_bin.h
@@ -0,0 +1,155 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GLYPH_RASTER_BIN_INCLUDED
+#define AGG_GLYPH_RASTER_BIN_INCLUDED
+
+#include <cstring>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //========================================================glyph_raster_bin
+    template<class ColorT> class glyph_raster_bin
+    {
+    public:
+        typedef ColorT color_type;
+
+        //--------------------------------------------------------------------
+        struct glyph_rect
+        {
+            int x1,y1,x2,y2;
+            double dx, dy;
+        };
+
+        //--------------------------------------------------------------------
+        glyph_raster_bin(const int8u* font) :
+            m_font(font),
+            m_big_endian(false)
+        {
+            int t = 1;
+            if(*(char*)&t == 0) m_big_endian = true;
+            std::memset(m_span, 0, sizeof(m_span));
+        }
+
+        //--------------------------------------------------------------------
+        const int8u* font() const { return m_font; }
+        void font(const int8u* f) { m_font = f; }
+
+        //--------------------------------------------------------------------
+        double height()    const { return m_font[0]; }
+        double base_line() const { return m_font[1]; }
+
+        //--------------------------------------------------------------------
+        template<class CharT>
+        double width(const CharT* str) const
+        {
+            unsigned start_char = m_font[2];
+            unsigned num_chars = m_font[3];
+
+            unsigned w = 0;
+            while(*str)
+            {
+                unsigned glyph = *str;
+                const int8u* bits = m_font + 4 + num_chars * 2 + 
+                                    value(m_font + 4 + (glyph - start_char) * 2);
+                w += *bits;
+                ++str;
+            }
+            return w;
+        }
+
+        //--------------------------------------------------------------------
+        void prepare(glyph_rect* r, double x, double y, unsigned glyph, bool flip)
+        {
+            unsigned start_char = m_font[2];
+            unsigned num_chars = m_font[3];
+
+            m_bits = m_font + 4 + num_chars * 2 + 
+                     value(m_font + 4 + (glyph - start_char) * 2);
+
+            m_glyph_width = *m_bits++;
+            m_glyph_byte_width = (m_glyph_width + 7) >> 3;
+
+            r->x1 = int(x);
+            r->x2 = r->x1 + m_glyph_width - 1;
+            if(flip)
+            {
+                r->y1 = int(y) - m_font[0] + m_font[1];
+                r->y2 = r->y1 + m_font[0] - 1;
+            }
+            else
+            {
+                r->y1 = int(y) - m_font[1] + 1;
+                r->y2 = r->y1 + m_font[0] - 1;
+            }
+            r->dx = m_glyph_width; 
+            r->dy = 0;
+        }
+
+        //--------------------------------------------------------------------
+        const cover_type* span(unsigned i)
+        {
+            i = m_font[0] - i - 1;
+            const int8u* bits = m_bits + i * m_glyph_byte_width;
+            unsigned j;
+            unsigned val = *bits;
+            unsigned nb = 0;
+            for(j = 0; j < m_glyph_width; ++j)
+            {
+                m_span[j] = (cover_type)((val & 0x80) ? cover_full : cover_none);
+                val <<= 1;
+                if(++nb >= 8)
+                {
+                    val = *++bits;
+                    nb = 0;
+                }
+            }
+            return m_span;
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        int16u value(const int8u* p) const
+        {
+            int16u v;
+            if(m_big_endian)
+            {
+                 *(int8u*)&v      = p[1];
+                *((int8u*)&v + 1) = p[0];
+            }
+            else
+            {
+                 *(int8u*)&v      = p[0];
+                *((int8u*)&v + 1) = p[1];
+            }
+            return v;
+        }
+
+
+        //--------------------------------------------------------------------
+        const int8u* m_font;
+        bool m_big_endian;
+        cover_type m_span[32];
+        const int8u* m_bits;
+        unsigned m_glyph_width;
+        unsigned m_glyph_byte_width;
+    };
+
+
+}
+
+#endif
--- a/Show More
+++ b/Show More