patterns/java_class: Added MIME type

type/leb128: Fixed type always displaying 0
patterns/7z: Added CompressData length and other improvements (#134 )
2026-03-31 05:15:54 -05:00 · 2023-06-24 11:05:10 +02:00 · 2023-06-22 17:35:59 +02:00 · 2023-06-22 07:27:31 +02:00 · 2023-06-19 23:09:16 +02:00 · 2023-06-19 23:08:42 +02:00
135 changed files with 163411 additions and 1117703 deletions
--- a/.github/PULL_REQUEST_TEMPLATE/pattern_template.md
+++ b/.github/PULL_REQUEST_TEMPLATE/pattern_template.md
@@ -6,5 +6,6 @@
 - [ ] A pattern for this format doesn't exist yet (or this PR improves the existing one)
 - [ ] The new pattern has been added to the relevant table in the Readme
 - [ ] The pattern was associated with all relevant MIME types (using `#pragma MIME mime-type` in the source code)
+  - Make sure to never use `application/octet-stream` here as that means "Unidentifiable binary data"
 - [ ] A test file for this pattern has been added to [/tests/patterns/test_data](/tests/patterns/test_data)
  - Try to keep this file below ~ 1 MB 
--- a/.github/workflows/dispatch.yml
+++ b/.github/workflows/dispatch.yml
@@ -0,0 +1,47 @@
+name: "Dispatch"
+
+on:
+  push:
+    branches: [ '*' ]
+  pull_request:
+    branches: [ '*' ]
+  repository_dispatch:
+    types: [run_tests]
+  workflow_dispatch:
+    inputs: 
+      generate_docs:
+        description: "Regenerate docs"
+        required: false
+        type: boolean
+
+jobs:
+  tests:
+    name: 🎯 Dispatch changes
+    runs-on: ubuntu-22.04
+    env:
+      DISPATCH_TOKEN: ${{ secrets.DISPATCH_TOKEN }}
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+    - name: 🧰 Checkout
+      uses: actions/checkout@v2
+      with:
+        submodules: recursive
+
+    - name: 📄 Check changed include files
+      id: changed-includes
+      uses: tj-actions/changed-files@v35
+      with:
+        files: includes/**/*.pat
+
+    - name: ✉️ Run Documentation generator
+      if: ${{ env.DISPATCH_TOKEN != '' && (steps.changed-includes.outputs.any_changed == 'true' || inputs.generate_docs || github.event_name == 'repository_dispatch' ) }}
+      uses: mvasigh/dispatch-action@main
+      with:
+        token: ${{ secrets.DISPATCH_TOKEN }}
+        repo: Documentation
+        owner: WerWolv
+        event_type: update_pl_docs
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -59,16 +59,18 @@ jobs:
        cd tests/build
        ctest --output-on-failure

-    - name: ⚗️ Generate Coverage Report
-      run: |
-        cd tests/build
-        lcov -d ./_deps/pattern_language-build/lib --gcov-tool /usr/bin/gcov-12 -c -o coverage.info
+    #- name: ⚗️ Generate Coverage Report
+    #  run: |
+    #    cd tests/build
+    #    lcov -d ./_deps/pattern_language-build/lib --gcov-tool /usr/bin/gcov-12 -c -o coverage.info

-    - name: ⬆️ Upload Coverage Report
-      uses: coverallsapp/github-action@master
-      with:
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        path-to-lcov: tests/build/coverage.info
+    #- name: ⬆️ Upload Coverage Report
+    #  uses: coverallsapp/github-action@master
+    #  env:
+    #    NODE_OPTIONS: --max-old-space-size=8000 
+    #  with:
+    #    github-token: ${{ secrets.GITHUB_TOKEN }}
+    #    path-to-lcov: tests/build/coverage.info

    - name: 📎 Validate JSON Files
      run: |
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 tests/cmake-build-debug/

 .idea/
+.DS_Store
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,12 @@
+# Contributing
+
+Contributing to the Database is very simple. Fork this repository, add your new files (or changes to existing files) to the right folders and create a PR.
+When adding new files, please make sure to also add a link to them to the Table of Contents in the README.md file. That way the files can be discovered by others more easily.
+
+Thanks a lot for any additions or improvements :)
+
+## Adding new Patterns
+
+When adding new patterns, if possible, please also add a test file named `<pattern_name>.hexpat.<extension>` to the `/tests/patterns/test_data` directory. This allows our Unit Tests to be run against your code so we can make sure it stays up-to-date and doesn't break when changes are made to the PatternLanguage.
+Please try to keep these files as small as possible (~100kiB at most) so cloning stays fast. 
+Please also make sure to not submit any test files that are under copyright such as game files, ROMs or files extracted from other programs. We don't want a DMCA takedown on this repo.
--- a/README.md
+++ b/README.md
@@ -1,6 +1,20 @@
-# ImHex-Patterns
+# ImHex Database

-Hex patterns, include patterns and magic files for the use with the ImHex Hex Editor
+This repository serves as a database for files to use with the [ImHex Hex Editor](https://github.com/WerWolv/ImHex). It currently contains
+- [Patterns](/patterns) - Binary Format definitions for the Pattern Language
+- [Pattern Libraries](/includes) - Libraries that make using the Pattern Language easier
+- [Magic Files](/magic) - Custom magic file definitions for the use with libmagic
+- [Encodings](/encodings) - Custom encodings in the .tbl format
+- [Data Processor Nodes](/nodes) - Custom nodes made for ImHex's Data Processor
+- [Themes](/themes) - Custom themes for ImHex
+- [Constants](/constants) - Constants definition files
+- [Scripts](/scripts) - Various scripts to generate code or automate some tasks
+- [Yara](/yara) - Custom Yara rules
+
+## Submissions
+
+Most files in this repository have been submitted by the community. Please feel free to open a PR on your own and add files to it!
+Everything will immediately show up in ImHex's Content Store and gets bundled with the next release of ImHex.

 ## Table of Contents

@@ -8,60 +22,82 @@ Hex patterns, include patterns and magic files for the use with the ImHex Hex Ed

 | Name | MIME | Path | Description |
 |------|------|------|-------------|
-| BMP  | `image/bmp` | [`patterns/bmp.hexpat`](patterns/bmp.hexpat) | OS2/Windows Bitmap files |
-| ELF  | `application/x-executable` | [`patterns/elf.hexpat`](patterns/elf.hexpat) | ELF header in elf binaries |
-| PE   | `application/x-dosexec` | [`patterns/pe.hexpat`](patterns/pe.hexpat) | PE header, COFF header, Standard COFF fields and Windows Specific fields |
-| NE   | | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
-| Intel HEX  | | [`patterns/intel_hex.hexpat`](patterns/intel_hex.hexpat) | [Intel hexadecimal object file format definition]("https://en.wikipedia.org/wiki/Intel_HEX") |
-| MIDI | `audio/midi` | [`patterns/midi.hexpat`](patterns/midi.hexpat) | MIDI header, event fields provided |
-| WAV  | `audio/wav`  | [`patterns/wav.hexpat`](patterns/wav.hexpat)  | RIFF header, WAVE header, PCM header |
-| ZIP  | `application/zip` | [`patterns/zip.hexpat`](patterns/zip.hexpat) | End of Central Directory Header, Central Directory File Headers |
-| PCAP | `application/vnd.tcpdump.pcap` | [`patterns/pcap.hexpat`](patterns/pcap.hexpat) | pcap header and packets | 
-| SPIRV | | [`patterns/spirv.hexpat`](patterns/spirv.hexpat) | SPIR-V header and instructions | 
+| 7Z | | [`patterns/7z.hexpat`](patterns/7z.hexpat) | 7z File Format | 
 | AFE2 | | [`patterns/afe2.hexpat`](patterns/afe2.hexpat) | Nintendo Switch Atmosphère CFW Fatal Error log | 
 | AR | `application/x-archive` | [`patterns/ar.hexpat`](patterns/ar.hexpat) | Static library archive files | 
-| NACP | | [`patterns/nacp.hexpat`](patterns/nacp.hexpat) | Nintendo Switch NACP files | 
-| NRO | | [`patterns/nro.hexpat`](patterns/nro.hexpat) | Nintendo Switch NRO files | 
-| PRODINFO | | [`patterns/prodinfo.hexpat`](patterns/prodinfo.hexpat) | Nintendo Switch PRODINFO | 
-| Java Class | `application/x-java-applet` | [`patterns/java_class.hexpat`](patterns/java_class.hexpat) | Java Class files | 
 | ARM VTOR | | [`patterns/arm_cm_vtor.hexpat`](patterns/arm_cm_vtor.hexpat) | ARM Cortex M Vector Table Layout | 
-| ICO | | [`patterns/ico.hexpat`](patterns/ico.hexpat) | Icon (.ico) or Cursor (.cur) files | 
-| PNG  | `image/png` | [`patterns/png.hexpat`](patterns/png.hexpat) | PNG image files | 
-| DDS | `image/vnd-ms.dds` | [`patterns/dds.hexpat`](patterns/dds.hexpat) | DirectDraw Surface |
-| TGA | `image/tga` | [`patterns/tga.hexpat`](patterns/tga.hexpat) | Truevision TGA/TARGA image |
-| ISO | | [`patterns/iso.hexpat`](patterns/iso.hexpat) | ISO 9660 file system |
-| VDF | | [`patterns/vdf.hexpat`](patterns/vdf.hexpat) | Binary Value Data Format (.vdf) files | 
-| IP | | [`patterns/ip.hexpat`](patterns/ip.hexpat) | Ethernet II Frames (IP Packets) | 
-| UF2 | | [`patterns/uf2.hexpat`](patterns/uf2.hexpat) | [USB Flashing Format](https://github.com/microsoft/uf2) | 
-| File System | | [`patterns/fs.hexpat`](patterns/fs.hexpat) | Drive File System | 
 | Bencode | `application/x-bittorrent` | [`patterns/bencode.hexpat`](patterns/bencode.hexpat) | Bencode encoding, used by Torrent files | 
-| Protobuf | | [`patterns/protobuf.hexpat`](patterns/protobuf.hexpat) | Google Protobuf encoding | 
-| OGG | `audio/ogg` | [`patterns/ogg.hexpat`](patterns/ogg.hexpat) | OGG Audio format | 
-| STL | `model/stl` | [`patterns/stl.hexpat`](patterns/stl.hexpat) | STL 3D Model format | 
-| VHDX | | [`patterns/vhdx.hexpat`](patterns/vhdx.hexpat) | Microsoft Hyper-V Virtual Hard Disk format | 
-| NTAG | | [`patterns/ntag.hexpat`](patterns/ntag.hexpat) | NTAG213/NTAG215/NTAG216, NFC Forum Type 2 Tag compliant IC | 
-| Shell Link | `application/x-ms-shortcut` | [`patterns/lnk.hexpat`](patterns/lnk.hexpat) | Windows Shell Link file format | 
-| Xilinx BIT | | [`patterns/xilinx_bit.hexpat`](patterns/xilinx_bit.hexpat) | Xilinx FPGA Bitstreams | 
-| FLAC | `audio/flac` | [`patterns/flac.hexpat`](patterns/flac.hexpat) | Free Lossless Audio Codec, FLAC Audio Format | 
+| BMP  | `image/bmp` | [`patterns/bmp.hexpat`](patterns/bmp.hexpat) | OS2/Windows Bitmap files |
 | BSON | `application/bson` | [`patterns/bson.hexpat`](patterns/bson.hexpat) | BSON (Binary JSON) format | 
-| msgpack | `application/x-msgpack` | [`patterns/msgpack.hexpat`](patterns/msgpack.hexpat) | MessagePack binary serialization format | 
-| MiniDump | `application/x-dmp` | [`patterns/minidump.hexpat`](patterns/minidump.hexpat) | Windows MiniDump files | 
-| ID3 | `audio/mpeg` | [`patterns/id3tag.hexpat`](patterns/id3tag.hexpat) | ID3 tags in MP3 files |
-| TAR | `application/x-tar` | [`patterns/tar.hexpat`](patterns/tar.hexpat) | Tar file format |
-| CPIO | `application/x-cpio` | [`patterns/cpio.hexpat`](patterns/cpio.hexpat) | Old Binary CPIO Format |
-| FDT | | [`patterns/fdt.hexpat`](patterns/fdt.hexpat) | Flat Linux Device Tree blob |
-| StuffItV5 | `application/x-stuffit` | [`patterns/sit5.hexpat`](patterns/sit5.hexpat) | StuffIt V5 archive |
-| NBT | | [`patterns/nbt.hexpat`](patterns/nbt.hexpat) | Minecraft NBT format |
-| PCX | `application/x-pcx` | [`patterns/pcx.hexpat`](patterns/pcx.hexpat) | PCX Image format |
-| GZIP | `application/gzip` | [`patterns/gzip.hexpat`](patterns/gzip.hexpat) | GZip compressed data format |
-| PFS0 | | [`patterns/pfs0.hexpat`](patterns/pfs0.hexpat) | Nintendo Switch PFS0 archive (NSP files) |
-| XCI | | [`patterns/xci.hexpat`](patterns/xci.hexpat) | Nintendo Switch XCI cardridge ROM |
-| WAD | | [`patterns/wad.hexpat`](patterns/wad.hexpat) | DOOM WAD Archive |
-| GIF | `image/gif` | [`patterns/gif.hexpat`](patterns/gif.hexpat) | GIF image files |
-| ZSTD | `application/zstd` | [`patterns/zstd.hexpat`](patterns/zstd.hexpat) | Zstandard compressed data format |
-| COFF | `application/x-coff` | [`patterns/coff.hexpat`](patterns/coff.hexpat) | Common Object File Format (COFF) executable |
-| Mach-O | `application/x-mach-binary` | [`patterns/macho.hexpat`](patterns/macho.hexpat) | Mach-O executable |
+| BSP | | [`patterns/bsp_goldsrc.hexpat`](patterns/bsp_goldsrc.hexpat) | GoldSrc engine maps format (used in Half-Life 1) |
+| CCHVA | | [`patterns/cchva.hexpat`](patterns/cchva.hexpat) | Command and Conquer Voxel Animation |
+| CCVXL | | [`patterns/ccvxl.hexpat`](patterns/ccvxl.hexpat) | Command and Conquer Voxel Model |
+| CCPAL | | [`patterns/ccpal.hexpat`](patterns/ccpal.hexpat) | Command and Conquer Voxel Palette |
+| CDA | | [`patterns/cda.hexpat`](patterns/cda.hexpat) | Compact Disc Audio track |
 | CHM | | [`patterns/chm.hexpat`](patterns/chm.hexpat) | Windows HtmlHelp Data (ITSF / CHM) |
+| COFF | `application/x-coff` | [`patterns/coff.hexpat`](patterns/coff.hexpat) | Common Object File Format (COFF) executable |
+| CPIO | `application/x-cpio` | [`patterns/cpio.hexpat`](patterns/cpio.hexpat) | Old Binary CPIO Format |
+| CrashLvl | | [`patterns/Crashlvl.hexpat`](patterns/Crashlvl.hexpat) | Crash Bandicoot - Back in Time (fan game) User created flashback tapes level format |
+| DDS | `image/vnd-ms.dds` | [`patterns/dds.hexpat`](patterns/dds.hexpat) | DirectDraw Surface |
+| DEX | | [`patterns/dex.hexpat`](patterns/dex.hexpat) | Dalvik EXecutable Format |
+| DMG | | [`patterns/dmg.hexpat`](patterns/dmg.hexpat) | Apple Disk Image Trailer (DMG) |
+| DS_Store | `application/octet-stream` | [`patterns/dsstore.hexpat`](patterns/dsstore.hexpat) | .DS_Store file format |
+| DTA | | [`patterns/max_v104.hexpat`](patterns/max_v104.hexpat) | Mechanized Assault and Exploration v1.04 (strategy game) save file format |
+| ELF  | `application/x-executable` | [`patterns/elf.hexpat`](patterns/elf.hexpat) | ELF header in elf binaries |
+| EVTX | | [`patterns/evtx.hexpat`](patterns/evtx.hexpat) | MS Windows Vista Event Log |
+| FDT | | [`patterns/fdt.hexpat`](patterns/fdt.hexpat) | Flat Linux Device Tree blob |
+| File System | | [`patterns/fs.hexpat`](patterns/fs.hexpat) | Drive File System | 
+| FLAC | `audio/flac` | [`patterns/flac.hexpat`](patterns/flac.hexpat) | Free Lossless Audio Codec, FLAC Audio Format | 
+| GB | `application/x-gameboy-rom` | [`patterns/gb.hexpat`](patterns/gb.hexpat) | Gameboy ROM |
+| GIF | `image/gif` | [`patterns/gif.hexpat`](patterns/gif.hexpat) | GIF image files |
+| GZIP | `application/gzip` | [`patterns/gzip.hexpat`](patterns/gzip.hexpat) | GZip compressed data format |
+| ICO | | [`patterns/ico.hexpat`](patterns/ico.hexpat) | Icon (.ico) or Cursor (.cur) files | 
+| ID3 | `audio/mpeg` | [`patterns/id3.hexpat`](patterns/id3.hexpat) | ID3 tags in MP3 files |
+| Intel HEX  | | [`patterns/intel_hex.hexpat`](patterns/intel_hex.hexpat) | [Intel hexadecimal object file format definition]("https://en.wikipedia.org/wiki/Intel_HEX") |
+| IP | | [`patterns/ip.hexpat`](patterns/ip.hexpat) | Ethernet II Frames (IP Packets) | 
+| ISO | | [`patterns/iso.hexpat`](patterns/iso.hexpat) | ISO 9660 file system |
+| Java Class | `application/x-java-applet` | [`patterns/java_class.hexpat`](patterns/java_class.hexpat) | Java Class files | 
+| JPEG | `image/jpeg` | [`patterns/jpeg.hexpat`](patterns/jpeg.hexpat) | JPEG Image Format |
+| Lua 5.4 | | [`patterns/lua54.hexpat`](patterns/lua54.hexpat) | Lua 5.4 bytecode |
+| Mach-O | `application/x-mach-binary` | [`patterns/macho.hexpat`](patterns/macho.hexpat) | Mach-O executable |
+| MIDI | `audio/midi` | [`patterns/midi.hexpat`](patterns/midi.hexpat) | MIDI header, event fields provided |
+| MiniDump | `application/x-dmp` | [`patterns/minidump.hexpat`](patterns/minidump.hexpat) | Windows MiniDump files | 
+| mp4 | `video/mp4` | [`patterns/mp4.hexpat`](patterns/mp4.hexpat) | MPEG-4 Part 14 digital multimedia container format | 
+| msgpack | `application/x-msgpack` | [`patterns/msgpack.hexpat`](patterns/msgpack.hexpat) | MessagePack binary serialization format | 
+| NACP | | [`patterns/nacp.hexpat`](patterns/nacp.hexpat) | Nintendo Switch NACP files | 
+| NBT | | [`patterns/nbt.hexpat`](patterns/nbt.hexpat) | Minecraft NBT format |
+| NE   | | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
+| NRO | | [`patterns/nro.hexpat`](patterns/nro.hexpat) | Nintendo Switch NRO files | 
+| NTAG | | [`patterns/ntag.hexpat`](patterns/ntag.hexpat) | NTAG213/NTAG215/NTAG216, NFC Forum Type 2 Tag compliant IC | 
+| OGG | `audio/ogg` | [`patterns/ogg.hexpat`](patterns/ogg.hexpat) | OGG Audio format | 
+| PCAP | `application/vnd.tcpdump.pcap` | [`patterns/pcap.hexpat`](patterns/pcap.hexpat) | pcap header and packets | 
+| PCX | `application/x-pcx` | [`patterns/pcx.hexpat`](patterns/pcx.hexpat) | PCX Image format |
+| PE   | `application/x-dosexec` | [`patterns/pe.hexpat`](patterns/pe.hexpat) | PE header, COFF header, Standard COFF fields and Windows Specific fields |
+| PFS0 | | [`patterns/pfs0.hexpat`](patterns/pfs0.hexpat) | Nintendo Switch PFS0 archive (NSP files) |
+| PIF | `image/pif` | [`patterns/pif.hexpat`](patterns/pif.hexpat) | PIF Image Format |
+| PNG  | `image/png` | [`patterns/png.hexpat`](patterns/png.hexpat) | PNG image files | 
+| PRODINFO | | [`patterns/prodinfo.hexpat`](patterns/prodinfo.hexpat) | Nintendo Switch PRODINFO | 
+| Protobuf | | [`patterns/protobuf.hexpat`](patterns/protobuf.hexpat) | Google Protobuf encoding | 
+| QBCL | | [`patterns/qbcl.hexpat`](patterns/qbcl.hexpat) | Qubicle voxel scene project file |
+| QOI  | `image/qoi` | [`patterns/qoi.hexpat`](patterns/qoi.hexpat) | QOI image files | 
+| Shell Link | `application/x-ms-shortcut` | [`patterns/lnk.hexpat`](patterns/lnk.hexpat) | Windows Shell Link file format | 
+| SPIRV | | [`patterns/spirv.hexpat`](patterns/spirv.hexpat) | SPIR-V header and instructions | 
+| STL | `model/stl` | [`patterns/stl.hexpat`](patterns/stl.hexpat) | STL 3D Model format | 
+| StuffItV5 | `application/x-stuffit` | [`patterns/sit5.hexpat`](patterns/sit5.hexpat) | StuffIt V5 archive |
+| TAR | `application/x-tar` | [`patterns/tar.hexpat`](patterns/tar.hexpat) | Tar file format |
+| TIFF | `image/tiff` | [`patterns/tiff.hexpat`](patterns/tiff.hexpat) | Tag Image File Format |
+| TGA | `image/tga` | [`patterns/tga.hexpat`](patterns/tga.hexpat) | Truevision TGA/TARGA image |
+| UEFI | | [`patterns/uefi.hexpat`](patterns/uefi.hexpat)` | UEFI structs for parsing efivars |
+| UF2 | | [`patterns/uf2.hexpat`](patterns/uf2.hexpat) | [USB Flashing Format](https://github.com/microsoft/uf2) | 
+| VDF | | [`patterns/vdf.hexpat`](patterns/vdf.hexpat) | Binary Value Data Format (.vdf) files | 
+| VHDX | | [`patterns/vhdx.hexpat`](patterns/vhdx.hexpat) | Microsoft Hyper-V Virtual Hard Disk format | 
+| WAV  | `audio/x-wav`  | [`patterns/wav.hexpat`](patterns/wav.hexpat)  | RIFF header, WAVE header, PCM header |
+| WAD | | [`patterns/wad.hexpat`](patterns/wad.hexpat) | DOOM WAD Archive |
+| XBEH | `audio/x-xbox-executable` | [`patterns/xbeh.hexpat`](patterns/xbeh.hexpat) | Xbox executable |
+| XCI | | [`patterns/xci.hexpat`](patterns/xci.hexpat) | Nintendo Switch XCI cardridge ROM |
+| Xilinx BIT | | [`patterns/xilinx_bit.hexpat`](patterns/xilinx_bit.hexpat) | Xilinx FPGA Bitstreams | 
+| ZIP  | `application/zip` | [`patterns/zip.hexpat`](patterns/zip.hexpat) | End of Central Directory Header, Central Directory File Headers |
+| ZSTD | `application/zstd` | [`patterns/zstd.hexpat`](patterns/zstd.hexpat) | Zstandard compressed data format |

 ### Scripts

@@ -131,6 +167,7 @@ Hex patterns, include patterns and magic files for the use with the ImHex Hex Ed
 | JIS 0213 | [`encodings/jis_x_0213.tbl`](encodings/jis_x_0213.tbl) | JIS X 0213 encoding in UTF-8 |
 | Macintosh | [`encodings/macintosh.tbl`](encodings/macintosh.tbl) | Macintosh character encoding used by the Kermit protocol |
 | Pokémon (English, Generation 1) | [`encodings/pokegen1_en.tbl`](encodings/pokegen1_en.tbl) | Character encoding used by the English generation 1 Pokémon games  |
+| Pokémon (English, Generation 3) | [`encodings/pokegen3_en.tbl`](encodings/pokegen3_en.tbl) | Character encoding used by the English generation 3 Pokémon games  |
 | Shift-JIS UTF-8 | [`encodings/shiftjis.tbl`](encodings/shiftjis.tbl) | Shift-JIS encoding in UTF-8 |
 | Thai | [`encodings/thai.tbl`](encodings/thai.tbl) | Thai character encoding |
 | Turkish ISO | [`encodings/turkish_iso.tbl`](encodings/turkish_iso.tbl) | Turkish ISO encoding |
@@ -138,9 +175,18 @@ Hex patterns, include patterns and magic files for the use with the ImHex Hex Ed
 | UTF-8 | [`encodings/utf8.tbl`](encodings/utf8.tbl) | UTF-8 encoding |
 | Vietnamese | [`encodings/vietnamese.tbl`](encodings/vietnamese.tbl) | Vietnamese character encoding |

-## Contributing
+### Data Processor Nodes
+| Name | Path | Description |
+|------|------|-------------|
+| Caesar Cipher | [`nodes/caesar.hexnode`](nodes/caesar.hexnode) | Simple adjustable per-byte Caecar Cipher (ROT) |
+| XOR Cipher | [`nodes/xor.hexnode`](nodes/xor.hexnode) | XORs a input with a repeating XOR pad |

-If you want to contribute a file to the database, please make a PR which adds it to the right folder and adds a new entry to the table in this readme. 
-To take advantage of the automatic pattern testing, please consider adding a test file named `<pattern_name>.hexpat.<extension>` to the `/tests/patterns/test_data` directory. Try to keep this file as small as possible so the repository doesn't become excessively large
-
-Thanks a lot :)
+### Themes
+| Name | Path | Description |
+|------|------|-------------|
+| Visual Studio Dark | [`themes/vs_dark.json`](themes/vs_dark.json) | Theme similar to Visual Studio's Dark theme |
+| Solarized Dark | [`themes/solarized_dark.json`](themes/solarized_dark.json) | Solarized Dark Theme |
+| Catppuccin Latte | [`themes/catppuccin-latte.json`](themes/catppuccin-latte.json) | Catppuccin Latte Flavor (Light Theme) |
+| Catppuccin Frappe | [`themes/catppuccin-frappe.json`](themes/catppuccin-frappe.json) | Catppuccin Frappe Flavor (Dark Theme) |
+| Catppuccin Macchiato | [`themes/catppuccin-macchiato.json`](themes/catppuccin-macchiato.json) | Catppuccin Macchiato Flavor (Dark Theme) |
+| Catppuccin Mocha | [`themes/catppuccin-mocha.json`](themes/catppuccin-mocha.json) | Catppuccin Mocha Flavor (Dark Theme) |
--- a/encodings/ms932.tbl
+++ b/encodings/ms932.tbl
--- a/encodings/pokegen3_en.tbl
+++ b/encodings/pokegen3_en.tbl
@@ -0,0 +1,256 @@
+00
+01=À
+02=Á
+03=Â
+04=Ç
+05=È
+06=È
+07=Ê
+08=Ë
+09=Ì
+0a
+0b=Î
+0c=Ï
+0d=Ò
+0e=Ó
+0f=Ô
+10=Œ
+11=Ù
+12=Ú
+13=Û
+14=Ñ
+15=ß
+16=à
+17=á
+18
+19=ç
+1a=è
+1b=é
+1c=ê
+1d=ë
+1e=ì
+1f
+20=î
+21=ï
+22=ò
+23=ó
+24=ô
+25=œ
+26=ù
+27=ú
+28=û
+29=ñ
+2a=º
+2b=ª
+2c=ᵉʳ
+2d=&
+2e=+
+2f
+30
+31
+32
+33
+34
+35==
+36
+37
+38
+39
+3a
+3b
+3c
+3d
+3e
+3f
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+4a
+4b
+4c
+4d
+4e
+4f
+50
+51=¿
+52=¡
+53=Pk
+54=Mn
+55=Po
+56=Ké
+57
+58
+59
+5a=Í
+5b=%
+5c=(
+5d=)
+5e
+5f
+60
+61
+62
+63
+64
+65
+66
+67
+68=â
+69
+6a
+6b
+6c
+6d
+6e
+6f=í
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79=⬆
+7a=⬇
+7b=⬅
+7c=➡
+7d
+7e
+7f
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+8a
+8b
+8c
+8d
+8e
+8f
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+9a
+9b
+9c
+9d
+9e
+9f
+a0
+a1=0
+a2=1
+a3=2
+a4=3
+a5=4
+a6=5
+a7=6
+a8=7
+a9=8
+aa=9
+ab=!
+ac=?
+ad=.
+ae=-
+af=・
+b0
+b1=“
+b2=”
+b3=‘
+b4=’
+b5=♂
+b6=♀
+b7
+b8=,
+b9=×
+ba=/
+bb=A
+bc=B
+bd=C
+be=D
+bf=E
+c0=F
+c1=G
+c2=H
+c3=I
+c4=J
+c5=K
+c6=L
+c7=M
+c8=N
+c9=O
+ca=P
+cb=Q
+cc=R
+cd=S
+ce=T
+cf=U
+d0=V
+d1=W
+d2=X
+d3=Y
+d4=Z
+d5=a
+d6=b
+d7=c
+d8=d
+d9=e
+da=f
+db=g
+dc=h
+dd=i
+de=j
+df=k
+e0=l
+e1=m
+e2=n
+e3=o
+e4=p
+e5=q
+e6=r
+e7=s
+e8=t
+e9=u
+ea=v
+eb=w
+ec=x
+ed=y
+ee=z
+ef=▶
+f0=:
+f1=Ä
+f2=Ö
+f3=Ü
+f4=ä
+f5=ö
+f6=ü
+f7
+f8
+f9
+fa
+fb
+fc
+fd
+fe
+ff
--- a/encodings/shiftjis.tbl
+++ b/encodings/shiftjis.tbl
@@ -1,9 +1,3 @@
-08=␈
-09=␉
-0A=␊
-0B=␋
-0C=␌
-0D=␍
 20= 
 21=!
 22="
@@ -127,12 +121,12 @@
 8159=〆
 815A=〇
 815B=ー
-815C=―
+815C=—
 815D=‐
 815E=／
 815F=＼
-8160=～
-8161=∥
+8160=〜
+8161=‖
 8162=｜
 8163=…
 8164=‥
@@ -159,7 +153,7 @@
 8179=【
 817A=】
 817B=＋
-817C=－
+817C=−
 817D=±
 817E=×
 8180=÷
@@ -179,8 +173,8 @@
 818E=℃
 818F=￥
 8190=＄
-8191=￠
-8192=￡
+8191=¢
+8192=£
 8193=％
 8194=＃
 8195=＆
@@ -193,6 +187,7 @@
 819C=●
 819D=◎
 819E=◇
+819F=◆
 81A0=□
 81A1=■
 81A2=△
@@ -216,7 +211,7 @@
 81BF=∩
 81C8=∧
 81C9=∨
-81CA=￢
+81CA=¬
 81CB=⇒
 81CC=⇔
 81CD=∀
@@ -622,89 +617,6 @@
 84BC=┥
 84BD=┸
 84BE=╂
-8740=①
-8741=②
-8742=③
-8743=④
-8744=⑤
-8745=⑥
-8746=⑦
-8747=⑧
-8748=⑨
-8749=⑩
-874A=⑪
-874B=⑫
-874C=⑬
-874D=⑭
-874E=⑮
-874F=⑯
-8750=⑰
-8751=⑱
-8752=⑲
-8753=⑳
-8754=Ⅰ
-8755=Ⅱ
-8756=Ⅲ
-8757=Ⅳ
-8758=Ⅴ
-8759=Ⅵ
-875A=Ⅶ
-875B=Ⅷ
-875C=Ⅸ
-875D=Ⅹ
-875F=㍉
-8760=㌔
-8761=㌢
-8762=㍍
-8763=㌘
-8764=㌧
-8765=㌃
-8766=㌶
-8767=㍑
-8768=㍗
-8769=㌍
-876A=㌦
-876B=㌣
-876C=㌫
-876D=㍊
-876E=㌻
-876F=㎜
-8770=㎝
-8771=㎞
-8772=㎎
-8773=㎏
-8774=㏄
-8775=㎡
-877E=㍻
-8780=〝
-8781=〟
-8782=№
-8783=㏍
-8784=℡
-8785=㊤
-8786=㊥
-8787=㊦
-8788=㊧
-8789=㊨
-878A=㈱
-878B=㈲
-878C=㈹
-878D=㍾
-878E=㍽
-878F=㍼
-8790=≒
-8791=≡
-8792=∫
-8793=∮
-8794=∑
-8795=√
-8796=⊥
-8797=∠
-8798=∟
-8799=⊿
-879A=∵
-879B=∩
-879C=∪
 889F=亜
 88A0=唖
 88A1=娃
@@ -7123,4 +7035,3 @@ EAA1=遙
 EAA2=瑤
 EAA3=凜
 EAA4=熙
-FA5B=∵
--- a/encodings/utf8.tbl
+++ b/encodings/utf8.tbl
--- a/includes/hex/core.pat
+++ b/includes/hex/core.pat
@@ -2,13 +2,24 @@

 #include <hex/impl/imhex_check.pat>

+/*!
+    Core intrinsic functions to interact with the ImHex Hex Editor
+*/
+
 namespace hex::core {

+    /**
+        A type representing a selection in the hex editor
+    */
    struct Selection {
        bool valid;
        u64 address, size;
    };

+    /**
+        Returns the current selection in the hex editor
+        @return The current selection
+    */
    fn get_selection() {
        u128 result = builtin::hex::core::get_selection();

--- a/includes/hex/dec.pat
+++ b/includes/hex/dec.pat
@@ -2,8 +2,17 @@

 #include <hex/impl/imhex_check.pat>

+/*!
+    Library to allow decoding of more complex values
+*/
+
 namespace hex::dec {

+    /**
+        Demangles a mangled name into a human readable name
+        @param mangled_name The mangled name
+        @return The demangled name
+    */
    fn demangle(str mangled_name) {
        return builtin::hex::dec::demangle(mangled_name);
    };
--- a/includes/hex/http.pat
+++ b/includes/hex/http.pat
@@ -2,8 +2,17 @@

 #include <hex/impl/imhex_check.pat>

+/*!
+    Library to do HTTP requests
+*/
+
 namespace hex::http {

+    /**
+        Performs a HTTP GET request to the given URL and returns the response body
+        @param url URL to perform the request to
+        @return Response body
+    */
    fn get(str url) {
        return builtin::hex::http::get(url);
    };
--- a/includes/hex/provider.pat
+++ b/includes/hex/provider.pat
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <hex/impl/imhex_check.pat>
+
+/*!
+    Library to interact with the currently loaded provider.
+*/
+
+namespace hex::prv {
+    
+    
+    /**
+        Queries information from the currently loaded provider. The kind of information that's available depends on the provider that's loaded
+        
+        > **Available information**
+        > - File Provider
+        >   - `file_path() -> str`
+        >   - `file_name() -> str`
+        >   - `file_extension() -> str`
+        >   - `creation_time() -> time_t`
+        >   - `access_time() -> time_t`
+        >   - `modification_time() -> time_t`
+        >   - `permissions() -> u16`
+        > - Disk Provider
+        >   - `file_path() -> str`
+        >   - `sector_size() -> u128`
+        > - GDB Provider
+        >   - `ip() -> str`
+        >   - `port() -> u16`
+        > - Process Memory Provider
+        >   - `region_address(regionName) -> u64`
+        >   - `region_size(regionName) -> u64`
+        >   - `process_id() -> u32`
+        >   - `process_name() -> str`
+        
+        @param category Information category
+        @param argument Extra argument to pass along
+    */
+    fn get_information(str category, str argument = "") {
+        return builtin::hex::prv::get_information(category, argument);
+    };
+    
+}
--- a/includes/hex/type/mangled.pat
+++ b/includes/hex/type/mangled.pat
@@ -6,8 +6,15 @@
 #include <hex/impl/imhex_check.pat>
 #include <hex/dec.pat>

+/*!
+    Types to automatically decode mangled names
+*/
+
 namespace hex::type {
 	
+    /**
+        A mangled name string that gets demangled when displayed
+    */
    struct MangledName {
        char value[];
    } [[sealed, format("hex::type::impl::format_mangled_name")]];
--- a/includes/std/array.pat
+++ b/includes/std/array.pat
@@ -1,9 +1,19 @@
 #pragma once

+/*!
+    The array library contains a helper type to make it easier to create multi-dimensional arrays
+    and pass arrays to functions as parameters.
+*/
+
 namespace std {

+    /**
+        Simple one dimensional array wrapper
+        @tparam T The array types
+        @tparam Size Size of the array
+    */
    struct Array<T, auto Size> {
        T data[Size] [[inline]];
    };

-}
+}
--- a/includes/std/bit.pat
+++ b/includes/std/bit.pat
@@ -2,8 +2,17 @@

 #include <std/limits.pat>

+/*!
+	This library contains various helper functions for common bit operations.
+*/
+
 namespace std::bit {

+	/**
+		Calculates the number of 1 bits in a given number
+		@param x The number
+		@return The number of bits set to 1 in `x`
+	*/
 	fn popcount(u128 x) {
 		x = (x & (std::limits::u128_max() /  3)) + ((x >> 1) & (std::limits::u128_max() /  3));
 		x = (x & (std::limits::u128_max() /  5)) + ((x >> 2) & (std::limits::u128_max() /  5));
@@ -12,10 +21,20 @@ namespace std::bit {
 		return x % 0xFF;
 	};

+	/**
+		Checks if only a single bit is set to 1 in a given number
+		@param x The number
+		@return True if there's a single bit set to 1 in `x`, false otherwise
+	*/
 	fn has_single_bit(u128 x) {
 		return x != 0 && (x & (x - 1)) == 0;
 	};
 	
+	/**
+		Rounds the given number up to the next bigger power of two
+		@param x The number
+		@return Next bigger power of two that can fit `x`
+	*/
 	fn bit_ceil(u128 x) {		
 		if (x == 0) return 0;
 		
@@ -25,7 +44,12 @@ namespace std::bit {
 		
 		return 1 << i;
 	};
-	
+
+	/**
+		Rounds the given number down to the next bigger power of two
+		@param x The number
+		@return Next smaller power of two
+	*/
 	fn bit_floor(u128 x) {
 		if (x == 0) return 0;
 		
--- a/includes/std/core.pat
+++ b/includes/std/core.pat
@@ -2,59 +2,148 @@

 #include <std/mem.pat>

+/*!
+    The core library contains intrinsics and "compiler magic" functions that
+    get extra help from the runtime to fulfill their purpose.
+*/
+
 namespace std::core {

+    /**
+        The layout order of each field after byte-endianness has been handled.
+
+        `LeftToRight` and `RightToLeft` are deprecated in favor of the clearer `MostToLeastSignificant` and `LeastToMostSignificant` names.
+    */
    enum BitfieldOrder : u8 {
+        /**
+            @warning deprecated
+        */
        LeftToRight = 0,
-        RightToLeft = 1
+        /**
+            @warning deprecated
+        */
+        RightToLeft = 1,
+        MostToLeastSignificant = 0,
+        LeastToMostSignificant = 1
    };


+    /**
+        Checks if a pattern has a specific attribute assigned to it
+        @param pattern The pattern to check
+        @param attribute The attribute's name to check for
+    */
    fn has_attribute(ref auto pattern, str attribute) {
        return builtin::std::core::has_attribute(pattern, attribute);
    };

-
+    /**
+        Returns the first parameter of the attribute of a pattern if it has one
+        @param pattern The pattern to check
+        @param attribute The attribute's name to query
+    */
    fn get_attribute_value(ref auto pattern, str attribute) {
        return builtin::std::core::get_attribute_value(pattern, attribute);
    };


+    /**
+        Sets the current default endianess.
+        Any patterns created following this attribute will be created using the set endianess.
+        @param endian The new default endianess
+    */
    fn set_endian(std::mem::Endian endian) {
        builtin::std::core::set_endian(u32(endian));
    };

+    /**
+        Gets the current default endianess.
+        @return The currently set default endianess
+    */
    fn get_endian() {
        return builtin::std::core::get_endian();
    };

    
+    /**
+        @warning Removed in 1.28.0
+    */
    fn set_bitfield_order(BitfieldOrder order) {
-        builtin::std::core::set_bitfield_order(u32(order));
+        builtin::std::error("Runtime default bitfield order is no longer supported.\nConsider using `be` or `le` on your bitfield variables,\nor attach attribute `bitfield_order` to the bitfield.");
    };

+    /**
+        @warning Removed in 1.28.0
+    */
    fn get_bitfield_order() {
-        return builtin::std::core::get_bitfield_order();
+        builtin::std::error("Runtime default bitfield order is no longer supported.\nConsider using `be` or `le` on your bitfield variables,\nor attach attribute `bitfield_order` to the bitfield.");
    };


+    /**
+        When used inside of a pattern that's being created using a pattern,
+        returns the current array index that's being processed.
+        If used outside of an array, always yields 0.
+        @return The current array index
+    */
    fn array_index() {
        return builtin::std::core::array_index();
    };

+    /**
+        Queries the number of members of a struct, union or bitfield or the number of entries in an array
+        @param pattern The pattern to check
+        @return The number of members in `pattern`
+    */
    fn member_count(ref auto pattern) {
        return builtin::std::core::member_count(pattern);  
    };

+    /**
+        Checks whether or not a given pattern has a member with a given name
+        @param pattern The pattern to check
+        @param name The name of the member to look for
+        @return True if a member called `name` exists, false otherwise
+    */
    fn has_member(ref auto pattern, str name) {
        return builtin::std::core::has_member(pattern, name);  
    };

+    /**
+        Formats a pattern using it's default formatter or its custom formatter function set through
+        the `[[format]]` or `[[format_read]]` attribute
+        @param pattern The pattern to format
+        @return Formatted string representation of `pattern`
+    */
    fn formatted_value(ref auto pattern) {
        return builtin::std::core::formatted_value(pattern);
    };

+    /**
+        Checks if the given enum value corresponds has a corresponding constant
+        @param pattern The enum value to check
+        @return True if pattern has a valid enum representation, false if not
+    */
    fn is_valid_enum(ref auto pattern) {
        return builtin::std::core::is_valid_enum(pattern);
    };
+
+
+    /**
+        Changes the color of the given pattern to a new color
+        @param pattern The pattern to modify
+        @param color The RGBA8 color 
+    */
+    fn set_pattern_color(ref auto pattern, u32 color) {
+        builtin::std::core::set_pattern_color(pattern, color);
+    };
+
+    /**
+        Changes the display name of a given pattern
+        @param pattern The pattern to modify
+        @param name The new display name of the pattern
+    */
+    fn set_display_name(ref auto pattern, str name) {
+        builtin::std::core::set_display_name(pattern, name);
+    }; 
 }
--- a/includes/std/ctype.pat
+++ b/includes/std/ctype.pat
@@ -1,51 +1,116 @@
 #pragma once

+/*!
+    The ctype library has functions to check if a character is part of a specific category
+    of ASCII characters.
+*/
+
 namespace std::ctype {

+    /**
+        Checks if the given character `c` is a digit between '0' and '9'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isdigit(char c) {
        return c >= '0' && c <= '9';
    };

+    /**
+        Checks if the given character `c` is a hexadecimal digit between '0' and '9', `A` and `F` or `a` and `f`
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isxdigit(char c) {
        return std::ctype::isdigit(c) || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
    };

+    /**
+        Checks if the given character `c` is a upper case letter between 'A' and 'Z'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isupper(char c) {
        return c >= 'A' && c <= 'Z';
    };

+    /**
+        Checks if the given character `c` is a lower case letter between 'a' and 'z'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn islower(char c) {
        return c >= 'a' && c <= 'z';
    };

+    /**
+        Checks if the given character `c` is either a upper or lower case letter between 'A' and 'Z' or 'a' and 'z'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isalpha(char c) {
        return std::ctype::isupper(c) || std::ctype::islower(c);
    };

+    /**
+        Checks if the given character `c` is a upper or lower case letter or a number
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isalnum(char c) {
        return std::ctype::isalpha(c) || std::ctype::isdigit(c);
    };

+    /**
+        Checks if the given character `c` is a space character
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isspace(char c) {
        return (c >= 0x09 && c <= 0x0D) || c == 0x20;
    };

+    /**
+        Checks if the given character `c` is a invisible character
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isblank(char c) {
        return c == 0x09 || c == ' ';
    };

+    /**
+        Checks if the given character `c` has a printable glyph
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isprint(char c) {
        return c >= '0' && c <= '~';
    };

+    /**
+        Checks if the given character `c` is a control code
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn iscntrl(char c) {
        return !std::ctype::isprint(c);
    };

+    /**
+        Checks if the given character `c` has a visible glyph
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn isgraph(char c) {
        return std::ctype::isprint(c) && !std::ctype::isspace(c);
    };

+    /**
+        Checks if the given character `c` is a punctuation character
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
    fn ispunct(char c) {
        return std::ctype::isgraph(c) && !std::ctype::isalnum(c);
    };
--- a/includes/std/file.pat
+++ b/includes/std/file.pat
@@ -1,9 +1,25 @@
 #pragma once

+/*!
+	The File library allows reading and writing from/to external files using 
+	a C-like File IO API.
+
+	**These functions are considered dangerous and require the user to manually permit them**
+*/
+
 namespace std::file {

+	/**
+        A handle representing a file that has been opened
+    */
 	using Handle = s32;
 	
+	/**
+        The mode to open a file in.
+		Read opens the file in read-only mode
+		Write opens the file in read and write mode
+		Create creates a new file if it doesn't exist and overwrites an existing file
+    */
 	enum Mode : u8 {
 		Read = 1,
 		Write = 2,
@@ -11,37 +27,84 @@ namespace std::file {
 	};


+	/**
+        Opens a file
+		@param path The path to the file to open
+		@param mode File open mode
+		@return Handle to the newly opened file
+    */
 	fn open(str path, Mode mode) {
 		return builtin::std::file::open(path, u32(mode));
 	};

+	/**
+        Closes a file handle that has been opened previously
+		@param handle The handle to close
+    */
 	fn close(Handle handle) {
 		builtin::std::file::close(handle);
 	};

 	
+	/**
+        Reads the content of a file into a string
+		@param handle The file handle to read from
+		@param size Number of bytes to read
+		@return String containing the read data
+    */
 	fn read(Handle handle, u64 size) {
 		return builtin::std::file::read(handle, size);
 	};

-	fn write(Handle handle, str data) {
-		return builtin::std::file::write(handle, data);
+	/**
+        Writes the content of a string into a file
+		@param handle The file handle to write to
+		@param data String or Pattern to write to the file
+    */
+	fn write(Handle handle, auto data) {
+		builtin::std::file::write(handle, data);
+	};
+
+	/**
+        Sets the current cursor position in the given file handle
+		@param handle The file handle to set the cursor position in
+		@param offset The offset to move the cursor to
+    */
+	fn seek(Handle handle, u64 offset) {
+		builtin::std::file::seek(handle, offset);
 	};


+	/**
+		Queries the size of a file
+		@param handle The handle of the file to get the size of
+		@return The file's size
+	*/
 	fn size(Handle handle) {
 		return builtin::std::file::size(handle);
 	};

+	/**
+		Resizes a file 
+		@param handle The handle of the file to resize
+	*/
 	fn resize(Handle handle, u64 size) {
 		builtin::std::file::resize(handle, size);
 	};

+	/** 
+		Flushes changes made to a file to disk
+		@param handle The handle of the file to flush
+	*/
 	fn flush(Handle handle) {
 		builtin::std::file::remove(handle);
 	};


+	/**
+		Deletes a file from disk. This will also automatically close this file
+		@param handle The handle of the file to delete
+	*/
 	fn remove(Handle handle) {
 		builtin::std::file::remove(handle);
 	};
--- a/includes/std/fxpt.pat
+++ b/includes/std/fxpt.pat
@@ -1,33 +1,87 @@
 #pragma once

+/*!
+	Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
+*/
+
 namespace std::fxpt {

+	/**
+		A fixed point value
+	*/
 	using fixed = s128;

+	/**
+		Converts a fixed point value into a floating point value
+		@param fxt The fixed point value to convert
+		@param precision The bits of precision the new value should have
+		@return The floating point representation of fxt
+	*/
 	fn to_float(fixed fxt, u32 precision) {
 		return double(fxt) / double((1 << precision));
 	};
 	
+	/**
+		Converts a floating point value into a fixed point value
+		@param flt The floating point value to convert
+		@param precision The bits of precision the new value should have
+		@return The fixed point representation of flt
+	*/
 	fn to_fixed(double flt, u32 precision) {
-		return fixed((flt * (1 << precision)));
+		return s128((flt * (1 << precision)));
 	};

+	/**
+		Changes the number of bits used to represent the decimal part of the given fixed point number
+		@param value The fixed point value to convert
+		@param start_precision The current number of bits used
+		@param end_precision The new number of bits used
+		@return `value` as a new fixed point number with `end_precision` bits of precision
+	*/
 	fn change_precision(fixed value, u32 start_precision, u32 end_precision) {
 		return std::fxpt::to_fixed(std::fxpt::to_float(value, start_precision), end_precision);
 	};
 	
+	/**
+		Adds two fixed point numbers with a given precision together
+		@param a First fixed point number
+		@param b Second fixed point number
+		@param precision The precision of `a` and `b`
+		@return Result of the addition of `a` and `b`
+	*/
 	fn add(fixed a, fixed b, u32 precision) {
 		return a + b;
 	};
 	
+	/**
+		Subtracts two fixed point numbers with a given precision together
+		@param a First fixed point number
+		@param b Second fixed point number
+		@param precision The precision of `a` and `b`
+		@return Result of the subtraction of `a` and `b`
+	*/
 	fn subtract(fixed a, fixed b, u32 precision) {
 		return a - b;
 	};
 	
+	/**
+		Multiplies two fixed point numbers with a given precision together
+		@param a First fixed point number
+		@param b Second fixed point number
+		@param precision The precision of `a` and `b`
+		@return Result of the multiplication of `a` and `b`
+	*/
 	fn multiply(fixed a, fixed b, u32 precision) {
 		return (a * b) / (1 << precision);
 	};
 	
+	/**
+		Divides two fixed point numbers with a given precision together
+		@param a First fixed point number
+		@param b Second fixed point number
+		@param precision The precision of `a` and `b`
+		@return Result of the division of `a` and `b`
+	*/
 	fn divide(fixed a, fixed b, u32 precision) {
 		return (a << precision) / b;
 	};
--- a/includes/std/hash.pat
+++ b/includes/std/hash.pat
@@ -1,9 +1,23 @@
 #pragma once

+/*!
+    The hash library contains various data hash functions
+*/
+
 namespace std::hash {

-    fn crc32(ref auto pattern, u32 init, u32 poly) {
-        return builtin::std::hash::crc32(pattern, init, poly);
+    /**
+        Calculates the CRC32 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the crc32 hash of
+        @param init The CRC32 init value
+        @param poly The CRC32 polynomial
+        @param xorout The CRC32 XOR-Out value
+        @param reflect_in Whether or not the input bytes should be reflected
+        @param reflect_out Whether or not the output should be reflected
+        @return Calculated CRC32 hash 
+    */
+    fn crc32(ref auto pattern, u32 init, u32 poly, u32 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc32(pattern, init, poly, xorout, reflect_in, reflect_out);
    };

 }
--- a/includes/std/io.pat
+++ b/includes/std/io.pat
@@ -1,20 +1,45 @@
 #pragma once

+/*!
+    The IO library allows formatting strings and outputting text to the console
+*/
+
 namespace std {

+    /**
+        Formats the given arguments using the format string and prints the result to the console
+        This function uses the C++20 `std::format` or libfmt's `fmt::format` syntax.
+        @param fmt Format string
+        @param args Values to use in the formatting
+    */
    fn print(str fmt, auto ... args) {
        builtin::std::print(fmt, args);
    };

+    /**
+        Formats the given arguments using the format string and returns the result as a string
+        This function uses the C++20 `std::format` or libfmt's `fmt::format` syntax.
+        @param fmt Format string
+        @param args Values to use in the formatting
+        @return The formatted string
+    */
    fn format(str fmt, auto ... args) {
        return builtin::std::format(fmt, args);
    };


+    /**
+        Aborts evaluation of the code immediately and prints a error message to the console
+        @param message The message to print
+    */
    fn error(str message) {
        builtin::std::error(message);
    };

+    /**
+        Prints a warning message to the console
+        @param message The message to print
+    */
    fn warning(str message) {
        builtin::std::warning(message);
    };
--- a/includes/std/limits.pat
+++ b/includes/std/limits.pat
@@ -1,83 +1,167 @@
 #pragma once

+/*!
+	Library to calculate the minimum and maximum values that fit into a given data type
+*/
+
 namespace std::limits {
 	
+	/**
+		Returns the minimum value that can be stored in a `u8`.
+		@return Minimum value
+	*/
 	fn u8_min() {
 		return u8(0);
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `u8`.
+		@return Maximum value
+	*/
 	fn u8_max() {
 		return u8(-1);
 	};

+	/**
+		Returns the minimum value that can be stored in a `s8`.
+		@return Minimum value
+	*/
    fn s8_min() {
 		return -s8((std::limits::u8_max() / 2)) - 1;
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `s8`.
+		@return Maximum value
+	*/
 	fn s8_max() {
 		return s8((std::limits::u8_max() / 2));
 	};

+	/**
+		Returns the minimum value that can be stored in a `u16`.
+		@return Minimum value
+	*/
 	fn u16_min() {
 		return u16(0);
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `u16`.
+		@return Maximum value
+	*/
 	fn u16_max() {
 		return u16(-1);
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `s16`.
+		@return Minimum value
+	*/
 	fn s16_min() {
 		return -s16((std::limits::u16_max() / 2)) - 1;
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `s16`.
+		@return Maximum value
+	*/
 	fn s16_max() {
 		return s16((std::limits::u16_max() / 2));
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `u32`.
+		@return Minimum value
+	*/
 	fn u32_min() {
 		return u32(0);
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `u32`.
+		@return Maximum value
+	*/
 	fn u32_max() {
 		return u32(-1);
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `s32`.
+		@return Minimum value
+	*/
 	fn s32_min() {
 		return -s32((std::limits::u32_max() / 2)) - 1;
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `s32`.
+		@return Maximum value
+	*/
 	fn s32_max() {
 		return s32((std::limits::u32_max() / 2));
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `u64`.
+		@return Minimum value
+	*/
 	fn u64_min() {
 		return u64(0);
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `u64`.
+		@return Maximum value
+	*/
 	fn u64_max() {
 		return u64(-1);
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `s64`.
+		@return Minimum value
+	*/
 	fn s64_min() {
 		return -s64((std::limits::u64_max() / 2)) - 1;
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `s64`.
+		@return Maximum value
+	*/
 	fn s64_max() {
 		return s64((std::limits::u64_max() / 2));
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `u128`.
+		@return Minimum value
+	*/
 	fn u128_min() {
 		return u128(0);
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `u128`.
+		@return Maximum value
+	*/
 	fn u128_max() {
 		return u128(-1);
 	};
 	
+	/**
+		Returns the minimum value that can be stored in a `s128`.
+		@return Minimum value
+	*/
 	fn s128_min() {
 		return -s128((std::limits::u128_max() / 2)) - 1;
 	};
 	
+	/**
+		Returns the maximum value that can be stored in a `s128`.
+		@return Maximum value
+	*/
 	fn s128_max() {
 		return s128((std::limits::u128_max() / 2));
 	};
--- a/includes/std/math.pat
+++ b/includes/std/math.pat
@@ -1,7 +1,19 @@
 #pragma once

+#include <std/mem.pat>
+
+/*!
+	Library containing more advanced mathematical operations.
+*/
+
 namespace std::math {

+	/**
+		Compares the values `a` and `b` with each other and returns the smaller of the two
+		@param a First value
+		@param b Second value
+		@return `a` if `a` is smaller than `b`, otherwise `b`
+	*/
 	fn min(auto a, auto b) {
 		if (a < b)
 			return a;
@@ -9,6 +21,12 @@ namespace std::math {
 			return b;
 	};
 	
+	/**
+		Compares the values `a` and `b` with each other and returns the bigger of the two
+		@param a First value
+		@param b Second value
+		@return `a` if `a` is bigger than `b`, otherwise `b`
+	*/
 	fn max(auto a, auto b) {
 		if (a > b)
 			return a;
@@ -16,6 +34,13 @@ namespace std::math {
 			return b;
 	};

+	/**
+		Clamps the value of `x` between `min` and `max`.
+		@param x Value
+		@param min Minimum value
+		@param max Maximum value
+		@return `min` if `x` is smaller than `min`, `max` if `x` is bigger than `max`, `x` otherwise
+	*/
 	fn clamp(auto x, auto min, auto max) {
 		if (x < min)
 			return min;
@@ -25,6 +50,11 @@ namespace std::math {
 			return x;
 	};

+	/**
+		Returns the absolute value of `x`.
+		@param x Value
+		@return `x` if `x` is positive, `-x` otherwise
+	*/
 	fn abs(auto x) {
 		if (x < 0) 
 			return -x;
@@ -32,6 +62,11 @@ namespace std::math {
 			return x;
 	};

+	/**
+		Returns the sign of `x`.
+		@param x Value
+		@return `1` if `x` is positive, `-1` if `x` is negative, `0` if `x` is zero
+	*/
 	fn sign(auto x) {
 		if (x > 0)
 			return 1;
@@ -41,6 +76,12 @@ namespace std::math {
 			return 0;
 	};

+	/**
+		Copies the sign of `y` to `x`.
+		@param x Value
+		@param y Value
+		@return `x` if `y` is positive, `-x` if `y` is negative
+	*/
 	fn copy_sign(auto x, auto y) {
 		if (y >= 0)
 			return std::math::abs(x);
@@ -48,6 +89,11 @@ namespace std::math {
 			return -std::math::abs(x);
 	};

+	/**
+		Calculates the factorial of `x`.
+		@param x Value
+		@return Factorial of `x`
+	*/
 	fn factorial(u128 x) {
 		u128 result;
 		
@@ -60,6 +106,12 @@ namespace std::math {
 		return result;
 	};

+	/**
+		Calculates the binomial coefficient of `n` and `k`.
+		@param n Value
+		@param k Value
+		@return Binomial coefficient of `n` and `k`
+	*/
 	fn comb(u128 n, u128 k) {
 		if (k > n)
 			return 0;
@@ -67,6 +119,12 @@ namespace std::math {
 			return std::math::factorial(n) / (std::math::factorial(k) * std::math::factorial(n - k));
 	};

+	/**
+		Calculates the permutation of `n` and `k`.
+		@param n Value
+		@param k Value
+		@return Permutation of `n` and `k`
+	*/
 	fn perm(u128 n, u128 k) {
 		if (k > n)
 			return 0;
@@ -74,36 +132,208 @@ namespace std::math {
 			return std::math::factorial(n) / std::math::factorial(n - k);
 	};

-
+	/**
+		Floors the value of `value`.
+		@param value Value
+		@return `value` floored
+	*/
 	fn floor(auto value) { return builtin::std::math::floor(value); };
+
+	/**
+		Ceils the value of `value`.
+		@param value Value
+		@return `value` ceiled
+	*/
 	fn ceil(auto value) { return builtin::std::math::ceil(value); };
+
+	/**
+		Rounds the value of `value`.
+		@param value Value
+		@return `value` rounded
+	*/
 	fn round(auto value) { return builtin::std::math::round(value); };
+
+	/**
+		Truncates the value of `value`.
+		@param value Value
+		@return `value` truncated
+	*/
 	fn trunc(auto value) { return builtin::std::math::trunc(value); };

+
+	/**
+		Calculates the logarithm of `value` with base 10.
+		@param value Value
+		@return Logarithm of `value` with base 10
+	*/
 	fn log10(auto value) { return builtin::std::math::log10(value); };
+
+	/**
+		Calculates the logarithm of `value` with base 2.
+		@param value Value
+		@return Logarithm of `value` with base 2
+	*/
 	fn log2(auto value) { return builtin::std::math::log2(value); };
+
+	/**
+		Calculates the natural logarithm of `value`.
+		@param value Value
+		@return Logarithm of `value` with base `e`
+	*/
 	fn ln(auto value) { return builtin::std::math::ln(value); };

+	/**
+		Calculates the floating point modulus of `value`.
+		@param value Value
+		@return Floating point modulus of `value`
+	*/
 	fn fmod(auto value) { return builtin::std::math::fmod(value); };
+
+	/**
+		Calculates the value of `base` raised to the power of `exp`.
+		@param base Base
+		@param exp Exponent
+		@return `base` raised to the power of `exp`
+	*/
 	fn pow(auto base, auto exp) { return builtin::std::math::pow(base, exp); };
+
+    /**
+		Calculates the value of the natural number `e`	raised to the power of `value`.
+		@param value Exponent
+		@return `e` raised to the power of `value`
+	*/
+    fn exp(auto value) { return builtin::std::math::exp(value); };
+
+	/**
+		Calculates the square root of `value`.
+		@param value Value
+		@return Square root of `value`
+	*/
 	fn sqrt(auto value) { return builtin::std::math::sqrt(value); };
+
+	/**
+		Calculates the cubic root of `value`.
+		@param value Value
+		@return Cubic root of `value`
+	*/
 	fn cbrt(auto value) { return builtin::std::math::cbrt(value); };

+	/**
+		Calculates the sine of `value`.
+		@param value Angle value in radians
+		@return Sine of `value`
+	*/
 	fn sin(auto value) { return builtin::std::math::sin(value); };
+
+	/**
+		Calculates the cosine of `value`.
+		@param value Angle value in radians
+		@return Cosine of `value`
+	*/
 	fn cos(auto value) { return builtin::std::math::cos(value); };
+
+	/**
+		Calculates the tangent of `value`.
+		@param value Angle value in radians
+		@return Tangent of `value`
+	*/
 	fn tan(auto value) { return builtin::std::math::tan(value); };

+	/**
+		Calculates the arc sine of `value`.
+		@param value Angle value in radians
+		@return Arc sine of `value`
+	*/
 	fn asin(auto value) { return builtin::std::math::asin(value); };
+
+	/**
+		Calculates the arc cosine of `value`.
+		@param value Value
+		@return Arc cosine of `value` in radians
+	*/
 	fn acos(auto value) { return builtin::std::math::acos(value); };
+
+	/**
+		Calculates the arc tangent of `value`.
+		@param value Value
+		@return Arc tangent of `value` in radians between `-pi/2` and `pi/2`
+	*/
 	fn atan(auto value) { return builtin::std::math::atan(value); };
+
+	/**
+		Calculates the arc tangent of `value`.
+		@param value Value
+		@return Arc tangent of `value` in radians between `-pi` and `pi`
+	*/
 	fn atan2(auto value) { return builtin::std::math::atan2(value); };

+	/**
+		Calculates the hyperbolic sine of `value`.
+		@param value Angle value in radians
+		@return Hyperbolic sine of `value`
+	*/
 	fn sinh(auto value) { return builtin::std::math::sinh(value); };
+
+	/**
+		Calculates the hyperbolic cosine of `value`.
+		@param value Angle value in radians
+		@return Hyperbolic cosine of `value`
+	*/
 	fn cosh(auto value) { return builtin::std::math::cosh(value); };
+
+	/**
+		Calculates the hyperbolic tangent of `value`.
+		@param value Angle value in radians
+		@return Hyperbolic tangent of `value`
+	*/
 	fn tanh(auto value) { return builtin::std::math::tanh(value); };

+
+	/**
+		Calculates the arc hyperbolic sine of `value`.
+		@param value Value
+		@return Arc hyperbolic sine of `value`
+	*/
 	fn asinh(auto value) { return builtin::std::math::asinh(value); };
+
+	/**
+		Calculates the arc hyperbolic cosine of `value`.
+		@param value Value
+		@return Arc hyperbolic cosine of `value`
+	*/
 	fn acosh(auto value) { return builtin::std::math::acosh(value); };
+
+	/**
+		Calculates the arc hyperbolic tangent of `value`.
+		@param value Value
+		@return Arc hyperbolic tangent of `value`
+	*/
 	fn atanh(auto value) { return builtin::std::math::atanh(value); };
+
+
+	/**
+		Options to use with the `std::math::accumulate` function.
+	*/
+	enum AccumulateOperation : u8 {
+		Add 		= 0,
+		Multiply 	= 1,
+		Modulo 		= 2,
+		Min 		= 3,
+		Max 		= 4
+	};
+
+	/**
+		Calculates the sum of all values in the specified memory range.
+		@param start Start address
+		@param end End address
+		@param valueSize Size of each value in bytes
+		@param section Section to use
+		@param operation Operation to use
+		@param endian Endianness to use
+		@return Sum of all values in the specified memory range
+	*/
+	fn accumulate(u128 start, u128 end, u128 valueSize, std::mem::Section section = 0, AccumulateOperation operation = AccumulateOperation::Add, std::mem::Endian endian = std::mem::Endian::Native) {
+		return builtin::std::math::accumulate(start, end, valueSize, section, u128(operation), u128(endian));
+	};
 	
 }
--- a/includes/std/mem.pat
+++ b/includes/std/mem.pat
@@ -1,19 +1,40 @@
 #pragma once

+/*!
+    Library for doing raw memory accesses and other low-level operations.
+*/
+
 namespace std::mem {
  
+    /**
+        A Handle for a custom Section
+     */
    using Section = u128;

+    /**
+        The Endianess of a value
+     */
    enum Endian : u8 {
        Native  = 0,
        Big     = 1,
        Little  = 2
    };

+    /**
+        Function that returns true if the cursor position is at the end of the memory
+        This is usually used in while-sized arrays in the form of `u8 array[while(!std::mem::eof())]`
+        @return True if the cursor is at the end of the memory
+     */
    fn eof() {
        return $ >= std::mem::size();
    };

+    /**
+        Aligns the given value to the given alignment
+        @param alignment The alignment to align to
+        @param value The value to align
+        @return The aligned value
+    */
    fn align_to(u128 alignment, u128 value) {
        u128 remainder = value % alignment;

@@ -21,57 +42,152 @@ namespace std::mem {
    };
  

+    /**
+        Gets the base address of the memory
+        @return The base address of the memory
+     */
    fn base_address() {
        return builtin::std::mem::base_address();
    };

+    /**
+        Gets the size of the memory
+        @return The size of the memory
+     */
    fn size() {
        return builtin::std::mem::size();
    };

+    /**
+        Finds a sequence of bytes in the memory
+        @param occurrence_index The index of the occurrence to find
+        @param bytes The bytes to find
+        @return The address of the sequence
+    */
    fn find_sequence(u128 occurrence_index, auto ... bytes) {
        return builtin::std::mem::find_sequence_in_range(occurrence_index, builtin::std::mem::base_address(), builtin::std::mem::size(), bytes);
    };

+    /**
+        Finds a sequence of bytes in a specific region of the memory
+        @param occurrence_index The index of the occurrence to find
+        @param offsetFrom The offset from which to start searching
+        @param offsetTo The offset to which to search
+        @param bytes The bytes to find
+        @return The address of the sequence
+    */
    fn find_sequence_in_range(u128 occurrence_index, u128 offsetFrom, u128 offsetTo, auto ... bytes) {
        return builtin::std::mem::find_sequence_in_range(occurrence_index, offsetFrom, offsetTo, bytes);
    };

+    /**
+        Reads a unsigned value from the memory
+        @param address The address to read from
+        @param size The size of the value to read
+        @param endian The endianess of the value to read
+        @return The value read
+    */
    fn read_unsigned(u128 address, u8 size, Endian endian = Endian::Native) {
        return builtin::std::mem::read_unsigned(address, size, u32(endian));
    };

+    /**
+        Reads a signed value from the memory
+        @param address The address to read from
+        @param size The size of the value to read
+        @param endian The endianess of the value to read
+        @return The value read
+    */
    fn read_signed(u128 address, u8 size, Endian endian = Endian::Native) {
        return builtin::std::mem::read_signed(address, size, u32(endian));
    };

+    /**
+        Reads a string value from the memory
+        @param address The address to read from
+        @param size The size of the value to read
+        @return The value read
+    */
    fn read_string(u128 address, u8 size) {
        return builtin::std::mem::read_string(address, size);
    };


+    /**
+        Gets the current bit offset within the current byte that a bitfield will read.
+    */
+    fn current_bit_offset() {
+        return builtin::std::mem::current_bit_offset();
+    };
+
+    /**
+        Reads a number of bits from the specified bit offset within the specified byte
+        @param byteOffset The byte offset within the data
+        @param bitOffset The bit offset to start the read at within the current byte
+        @param bitSize The total number of bits to read
+        @return A u128 containing the value read
+    */
+    fn read_bits(u128 byteOffset, u128 bitOffset, u64 bitSize) {
+        byteOffset += bitOffset >> 3;
+        bitOffset = bitOffset & 0x7;
+        return builtin::std::mem::read_bits(byteOffset, bitOffset, bitSize);
+    };
+
+
+    /**
+        Creates a new custom section with the given name
+        @param name The name of the section
+        @return The handle to the section
+    */
    fn create_section(str name) {
        return builtin::std::mem::create_section(name);
    };

+    /**
+        Deletes a custom section
+        @param section The handle to the section
+    */
    fn delete_section(Section section) {
        builtin::std::mem::delete_section(section);
    };

+    /**
+        Gets the size of a custom section
+        @param section The handle to the section
+        @return The size of the section
+    */
    fn get_section_size(Section section) {
        return builtin::std::mem::get_section_size(section);
    };

+    /**
+        Copies a range of bytes from one section into another
+        @param from_section The section to copy from
+        @param from_address The address to copy from
+        @param to_section The section to copy to
+        @param to_address The address to copy to
+        @param size The size of the range to copy
+    */
    fn copy_section_to_section(Section from_section, u64 from_address, Section to_section, u64 to_address, u64 size) {
        builtin::std::mem::copy_to_section(from_section, from_address, to_section, to_address, size);
    };

+    /**
+        Copies a range of bytes from the main section into a custom section
+        @param value The pattern whose bytes should be copied
+        @param to_section The section to copy to
+        @param to_address The address to copy to
+    */
    fn copy_value_to_section(ref auto value, Section to_section, u64 to_address) {
        builtin::std::mem::copy_value_to_section(value, to_section, to_address);
    };


-
+    /**
+        Searches for a sequence of bytes and places the given type at that address
+        @tparam Magic The magic sequence to search for
+        @tparam T The type to place at the address
+    */
    struct MagicSearch<auto Magic, T> {
        if ($ < (std::mem::size() - std::string::length(Magic) - 1)) {
            char __potentialMagic__[std::string::length(Magic)] [[hidden, no_unique_address]];
@@ -88,13 +204,39 @@ namespace std::mem {
        }
    };

+    /**
+        Reinterprets a value as a different one
+        @tparam From The type to reinterpret from
+        @tparam To The type to reinterpret to
+    */
    union Reinterpreter<From, To> {
        From from;
        To to;
    };
  
+
+    /**
+        Aligns the cursor to the given alignment
+        @tparam alignment The alignment to align to
+    */
    struct AlignTo<auto Alignment> {
        padding[Alignment - ((($ - 1) % Alignment) + 1)];
    } [[hidden, sealed]];

+    /**
+        A type representing a sequence of bytes without any specific meaning
+        @tparam Size The size of the sequence
+    */
+    struct Bytes<auto Size> {
+        u8 bytes[Size];
+    } [[sealed, format("std::mem::impl::format_bytes")]];
+
+    namespace impl {
+      
+        fn format_bytes(auto bytes) {
+            return "";
+        };
+      
+    }
+
 }
--- a/includes/std/ptr.pat
+++ b/includes/std/ptr.pat
@@ -1,17 +1,67 @@
 #pragma once

+/*!
+    The Pointer library contains helper functions to deal with pointer types.
+    The `relative_to` functions are meant to be used with the `[[pointer_base]]` attribute
+*/
+
 namespace std::ptr {

+    /**
+        Use the offset of the current pointer as start address
+        @param offset The pointer's value
+        @return The new pointer base
+    */
    fn relative_to_pointer(u128 offset) {
        return $;
    };

+    /**
+        Use the offset of the pointer's parent as start address
+        @param offset The pointer's value
+        @return The new pointer base
+    */
    fn relative_to_parent(u128 offset) {
        return addressof(parent);
    };

+    /**
+        Use the end of the file as pointer base address and use its value as offset backwards from there
+        @param offset The pointer's value
+        @return The new pointer base
+    */
    fn relative_to_end(u128 offset) {
        return std::mem::size() - offset * 2;
    };

+    /**
+    A nullable pointer, generic over both the pointee type and pointer type.
+
+    By nullable, we mean that if the pointer's value is zero (`0x0`), then the
+    value will appear as padding rather than a pointer to something, but
+    if the pointer's value is non-zero, that non-zero value will be treated as
+    a pointer of type `PointerTy` which points to an element of type `PointeeTy`.
+
+    Example:
+    A struct field called `p_myInfo` which is a nullable 64-bit pointer to an
+    element of type `MyInfoTy` would be written as:
+    ```
+    struct MyStruct {
+      std::ptr::NullablePtr<MyInfoTy, u64> p_myInfo;
+    }
+    ```
+    */
+    struct NullablePtr<PointeeTy, PointerTy> {
+        // `pointerValue` is `no_unique_address` because we don't want to advance
+        // the current memory location after reading the value of the pointer itself;
+        // we want to examine the value at this address to determine what should be
+        // displayed. It's also `hidden` so the editor only displays either thee 
+        // padding or the populated pointer/pointee field.
+        PointerTy pointerValue [[no_unique_address, hidden]];
+        if (pointerValue == 0x0) {
+            padding[sizeof(PointerTy)];
+        } else {
+            PointeeTy *data : PointerTy;
+        }
+    };
 }
--- a/includes/std/random.pat
+++ b/includes/std/random.pat
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <std/limits.pat>
+
+/*!
+  Library to generate random numbers. Supports various different distribution types.
+*/
+
+namespace std::random {
+  
+    /**
+        Represents the type of distribution to use to generate a random number
+    */
+    enum Distribution : u8 {
+        Uniform           = 0,
+        Normal            = 1,
+        Exponential       = 2,
+        Gamma             = 3,
+        Weibull           = 4,
+        ExtremeValue      = 5,
+        ChiSquared        = 6,
+        Cauchy            = 7,
+        FisherF           = 8,
+        StudentT          = 9,
+        LogNormal         = 10,
+        Bernoulli         = 11,
+        Binomial          = 12,
+        NegativeBinomial  = 13,
+        Geometric         = 14,
+        Poisson           = 15
+    };
+
+    /**
+        Sets the seed of the random number generator
+        @param seed Seed to use
+    */
+    fn set_seed(u64 seed) {
+        builtin::std::random::set_seed(seed);
+    };
+
+    /**
+        Generates a random number using the given distribution with the given parameters.
+        The random number generator used internally is C++'s std::mt19937_64 Mersenne Twister implementation.
+
+        > **Distributions**
+        > - `Uniform(min, max) -> i128`
+        > - `Normal(mean, stddev) -> double`
+        > - `Exponential(lambda) -> double`
+        > - `Gamma(alpha, beta) -> double`
+        > - `Weibull(a, b) -> double`
+        > - `ExtremeValue(a, b) -> double`
+        > - `ChiSquared(n) -> double`
+        > - `Cauchy(a, b) -> double`
+        > - `FisherF(m, n) -> double`
+        > - `StudentT(n) -> double`
+        > - `LogNormal(m, s) -> double`
+        > - `Bernoulli(p) -> bool`
+        > - `Binomial(t, p) -> i128`
+        > - `NegativeBinomial(k, p) -> i128`
+        > - `Geometric(p) -> i128`
+        > - `Poisson(mean) -> i128`
+
+        @param distribution Distribution to use
+        @param param1 This parameter depends on the type of distribution used.
+        @param param2 This parameter depends on the type of distribution used.
+    */
+    fn generate_using(Distribution distribution, auto param1 = 0, auto param2 = 0) {
+        return builtin::std::random::generate(u32(distribution), param1, param2);
+    };
+
+    
+    /**
+        Generates a uniformly distributed random number between `min` and `max`
+        @param min Minimum number
+        @param max Maximum number
+    */
+    fn generate(u64 min = std::limits::u64_min(), u64 max = std::limits::u64_max()) {
+        return std::random::generate_using(Distribution::Uniform, min, max);
+    };
+  
+}
--- a/includes/std/string.pat
+++ b/includes/std/string.pat
@@ -2,14 +2,32 @@

 #include <std/io.pat>

+/*!
+	Libray to interact with strings.
+*/
+
 namespace std::string {

+	/**
+	    Base type for sized strings. Represents a string with its size preceeding it.
+		@tparam SizeType The type of the size field.
+		@tparam DataType The type of the characters.
+	*/
 	struct SizedStringBase<SizeType, DataType> {
 		SizeType size;
 		DataType data[size];
 	} [[sealed, format("std::string::impl::format_sized_string"), transform("std::string::impl::format_sized_string")]];

+	/**
+	    A ASCII string with a prefixed size.
+		@tparam SizeType The type of the size field.
+	*/
 	using SizedString<SizeType> = SizedStringBase<SizeType, char>;
+
+	/**
+	    A UTF-16 string with a prefixed size.
+		@tparam SizeType The type of the size field.
+	*/
 	using SizedString16<SizeType> = SizedStringBase<SizeType, char16>;

 	namespace impl {
@@ -20,52 +38,109 @@ namespace std::string {

 	}

+	/**
+		Gets the length of a string.
+		@param string The string to get the length of.
+		@return The length of the string.
+	*/
 	fn length(str string) {
 		return builtin::std::string::length(string);
 	};

+	/**
+		Gets the character at a given index.
+		@param string The string to get the character from.
+		@param index The index of the character to get.
+		@return The character at the given index.
+	*/
 	fn at(str string, u32 index) {
 		return builtin::std::string::at(string, index);
 	};

+	/**
+		Gets a substring of a string.
+		@param string The string to get the substring from.
+		@param pos The position of the first character of the substring.
+		@param count The number of characters to get.
+		@return The substring.
+	*/
 	fn substr(str string, u32 pos, u32 count) {
 		return builtin::std::string::substr(string, pos, count);
 	};


+	/**
+		Converts a string to an integer.
+		@param string The string to convert.
+		@param base The base of the number.
+		@return The integer.
+	*/
 	fn parse_int(str string, u8 base) {
 		return builtin::std::string::parse_int(string, base);
 	};

+	/**
+		Converts a string to a float.
+		@param string The string to convert.
+		@return The float.
+	*/
 	fn parse_float(str string) {
 		return builtin::std::string::parse_float(string);
 	};


+	/**
+		Converts any type to a string.
+		@param x The value to convert.
+		@return The string.
+	*/
    fn to_string(auto x) {
        return std::format("{}", x);
    };

+	/**
+		Checks if a string starts with a given substring.
+		@param string The string to check.
+		@param part The substring to check for.
+		@return True if the string starts with the substring, false otherwise.
+	*/
    fn starts_with(str string, str part) {
        return std::string::substr(string, 0, std::string::length(part)) == part;
    };

+	/**
+		Checks if a string ends with a given substring.
+		@param string The string to check.
+		@param part The substring to check for.
+		@return True if the string ends with the substring, false otherwise.
+	*/
    fn ends_with(str string, str part) {
        return std::string::substr(string, std::string::length(string) - std::string::length(part), std::string::length(part)) == part;
    };

-    fn contains(str a, str b) {
-        s32 a_len = std::string::length(a);
-        s32 b_len = std::string::length(b);
+	/**
+		Checks if a string contains a given substring.
+		@param string The string to check.
+		@param part The substring to check for.
+		@return True if the string contains the substring, false otherwise.
+	*/
+    fn contains(str string, str part) {
+        s32 string_len = std::string::length(string);
+        s32 part_len = std::string::length(part);

-        for (s32 i = 0, i <= (a_len - b_len), i += 1) {
-            if (std::string::substr(a, i, b_len) == b)
+        for (s32 i = 0, i <= (string_len - part_len), i += 1) {
+            if (std::string::substr(string, i, part_len) == part)
                return true;
        }

        return false;
    };

+	/**
+		Reverses a string.
+		@param string The string to reverse.
+		@return The reversed string.
+	*/
    fn reverse(str string) {	
        str result;
        
@@ -79,6 +154,11 @@ namespace std::string {
        return result;
    };

+	/**
+		Converts a string to upper case.
+		@param string The string to convert.
+		@return The converted string.
+	*/
    fn to_upper(str string) {
 		str result;
 		
@@ -98,6 +178,11 @@ namespace std::string {
 		return result;
 	};
 	
+	/**
+		Converts a string to lower case.
+		@param string The string to convert.
+		@return The converted string.
+	*/
 	fn to_lower(str string) {
 		str result;
 		
@@ -117,6 +202,13 @@ namespace std::string {
 		return result;
 	};

+	/**
+		Replaces all occurrences of a substring with another substring.
+		@param string The string to replace in.
+		@param pattern The substring to replace.
+		@param replace The substring to replace with.
+		@return The string with the replacements.
+	*/
    fn replace(str string, str pattern, str replace) {
    	u32 string_len, pattern_len, replace_len;
 		string_len  = std::string::length(string);
--- a/includes/std/sys.pat
+++ b/includes/std/sys.pat
@@ -2,14 +2,28 @@

 #include <std/io.pat>

+/*!
+    Basic helper functions
+*/
+
 namespace std {

+    /**
+        Asserts that a given value is true. If it's not, abort evaluation and print the given message to the console
+        @param conditoon The condition that is required to be true
+        @param message The message to print in case the assertion doesn't hold
+    */
    fn assert(bool condition, str message) {
        if (!condition) {
            std::error(std::format("assertion failed '{0}'", message));
        }
    };

+    /**
+        Asserts that a given value is true. If it's not, print the given message to the console as a warning
+        @param conditoon The condition that is required to be true
+        @param message The message to print in case the assertion doesn't hold
+    */
    fn assert_warn(bool condition, str message) {
        if (!condition) {
            std::warning(std::format("assertion failed '{0}'", message));
@@ -17,10 +31,20 @@ namespace std {
    };


+    /**
+        Queries the value of a set environment variable given it's name
+        @param name The name of the env variable
+        @return The value of that variable
+    */
    fn env(str name) {
        return builtin::std::env(name);
    };

+    /**
+        Returns the number of parameters in a parameter pack.
+        @param pack The pack to check
+        @return Number of parameters in `pack`
+    */
    fn sizeof_pack(auto ... pack) {
        return builtin::std::sizeof_pack(pack);
    };
--- a/includes/std/time.pat
+++ b/includes/std/time.pat
@@ -2,8 +2,15 @@

 #include <std/io.pat>

+/*!
+	Library to handle time and date related operations.
+*/
+
 namespace std::time {

+	/**
+		A structured representation of a time and date.
+	*/
 	struct Time {
 		u8 sec;
 		u8 min;
@@ -16,24 +23,39 @@ namespace std::time {
 		bool isdst;
 	} [[sealed]];

+	/**
+		A helper type to convert between Time and u128.
+	*/
 	union TimeConverter {
 		Time time;
 		u128 value;
 	};

+	/**
+		A type to represent a time in seconds since the epoch.
+	*/
 	using EpochTime = u128;

+	/**
+		A type to represent a time zone.
+	*/
 	enum TimeZone : u8 {
 		Local,
 		UTC
 	};

+	/**
+		A type to represent a DOS date.
+	*/
 	bitfield DOSDate {
 		day: 5;
 		month: 4;
 		year: 7;
 	} [[sealed]];

+	/**
+		A type to represent a DOS time.
+	*/
 	bitfield DOSTime {
 		seconds: 5;
 		minutes: 6;
@@ -54,10 +76,20 @@ namespace std::time {

 	}

+
+	/**
+		Returns the current time in seconds since the epoch.
+		@return The current time in seconds since the epoch.
+	*/
 	fn epoch() {
 		return builtin::std::time::epoch();
 	};

+	/**
+		Converts a time in seconds since the epoch to a local time.
+		@param epoch_time The time in seconds since the epoch.
+		@return The local time.
+	*/
 	fn to_local(EpochTime epoch_time) {
 		TimeConverter converter;

@@ -66,6 +98,11 @@ namespace std::time {
 		return converter.time;
 	};

+	/**
+		Converts a time in seconds since the epoch to a UTC time.
+		@param epoch_time The time in seconds since the epoch.
+		@return The UTC time.
+	*/
 	fn to_utc(EpochTime epoch_time) {
 		TimeConverter converter;

@@ -74,6 +111,11 @@ namespace std::time {
 		return converter.time;
 	};

+	/**
+		Queries the current time in the specified time zone.
+		@param time_zone The time zone to query.
+		@return The current time in the specified time zone.
+	*/
 	fn now(TimeZone time_zone = TimeZone::Local) {
 		TimeConverter converter;

@@ -87,6 +129,11 @@ namespace std::time {
 		return converter.time;
 	};

+	/**
+		Converts a value to a DOS date.
+		@param value The value to convert.
+		@return The DOS date.
+	*/
 	fn to_dos_date(u16 value) {
 		impl::DOSDateConverter converter;

@@ -95,6 +142,11 @@ namespace std::time {
 		return converter.date;
 	};

+	/**
+		Converts a value to a DOS time.
+		@param value The value to convert.
+		@return The DOS time.
+	*/
 	fn to_dos_time(u16 value) {
 		impl::DOSTimeConverter converter;

@@ -103,6 +155,12 @@ namespace std::time {
 		return converter.time;
 	};

+	/**
+		Formats a time according to the specified format string.
+		@param time The time to format.
+		@param format_string The format string to use.
+		@return The formatted time.
+	*/
 	fn format(Time time, str format_string = "%c") {
 		TimeConverter converter;
 		converter.time = time;
@@ -110,10 +168,22 @@ namespace std::time {
 		return builtin::std::time::format(format_string, converter.value);
 	};

+	/**
+		Formats a DOS date according to the specified format string.
+		@param date The DOS date to format.
+		@param format_string The format string to use.
+		@return The formatted DOS date.
+	*/
 	fn format_dos_date(DOSDate date, str format_string = "{}/{}/{}") {
 		return std::format(format_string, date.day, date.month, date.year + 1980);
 	};

+	/**
+		Formats a DOS time according to the specified format string.
+		@param time The DOS time to format.
+		@param format_string The format string to use.
+		@return The formatted DOS time.
+	*/
 	fn format_dos_time(DOSTime time, str format_string = "{:02}:{:02}:{:02}") {
 		return std::format(format_string, time.hours, time.minutes, time.seconds * 2);
 	};
--- a/includes/type/base.pat
+++ b/includes/type/base.pat
@@ -3,11 +3,35 @@
 #include <std/io.pat>
 #include <std/math.pat>

+/*!
+    Types used to change the base of the displayed integer value.
+    Used like `type::Hex<u32> hexNumber;`, `type::Oct<u16> octalNumber;`
+*/
+
 namespace type {
    
+    /**
+        Integer type representing a Hexadecimal value. Displays its value in hexadecimal format.
+        @tparam T Integer type to use
+    */
    using Hex<T> = T [[format("type::impl::format_hex")]];
+
+    /**
+        Integer type representing a Octal value. Displays its value in octal format.
+        @tparam T Integer type to use
+    */
    using Oct<T> = T [[format("type::impl::format_oct")]];
+
+    /**
+        Integer type representing a Decimal value. Displays its value in decimal format.
+        @tparam T Integer type to use
+    */
    using Dec<T> = T [[format("type::impl::format_dec")]];
+
+    /**
+        Integer type representing a Binary value. Displays its value in binary format.
+        @tparam T Integer type to use
+    */
    using Bin<T> = T [[format("type::impl::format_bin")]];

 	namespace impl {
--- a/includes/type/base64.pat
+++ b/includes/type/base64.pat
@@ -0,0 +1,63 @@
+#include <std/io.pat>
+#include <std/string.pat>
+#include <std/mem.pat>
+
+/*!
+    Type representing a Base64 encoded string
+*/
+
+namespace type {
+
+    /**
+        Type representing a Base64 encoded string
+        @tparam T String type
+    */
+    struct Base64<T> {
+        T string;
+    } [[sealed, format("type::impl::transform_base64")]];
+
+    namespace impl {
+
+        fn get_decoded_value(char c) {
+            if (c >= 'A' && c <= 'Z') return c - 'A';
+            if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+            if (c >= '0' && c <= '9') return c - '0' + 52;
+            if (c == '+') return 62;
+            if (c == '/') return 63;
+            return -1; // Invalid character
+        };
+
+        fn decode_base64(str input) {
+            u64 inputLength = std::string::length(input);
+            str result;
+
+            s32 val = 0;
+            s32 bits = -8;
+            for (u32 i = 0, i < inputLength, i += 1) {
+                char c = input[i];
+                if (c == '=')
+                    break;
+
+                s32 index = type::impl::get_decoded_value(c);
+                if (index == -1)
+                    continue;
+
+                val = (val << 6) + index;
+                bits += 6;
+
+                if (bits >= 0) {
+                    result += char((val >> bits) & 0xFF);
+                    bits -= 8;
+                }
+            }
+
+            return result;
+        };
+
+        fn transform_base64(ref auto base64) {
+            return type::impl::decode_base64(base64.string);
+        };
+
+    }
+
+}
--- a/includes/type/bcd.pat
+++ b/includes/type/bcd.pat
@@ -2,8 +2,16 @@

 #include <std/io.pat>

+/*!
+    Type to decode a BCD (Binary Coded Decimal) number
+*/
+
 namespace type {

+    /**
+        Decodes a BCD value where one byte represents a single digit
+        @tparam Digits Number of digits
+    */
    struct BCD<auto Digits> {
        u8 bytes[Digits];
    } [[sealed, format_read("type::impl::format_bcd")]];
--- a/includes/type/byte.pat
+++ b/includes/type/byte.pat
@@ -2,8 +2,15 @@

 #include <std/io.pat>

+/*!
+    Types to display single bytes using various different representations
+*/
+
 namespace type {
    
+    /**
+        Type visualizing the value of each individual bit
+    */
    bitfield Bits {
        bit0 : 1;
        bit1 : 1;
@@ -15,11 +22,17 @@ namespace type {
        bit7 : 1;
    } [[format("type::impl::format_bits"), right_to_left]];
    
+    /**
+        Type visualizing the value of the two nibbles
+    */
    bitfield Nibbles {
        low  : 4;
        high : 4;
    } [[format("type::impl::format_nibbles")]];
    
+    /**
+        Type representing a single Byte. Decodes the byte as it's hexadeicmal value, individual bits and nibbles
+    */
    union Byte {
        u8 value;
        Bits bits;
--- a/includes/type/color.pat
+++ b/includes/type/color.pat
@@ -3,28 +3,60 @@
 #include <std/io.pat>
 #include <std/core.pat>

+/*!
+    Types representing RGB or RGBA colors. The decoded color will be displayed in their color field
+*/
+
 namespace type {

-    struct RGB8 {
-        u8 r, g, b;
-    } [[sealed, format("type::impl::format_color")]];
+    /**
+        Type representing a generic RGBA color with a variable number of bits for each color
+        @tparam R Number of bits used for the red component
+        @tparam G Number of bits used for the green component
+        @tparam B Number of bits used for the blue component
+        @tparam A Number of bits used for the alpha component 
+    */
+    bitfield RGBA<auto R, auto G, auto B, auto A> {
+        r : R;
+        g : G;
+        b : B;
+        if (A > 0) a : A;
+    } [[sealed, format("type::impl::format_color"), color(std::format("{0:02X}{1:02X}{2:02X}FF", r, g, b))]];
+    
+    /**
+        Type representing a generic RGB color with a variable number of bits for each color
+        @tparam R Number of bits used for the red component
+        @tparam G Number of bits used for the green component
+        @tparam B Number of bits used for the blue component
+    */
+    using RGB<auto R, auto G, auto B> = RGBA<R,G,B,0>;
+    

-    struct RGBA8 {
-        u8 r, g, b, a;
-    } [[sealed, format("type::impl::format_color")]];
+    /**
+        Type representing a RGBA color with 8 bits for the red component, 8 bits for green, 8 bits for blue and 8 bits for alpha
+    */
+    using RGBA8    = RGBA<8,8,8,8>;

-    bitfield RGB565 {
-        r : 5;
-        g : 6;
-        b : 5;
-    } [[sealed, format("type::impl::format_color")]];
+    /**
+        Type representing a RGB color with 8 bits for the red component, 8 bits for green and 8 bits for blue
+    */
+    using RGB8     = RGB<8,8,8>;

-    bitfield RGBA4 {
-        r : 4;
-        g : 4;
-        b : 4;
-        a : 4;
-    } [[sealed, format("type::impl::format_color")]];
+    /**
+        Type representing a RGB color with 5 bits for the red component, 6 bits for green and 5 bits for blue
+    */
+    using RGB565   = RGB<5,6,5>;
+
+    /**
+        Type representing a RGBA color with 4 bits for the red component, 4 bits for green, 4 bits for blue and 4 bits for alpha
+    */
+    using RGB4444  = RGBA<4,4,4,4>;
+
+    /**
+        Type representing a RGBA color with 5 bits for the red component, 5 bits for green, 5 bits for blue and 1 bits for alpha
+    */
+    using RGBA5551 = RGBA<5,5,5,1>;
+    

    namespace impl {

@@ -44,5 +76,5 @@ namespace type {
        };

    }
-
-}
+    
+}
--- a/includes/type/float16.pat
+++ b/includes/type/float16.pat
@@ -4,8 +4,15 @@
 #include <std/math.pat>
 #include <std/mem.pat>

+/*!
+    Type representing a 16 bit half precision floating point number
+*/
+
 namespace type {
    
+    /**
+        Type representing a 16 bit half precision floating point number
+    */
    using float16 = u16 [[format("type::impl::format_float16")]];

    namespace impl {
--- a/includes/type/guid.pat
+++ b/includes/type/guid.pat
@@ -2,8 +2,15 @@

 #include <std/io.pat>

+/*!
+	Types to deal with UUIDs (Universally Unique Identifiers) / GUIDs (Globally Unique Identifiers) as described in RFC 4122
+*/
+
 namespace type {

+	/**
+		Type representing a GUID value
+	*/
 	struct GUID {
        u32 time_low;
        u16 time_mid;
@@ -13,6 +20,11 @@ namespace type {
        u8 node[6];
    } [[sealed, format("type::impl::format_guid")]];

+	/**
+		Alias name for GUID
+	*/
+	using UUID = GUID;
+
 	namespace impl {

 		fn format_guid(GUID guid) {
--- a/includes/type/ip.pat
+++ b/includes/type/ip.pat
@@ -1,19 +1,30 @@
 #pragma once

 #include <std/io.pat>
+#include <std/string.pat>
+
+/*!
+    Types used to decode IP addresses
+*/

 namespace type {

+    /**
+        A 4 byte IPv4 Address as described in RFC 791
+    */
    struct IPv4Address {
        u8 bytes[4];
    } [[sealed, format("type::impl::format_ipv4_address")]];

+    /**
+        A 16 byte IPv6 Address as described in RFC 8200
+    */
    struct IPv6Address {
-        u16 words[8];
+        be u16 words[8];
    } [[sealed, format("type::impl::format_ipv6_address")]];
-                        
+
    namespace impl {
-                
+
        fn format_ipv4_address(IPv4Address address) {
            return std::format("{}.{}.{}.{}",
                address.bytes[0],
@@ -24,33 +35,33 @@ namespace type {

        fn format_ipv6_address(IPv6Address address) {
            str result;
-            
+
            bool hadZeros = false;
            s8 startIndex = -1;
-            
+
            for (u8 i = 0, i < 8, i += 1) {
                if (address.words[i] == 0x00 && !hadZeros) {
                    hadZeros = true;
                    startIndex = i;
-                    
+
                    while (i < 7) {
                        if (address.words[i + 1] != 0x00)
                            break;
                        i += 1;
                    }
-                    
+
                    if (startIndex == 0 || i == 7)
                        result += ":";
                } else {
-                    result += std::format("{:04X}", address.words[i]);
+                    result += std::format("{:X}", address.words[i]);
                }
-                
+
                result += ":";
            }
-            
+
            return std::string::substr(result, 0, std::string::length(result) - 1);
        };
-                
+
    }

 }
--- a/includes/type/leb128.pat
+++ b/includes/type/leb128.pat
@@ -3,31 +3,70 @@
 #include <std/io.pat>
 #include <std/mem.pat>

+/*!
+	Types used to decode Little Endian Base 128 numbers used to store large numbers as space efficiently as possible
+*/
+
 namespace type {
 	
-	struct LEB128 {
+	/**
+		Base LEB128 type. Use `uLEB128` and `sLEB128` instead.
+	*/
+	struct LEB128Base {
 		u8 array[while($ == addressof(this) || std::mem::read_unsigned($-1, 1) & 0x80 != 0)] [[hidden]];
-	} [[sealed, format("type::impl::format_leb128"), transform("type::impl::transform_leb128")]];
+	} [[sealed]];
+
+	/**
+		A unsigned variant of a LEB128 number
+	*/
+	using uLEB128 = LEB128Base [[format("type::impl::format_uleb128"), transform("type::impl::transform_uleb128")]];
+
+	/**
+		A signed variant of a LEB128 number
+	*/
+	using sLEB128 = LEB128Base [[format("type::impl::format_sleb128"), transform("type::impl::transform_sleb128")]];
+
+	/**
+		Legacy alias for uLEB128
+	*/
+	using LEB128 = uLEB128;
 	
 	namespace impl {
 	
-		fn transform_leb128_array(auto array) {
+		fn transform_uleb128_array(ref auto array) {
 			u128 res = array[0] & 0x7f;
 			for(u8 i = 1, array[i-1] & 0x80 != 0, i+=1) {
-				res |= u64(array[i] & 0x7f) << 7 * i;
+				res |= u128(array[i] & 0x7f) << 7 * i;
+			}
+			return res;
+		};
+
+		fn transform_sleb128_array(ref auto array) {			
+			s128 res = type::impl::transform_uleb128_array(array);
+			if (res & 0x40 != 0) {
+				res |= ~0 << (sizeof(array) / sizeof(u8)) * 7;
 			}
 			return res;
 		};
 		
-		fn format_leb128(auto leb128) {
-			u128 res = type::impl::transform_leb128_array(leb128.array);
+		fn format_uleb128(ref auto leb128) {
+			u128 res = type::impl::transform_uleb128_array(leb128.array);
 			return std::format("{} ({:#x})", res, res);
 		};
 	
-		fn transform_leb128(auto leb128) {
-			return type::impl::transform_leb128_array(leb128.array);
+		fn transform_uleb128(ref auto leb128) {
+			return type::impl::transform_uleb128_array(leb128.array);
 		};
+
+		fn format_sleb128(ref auto leb128) {
+			s128 res = type::impl::transform_sleb128_array(leb128.array);
+			return std::format("{} ({:#x})", res, res);
+		};
+	
+		fn transform_sleb128(ref auto leb128) {
+			return type::impl::transform_sleb128_array(leb128.array);
+		};
+
 	}
 	
 }
-
--- a/includes/type/mac.pat
+++ b/includes/type/mac.pat
@@ -2,8 +2,15 @@

 #include <std/io.pat>

+/*!
+	Types used to decode MAC Addresses
+*/
+
 namespace type {

+	/**
+		A MAC Address as used in the Internet Protocol
+	*/
 	struct MACAddress {
 		u8 bytes[6];
 	} [[sealed, format("type::impl::format_mac_address")]];
--- a/includes/type/magic.pat
+++ b/includes/type/magic.pat
@@ -1,8 +1,18 @@
 #include <std/string.pat>
 #include <std/sys.pat>
+#include <std/io.pat>
+#include <std/ctype.pat>
+
+/*!
+    Types used to parse and enforce specific magic numbers
+*/

 namespace type {

+    /**
+        A Magic number. Throws an error if the magic number does not match the expected value
+        @tparam ExpectedValue A string representing the expected value
+    */
    struct Magic<auto ExpectedValue> {
        char value[std::string::length(ExpectedValue)];
        std::assert(value == ExpectedValue, std::format("Invalid magic value! Expected \"{}\", got \"{}\".", ExpectedValue, value));
@@ -11,9 +21,18 @@ namespace type {
    namespace impl {
    
        fn format_magic(ref auto magic) {
-            return magic.value;
+            str result;
+            for (u32 i = 0, i < sizeof(magic.value), i += 1) {
+                char c = magic.value[i];
+
+                if (std::ctype::isprint(c))
+                    result += c;
+                else
+                    result += std::format("\\x{:02X}", u8(c));
+            }
+            return std::format("\"{}\"", result);
        };
        
    }

-}
+}
--- a/includes/type/path.pat
+++ b/includes/type/path.pat
@@ -1,32 +1,53 @@
 #include <std/mem.pat>

+/*!
+	Types dealing with various kinds of resource paths
+*/
+
 namespace type {

-	struct UnixPathSegment {
-		char string[while(std::mem::read_unsigned($, 1) != '/' && std::mem::read_unsigned($, 1) != 0x00)];
+	/**
+		Type representing a single path segment. Use the `Path` type instead of using this on its own
+		@tparam Delimeter The delimeter sequence used to separate two path segments
+	*/
+	struct PathSegment<auto Delimeter> {
+		char string[while(std::mem::read_string($, std::string::length(Delimeter)) != Delimeter && std::mem::read_unsigned($, 1) != 0x00)];
 		char separator [[hidden]];
 		
 		if (separator == 0x00) {
 			$ -= 1;
 			break;
 		}
-	} [[sealed, format("type::impl::format_unix_path_segment")]];
+	} [[sealed, format("type::impl::format_path_segment")]];
 	
-	struct UnixPath {
-		UnixPathSegment segments[while(true)];
-	} [[format("type::impl::format_unix_path")]];
+	/**
+		A generic type representing a path with an arbitrary delimeter
+		@tparam Delimeter The delimeter sequence used to separate two path segments
+	*/
+	struct Path<auto Delimeter> {
+		PathSegment<Delimeter> segments[while(true)];
+	} [[format("type::impl::format_path")]];
 	
+	/**
+		A type representing a Unix path using a '/' forwardslash as delimeter
+	*/
+	using UnixPath = Path<"/">;
+
+	/**
+		A type representing a DOS path using a '\' backslash as delimeter
+	*/
+	using DOSPath = Path<"\\">;
 	
 	namespace impl {
 	
-		fn format_unix_path_segment(UnixPathSegment segment) {
+		fn format_path_segment(ref auto segment) {
 			return segment.string;
 		};
 	
-		fn format_unix_path(UnixPath path) {
+		fn format_path(ref auto path) {
 			return std::mem::read_string($, sizeof(path));
 		};
 	
 	}

-}
+}
--- a/includes/type/size.pat
+++ b/includes/type/size.pat
@@ -1,13 +1,36 @@
 #include <std/io.pat>

+/*!
+    Types used to pretty print size values
+*/
+
 namespace type {

+    /**
+        A generic size type which displays its value in Bytes (or kiB, MiB, GiB, TiB, PiB, EiB if larger)
+        @tparam T Underlying type
+    */
    using Size<T> = T [[format("type::impl::size_formatter")]];

+    /**
+        A 8 bit size type
+    */
    using Size8   = Size<u8>;
+    /**
+        A 16 bit size type
+    */
    using Size16  = Size<u16>;
+    /**
+        A 32 bit size type
+    */
    using Size32  = Size<u32>;
+    /**
+        A 64 bit size type
+    */
    using Size64  = Size<u64>;
+    /**
+        A 128 bit size type
+    */
    using Size128 = Size<u128>;

    namespace impl {
--- a/includes/type/time.pat
+++ b/includes/type/time.pat
@@ -3,12 +3,36 @@
 #include <std/io.pat>
 #include <std/time.pat>

+/*!
+    Types used to decode various different time formats
+*/
+
 namespace type {

+    /**
+        A 32 bit Unix time value
+    */
    using time32_t = u32 [[format("type::impl::format_time_t")]];
+    
+    /**
+        Alias name for `time32_t` 
+    */
+    using time_t = time32_t;
+
+    /**
+        A 64 bit Unix time value
+    */
    using time64_t = u64 [[format("type::impl::format_time_t")]];
-    using dosdate16_t = u16 [[format("type::impl::format_dosdate16_t")]];
-    using dostime16_t = u16 [[format("type::impl::format_dostime16_t")]];
+
+    /**
+        A DOS Date value
+    */
+    using DOSDate = u16 [[format("type::impl::format_dosdate")]];
+
+    /**
+        A DOS Time value
+    */
+    using DOSTime = u16 [[format("type::impl::format_dostime")]];

    namespace impl {

@@ -16,11 +40,11 @@ namespace type {
            return std::time::format(std::time::to_utc(value));
        };

-        fn format_dosdate16_t(u16 value) {
+        fn format_dosdate(u16 value) {
            return std::time::format_dos_date(std::time::to_dos_date(value));
        };

-        fn format_dostime16_t(u16 value) {
+        fn format_dostime(u16 value) {
            return std::time::format_dos_time(std::time::to_dos_time(value));
        };

--- a/includes/type/types/010.pat
+++ b/includes/type/types/010.pat
@@ -1,5 +1,9 @@
 #pragma once

+/*!
+    Alias types to make it easier to move template definitions over from 010 Editor to ImHex
+*/
+
 // Explicitly don't add these types to the `type` namespace for usability
 // namespace type {

--- a/includes/type/types/c.pat
+++ b/includes/type/types/c.pat
@@ -1,5 +1,9 @@
 #pragma once

+/*!
+    Alias definitions for all C stdint and regular data types
+*/
+
 // Explicitly don't add these types to the `type` namespace for usability
 // namespace type {

--- a/includes/type/types/linux.pat
+++ b/includes/type/types/linux.pat
@@ -1,5 +1,9 @@
 #pragma once

+/*!
+    Various data types used in the Linux Kernel
+*/
+
 // Explicitly don't add these types to the `type` namespace for usability
 // namespace type {

--- a/includes/type/types/rust.pat
+++ b/includes/type/types/rust.pat
@@ -1,5 +1,9 @@
 #pragma once

+/*!
+    Alias definitions for Rust's data types
+*/
+
 // Explicitly don't add these types to the `type` namespace for usability
 // namespace type {

--- a/includes/type/types/win32.pat
+++ b/includes/type/types/win32.pat
@@ -1,5 +1,9 @@
 #pragma once

+/*!
+    Alias definitions for various type names used in Windows applications
+*/
+
 // Explicitly don't add these types to the `type` namespace for usability
 // namespace type {

--- a/nodes/caesar.hexnode
+++ b/nodes/caesar.hexnode
@@ -0,0 +1,219 @@
+{
+    "attrs": [
+        76,
+        77,
+        78
+    ],
+    "data": {
+        "nodes": {
+            "links": {
+                "31": {
+                    "from": 54,
+                    "id": 31,
+                    "to": 55
+                },
+                "33": {
+                    "from": 59,
+                    "id": 33,
+                    "to": 56
+                },
+                "34": {
+                    "from": 60,
+                    "id": 34,
+                    "to": 57
+                },
+                "40": {
+                    "from": 68,
+                    "id": 40,
+                    "to": 53
+                },
+                "41": {
+                    "from": 66,
+                    "id": 41,
+                    "to": 69
+                },
+                "42": {
+                    "from": 66,
+                    "id": 42,
+                    "to": 63
+                },
+                "43": {
+                    "from": 58,
+                    "id": 43,
+                    "to": 71
+                },
+                "44": {
+                    "from": 70,
+                    "id": 44,
+                    "to": 72
+                },
+                "45": {
+                    "from": 73,
+                    "id": 45,
+                    "to": 64
+                },
+                "46": {
+                    "from": 65,
+                    "id": 46,
+                    "to": 75
+                }
+            },
+            "nodes": {
+                "19": {
+                    "attrs": [
+                        66
+                    ],
+                    "data": {
+                        "name": "Input",
+                        "type": 2
+                    },
+                    "id": 19,
+                    "name": "Input",
+                    "pos": {
+                        "x": 48.0,
+                        "y": 151.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "20": {
+                    "attrs": [
+                        68
+                    ],
+                    "data": {
+                        "name": "Count",
+                        "type": 0
+                    },
+                    "id": 20,
+                    "name": "Count",
+                    "pos": {
+                        "x": 50.0,
+                        "y": 264.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "21": {
+                    "attrs": [
+                        53,
+                        54
+                    ],
+                    "data": null,
+                    "id": 21,
+                    "name": "hex.builtin.nodes.casting.int_to_buffer.header",
+                    "pos": {
+                        "x": 212.0,
+                        "y": 315.0
+                    },
+                    "type": "hex.builtin.nodes.casting.int_to_buffer"
+                },
+                "22": {
+                    "attrs": [
+                        55,
+                        56,
+                        57,
+                        58
+                    ],
+                    "data": null,
+                    "id": 22,
+                    "name": "hex.builtin.nodes.buffer.slice.header",
+                    "pos": {
+                        "x": 384.0,
+                        "y": 375.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.slice"
+                },
+                "23": {
+                    "attrs": [
+                        59
+                    ],
+                    "data": {
+                        "data": 0
+                    },
+                    "id": 23,
+                    "name": "hex.builtin.nodes.constants.int.header",
+                    "pos": {
+                        "x": 122.0,
+                        "y": 423.0
+                    },
+                    "type": "hex.builtin.nodes.constants.int"
+                },
+                "24": {
+                    "attrs": [
+                        60
+                    ],
+                    "data": {
+                        "data": 1
+                    },
+                    "id": 24,
+                    "name": "hex.builtin.nodes.constants.int.header",
+                    "pos": {
+                        "x": 120.0,
+                        "y": 510.0
+                    },
+                    "type": "hex.builtin.nodes.constants.int"
+                },
+                "25": {
+                    "attrs": [
+                        63,
+                        64,
+                        65
+                    ],
+                    "data": null,
+                    "id": 25,
+                    "name": "hex.builtin.nodes.bitwise.add.header",
+                    "pos": {
+                        "x": 720.0,
+                        "y": 183.0
+                    },
+                    "type": "hex.builtin.nodes.bitwise.add"
+                },
+                "26": {
+                    "attrs": [
+                        69,
+                        70
+                    ],
+                    "data": null,
+                    "id": 26,
+                    "name": "hex.builtin.nodes.buffer.size.header",
+                    "pos": {
+                        "x": 383.0,
+                        "y": 274.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.size"
+                },
+                "27": {
+                    "attrs": [
+                        71,
+                        72,
+                        73
+                    ],
+                    "data": null,
+                    "id": 27,
+                    "name": "hex.builtin.nodes.buffer.repeat.header",
+                    "pos": {
+                        "x": 595.0,
+                        "y": 445.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.repeat"
+                },
+                "28": {
+                    "attrs": [
+                        75
+                    ],
+                    "data": {
+                        "name": "Output",
+                        "type": 2
+                    },
+                    "id": 28,
+                    "name": "Output",
+                    "pos": {
+                        "x": 864.0,
+                        "y": 330.0
+                    },
+                    "type": "hex.builtin.nodes.custom.output"
+                }
+            }
+        }
+    },
+    "name": "Caesar Cipher",
+    "type": "hex.builtin.nodes.custom.custom"
+}
--- a/nodes/xor.hexnode
+++ b/nodes/xor.hexnode
@@ -0,0 +1,223 @@
+{
+    "attrs": [
+        36,
+        37,
+        38
+    ],
+    "data": {
+        "nodes": {
+            "links": {
+                "11": {
+                    "from": 20,
+                    "id": 11,
+                    "to": 22
+                },
+                "13": {
+                    "from": 23,
+                    "id": 13,
+                    "to": 32
+                },
+                "14": {
+                    "from": 17,
+                    "id": 14,
+                    "to": 19
+                },
+                "15": {
+                    "from": 14,
+                    "id": 15,
+                    "to": 15
+                },
+                "16": {
+                    "from": 12,
+                    "id": 16,
+                    "to": 16
+                },
+                "17": {
+                    "from": 9,
+                    "id": 17,
+                    "to": 11
+                },
+                "18": {
+                    "from": 7,
+                    "id": 18,
+                    "to": 10
+                },
+                "19": {
+                    "from": 31,
+                    "id": 19,
+                    "to": 8
+                },
+                "20": {
+                    "from": 30,
+                    "id": 20,
+                    "to": 6
+                },
+                "22": {
+                    "from": 31,
+                    "id": 22,
+                    "to": 18
+                },
+                "23": {
+                    "from": 30,
+                    "id": 23,
+                    "to": 21
+                }
+            },
+            "nodes": {
+                "10": {
+                    "attrs": [
+                        14
+                    ],
+                    "data": {
+                        "data": 1
+                    },
+                    "id": 10,
+                    "name": "hex.builtin.nodes.constants.int.header",
+                    "pos": {
+                        "x": 430.0,
+                        "y": 364.0
+                    },
+                    "type": "hex.builtin.nodes.constants.int"
+                },
+                "11": {
+                    "attrs": [
+                        15,
+                        16,
+                        17
+                    ],
+                    "data": null,
+                    "id": 11,
+                    "name": "hex.builtin.nodes.arithmetic.add.header",
+                    "pos": {
+                        "x": 579.0,
+                        "y": 421.0
+                    },
+                    "type": "hex.builtin.nodes.arithmetic.add"
+                },
+                "12": {
+                    "attrs": [
+                        18,
+                        19,
+                        20
+                    ],
+                    "data": null,
+                    "id": 12,
+                    "name": "hex.builtin.nodes.buffer.repeat.header",
+                    "pos": {
+                        "x": 661.0,
+                        "y": 241.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.repeat"
+                },
+                "13": {
+                    "attrs": [
+                        21,
+                        22,
+                        23
+                    ],
+                    "data": null,
+                    "id": 13,
+                    "name": "hex.builtin.nodes.bitwise.xor.header",
+                    "pos": {
+                        "x": 818.0,
+                        "y": 163.0
+                    },
+                    "type": "hex.builtin.nodes.bitwise.xor"
+                },
+                "14": {
+                    "attrs": [
+                        32
+                    ],
+                    "data": {
+                        "name": "Output",
+                        "type": 2
+                    },
+                    "id": 14,
+                    "name": "Output",
+                    "pos": {
+                        "x": 1000.0,
+                        "y": 432.0
+                    },
+                    "type": "hex.builtin.nodes.custom.output"
+                },
+                "4": {
+                    "attrs": [
+                        30
+                    ],
+                    "data": {
+                        "name": "Input",
+                        "type": 2
+                    },
+                    "id": 4,
+                    "name": "Input",
+                    "pos": {
+                        "x": 82.0,
+                        "y": 139.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "5": {
+                    "attrs": [
+                        31
+                    ],
+                    "data": {
+                        "name": "XOR Pad",
+                        "type": 2
+                    },
+                    "id": 5,
+                    "name": "XOR Pad",
+                    "pos": {
+                        "x": 89.0,
+                        "y": 328.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "6": {
+                    "attrs": [
+                        6,
+                        7
+                    ],
+                    "data": null,
+                    "id": 6,
+                    "name": "hex.builtin.nodes.buffer.size.header",
+                    "pos": {
+                        "x": 269.0,
+                        "y": 403.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.size"
+                },
+                "7": {
+                    "attrs": [
+                        8,
+                        9
+                    ],
+                    "data": null,
+                    "id": 7,
+                    "name": "hex.builtin.nodes.buffer.size.header",
+                    "pos": {
+                        "x": 267.0,
+                        "y": 486.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.size"
+                },
+                "8": {
+                    "attrs": [
+                        10,
+                        11,
+                        12
+                    ],
+                    "data": null,
+                    "id": 8,
+                    "name": "hex.builtin.nodes.arithmetic.div.header",
+                    "pos": {
+                        "x": 409.0,
+                        "y": 465.0
+                    },
+                    "type": "hex.builtin.nodes.arithmetic.div"
+                }
+            }
+        }
+    },
+    "name": "XOR Pad",
+    "type": "hex.builtin.nodes.custom.custom"
+}
--- a/patterns/7z.hexpat
+++ b/patterns/7z.hexpat
@@ -0,0 +1,99 @@
+#include <std/io.pat> 
+#include <std/mem.pat> 
+#include <std/math.pat> 
+
+
+enum Type:u8{ 
+    startPosition = 0x00,       // Start position 
+    sizeStartHeader = 0x20,  // Size of start Header       
+}; 
+
+enum TypeB:u48{ 
+    sevenZipSignature = 0x1C27AFBC7A37,  // Defining 7z signature   
+};   
+
+struct StartHeader { 
+    // File signature 
+    u48 signature  [[color("FF0000")] ];  
+    // Version format 
+    u16 formatVersion [[color("00FF00")]];  
+    // CRC start header 
+    u32 crcOfTheFollowing20Bytes [[color("0000FF")]]; 
+    // Relative offset of End Header 
+    u64 relativeOffsetEndHeader [[color("FFFF00")]]; 
+    // Length of End Header 
+    u64 theLengthOfEndHeader [[color("00FFFF")]];  
+    // CRC of End Ender 
+    u32 crcOftheEndHeader [[color("FF00FF")]]; 
+    // File size calculation 
+    u64 fileSize = relativeOffsetEndHeader + theLengthOfEndHeader + Type::sizeStartHeader; 
+    // Absolute offset calculation End Header 
+    u64 startEndHeader = relativeOffsetEndHeader +  Type::sizeStartHeader; 
+}; 
+
+StartHeader startheader @ Type::startPosition; 
+ 
+struct CompressedData { 
+     // Start of compressed data     
+     u8 startOfCompressedData[4] [[color("C0C0C0")]];          
+}; 
+
+CompressedData compresseddata @ Type::sizeStartHeader; 
+
+  
+struct EndHeader { 
+    // Set padding to place End Header in right position 
+    padding[startheader.relativeOffsetEndHeader]; 
+    // Mark link to meta block 
+    u8 linkToMetaBlock [[color("FF0000")]];     
+    // Mark all End Header 
+    char fullEndHeader[startheader.theLengthOfEndHeader] [[color("63954A")]];  
+    // Detect LZMA signature 
+    u64 lzmaSignaturePosition = std::mem::find_sequence_in_range(0, addressof(fullEndHeader), addressof(fullEndHeader) + sizeof(fullEndHeader), 0x23, 0x03, 0x01, 0x01, 0x05, 0x5D);    
+                                                 
+    // Mark positions if LZMA signature was detected 
+    if(lzmaSignaturePosition != 0xFFFFFFFFFFFFFFFF){ 
+        u48 lzmaSignature @ lzmaSignaturePosition [[color("0000FF")]];   
+    } 
+}; 
+
+EndHeader endheader @ Type::sizeStartHeader; 
+ 
+// Check 7z type 
+if(startheader.signature ==  TypeB::sevenZipSignature){ 
+    std::print("It is a 7z File Type");  
+}else{ 
+    std::print("The file is not 7z type");  
+}  
+
+std::print("Format Version {} ",startheader.formatVersion);  
+
+// Version verification 
+if(startheader.formatVersion ==  0x0400){ 
+    std::print("Major Version 0x00 || 0 -  Minor Version 0x04 || 4");  
+}    
+
+// Verification of the compressed method is LZMA, Bzip2 or LZMA2 
+if(compresseddata.startOfCompressedData[0] ==  Type::startPosition){  
+     std::print("Compressed Method LZMA");    
+}else if(compresseddata.startOfCompressedData[0] ==  0x42){  
+    std::print("Compressed Method Bzip2");    
+}else{  
+    std::print("Compressed Method LZMA2");    
+} 
+
+  
+
+std::print("CRC Start Header 0x{:X}",startheader.crcOfTheFollowing20Bytes);     
+
+std::print("CRC End Header 0x{:X} ", startheader.crcOftheEndHeader);  
+
+std::print("CompressedData length 0x{:X} || {} bytes ",startheader.relativeOffsetEndHeader, startheader.relativeOffsetEndHeader);  
+
+std::print("Relative Offset of End Header 0x{:X} || {} bytes",startheader.relativeOffsetEndHeader, startheader.relativeOffsetEndHeader);  
+
+std::print("Offset to start End Header 0x{:X} || {} bytes",startheader.startEndHeader,startheader.startEndHeader);  
+
+std::print("End Header length 0x{:X} || {} bytes",startheader.theLengthOfEndHeader,startheader.theLengthOfEndHeader);  
+
+std::print("File size 0x{:X} || {} bytes",startheader.fileSize, startheader.fileSize); 
--- a/patterns/Crashlvl.hexpat
+++ b/patterns/Crashlvl.hexpat
@@ -0,0 +1,73 @@
+#include <type/magic.pat>
+#include <std/string.pat>
+#include <std/array.pat>
+
+// Crash Bandicoot - Back in Time (fan game) user created tapes
+// author AdventureT
+
+struct Header {
+    type::Magic<"CRASHLVL"> magic;
+    u8 version;
+    std::string::SizedString<u8> levelName;
+    std::string::SizedString<u8> author;
+};
+
+enum Music : u32 {
+    None,
+    BonusBGM,
+    CrashCreatorBGM,
+    MainMenuBGM,
+    WarpRoomBGM,
+    Level01BGM,
+    Level02BGM,
+    Level03BGM,
+    Level04BGM,
+    Level05BGM,
+    SewerBGM,
+    EgyptBGM,
+    NBrioBGM
+};
+
+enum Type : u32 {
+    Unset,
+    Flashback,
+    Trial
+};
+
+enum Time : u32 {
+    Night,
+    Day,
+    Storm,
+    Dawn
+};
+
+enum Terrain : u32 {
+    None,
+    Machines,
+    Trees,
+    Waterfall,
+    Snow,
+    Fortress,
+};
+
+struct Options {
+    Type type;
+    Time time;
+    Terrain terrain;
+    Music music;
+};
+
+struct Object {
+    std::string::SizedString<u8> objName;
+    u32 x;
+    u32 y;
+};
+
+struct Objects{
+    u32 objCount;
+    std::Array<Object, objCount> objArray;
+};
+
+Header header @ 0x0;
+Options options @ $;
+Objects objects @ $;
--- a/patterns/afe2.hexpat
+++ b/patterns/afe2.hexpat
@@ -1,6 +1,7 @@
 #pragma endian little

 #include <std/io.pat>
+#include <std/sys.pat>

 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC   	"AFE2"
 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC_1 	"AFE1"
@@ -54,4 +55,4 @@ std::assert_warn(ctx.magic == ATMOSPHERE_REBOOT_TO_FATAL_MAGIC,


 std::print("Error Description: 0x{:04X}", ctx.error_desc);
-std::print("Program ID: {:016X}", ctx.program_id);
+std::print("Program ID: {:016X}", ctx.program_id);
--- a/patterns/bmp.hexpat
+++ b/patterns/bmp.hexpat
@@ -1,5 +1,6 @@
 #pragma MIME image/bmp
 #pragma endian little
+#include <std/mem.pat>

 struct BitmapFileHeader {
 	u8 bfType[2];
@@ -31,6 +32,7 @@ struct Colors {
 };

 struct Bitmap {
+    u8 data[std::mem::size()] [[no_unique_address, hidden]];
 	BitmapFileHeader bmfh;
 	BitmapInfoHeader bmih;
 	
@@ -46,6 +48,6 @@ struct Bitmap {
 		u8 lineData[bmih.biSizeImage];
 	else
 		u8 lineData[bmfh.bfSize - $];
-};
+} [[hex::visualize("image", this.data)]];

 Bitmap bitmap @ 0x00;
--- a/patterns/bsp_goldsrc.hexpat
+++ b/patterns/bsp_goldsrc.hexpat
@@ -0,0 +1,208 @@
+#include <std/ptr.pat>
+#include <std/mem.pat>
+#include <std/sys.pat>
+
+#pragma endian little
+
+#define HEADER_LUMPS 15
+#define MAX_MAP_HULLS 4
+#define NUM_AMBIENTS 4
+#define MAXLIGHTMAPS 4
+
+enum LumpIndex : u32 {
+	Entities,
+	Planes,
+	Textures,
+	Vertexes,
+	Visibility,
+	Nodes,
+	Texinfo,
+	Faces,
+	Lighting,
+	Clipnodes,
+	Leafs,
+	Marksurfaces,
+	Edges,
+	Surfedges,
+	Models,
+};
+
+struct vec3f
+{
+	float x, y, z;
+};
+
+struct dlump_t
+{
+	s32 fileofs;
+	s32 filelen;
+};
+
+struct dheader_t
+{
+	s32    version;
+	dlump_t	lumps[HEADER_LUMPS];
+	std::assert(version == 30, "This version of BSP format is unsupported.");
+};
+
+struct dmodel_t
+{
+	vec3f  mins;
+	vec3f  maxs;
+	vec3f  origin;     // for sounds or lights
+	s32    headnode[MAX_MAP_HULLS];
+	s32    visleafs;   // not including the solid leaf 0
+	s32    firstface;
+	s32    numfaces;
+};
+
+struct dplane_t
+{
+	vec3f  normal;
+	float  dist;
+	s32	   type;
+};
+
+struct dtexinfo_t
+{
+	float  vecs[8];	// texmatrix [s/t][xyz offset]
+	s32	   miptex;
+	s16	   flags;
+	s16	   faceinfo; // -1 no face info otherwise dfaceinfo_t
+};
+
+struct dleaf_t
+{
+	s32 contents;
+	s32 visofs;     // -1 = no visibility info
+	s16 mins[3];
+	s16 maxs[3];
+	u16 firstmarksurface;
+	u16 nummarksurfaces;
+	u8 ambient_level[NUM_AMBIENTS];
+};
+
+struct dnode_t
+{
+	s32 planenum;
+	s16 children[2];    // negative numbers are -(leafs + 1), not nodes
+	s16 mins[3];
+	s16 maxs[3];
+	u16 firstface;
+	u16 numfaces;   // counting both sides
+};
+
+struct dface_t
+{
+	u16 planenum;
+	s16 side;
+	s32 firstedge;
+	s16 numedges;
+	s16 texinfo;
+	u8 styles[MAXLIGHTMAPS];
+	s32 lightofs;   // start of [numstyles*surfsize] samples
+};
+
+struct dedge_t
+{
+	u16 v[2]; // indices of vertexes
+};
+
+struct dclipnode_t
+{
+	s32 planenum;
+	s16 children[2];
+};
+
+using dmarkface_t = u16;
+using dsurfedge_t = s32;
+using dvertex_t = vec3f;
+
+fn get_miptex_pixeldata_size(auto width, auto height, auto offset) {
+	if (offset != 0) {
+		return std::mem::align_to(4, width * height * 85 / 64 + sizeof(u16) + 768);
+	}
+	else {
+		return 0;
+	}
+};
+
+struct miptex_t
+{
+	char   name[16];
+	u32	   width;
+	u32	   height;
+	u32	   offsets[4]; // four mip maps stored
+	u8     pixeldata[get_miptex_pixeldata_size(width, height, offsets[0])];
+};
+
+dheader_t file_header @ 0x00;
+
+fn get_lump_element_count(auto index, auto elem_size) {
+	return file_header.lumps[index].filelen / elem_size;
+};
+
+fn get_lump_address(auto index) {
+	return file_header.lumps[index].fileofs;
+};
+
+fn get_miptex_ptr_base(auto offset) {
+	return file_header.lumps[LumpIndex::Textures].fileofs;
+};
+
+struct MiptexPointer
+{
+	miptex_t *data: u32 [[pointer_base("get_miptex_ptr_base"), inline]];
+};
+
+struct dmiptexlump_t
+{
+	s32	nummiptex;
+	MiptexPointer dataofs[nummiptex];
+};
+
+struct VisibilityData 
+{
+	u8 data[file_header.lumps[LumpIndex::Visibility].filelen];
+	u8 pad[std::mem::align_to(4, sizeof(this)) - sizeof(this)];
+};
+
+struct LightmapData
+{
+	u8 data[file_header.lumps[LumpIndex::Lighting].filelen];
+	u8 pad[std::mem::align_to(4, sizeof(this)) - sizeof(this)];
+};
+
+struct EntityData
+{
+	char text[];
+	u8 pad[std::mem::align_to(4, sizeof(this)) - sizeof(this)];
+};
+
+s32 models_count = get_lump_element_count(LumpIndex::Models, sizeof(dmodel_t));
+s32 vertexes_count = get_lump_element_count(LumpIndex::Vertexes, sizeof(vec3f));
+s32 planes_count = get_lump_element_count(LumpIndex::Planes, sizeof(dplane_t));
+s32 leafs_count = get_lump_element_count(LumpIndex::Leafs, sizeof(dleaf_t));
+s32 nodes_count = get_lump_element_count(LumpIndex::Nodes, sizeof(dnode_t));
+s32 faces_count = get_lump_element_count(LumpIndex::Faces, sizeof(dface_t));
+s32 markfaces_count = get_lump_element_count(LumpIndex::Marksurfaces, sizeof(dmarkface_t));
+s32 surfedges_count = get_lump_element_count(LumpIndex::Surfedges, sizeof(dsurfedge_t));
+s32 edges_count = get_lump_element_count(LumpIndex::Edges, sizeof(dedge_t));
+s32 clipnodes_count = get_lump_element_count(LumpIndex::Clipnodes, sizeof(dclipnode_t));
+s32 texinfo_count = get_lump_element_count(LumpIndex::Texinfo, sizeof(dtexinfo_t));
+
+dmodel_t models_lump[models_count] @ get_lump_address(LumpIndex::Models);
+dvertex_t vertexes_lump[vertexes_count] @ get_lump_address(LumpIndex::Vertexes);
+dplane_t planes_lump[planes_count] @ get_lump_address(LumpIndex::Planes);
+dleaf_t leafs_lump[leafs_count] @ get_lump_address(LumpIndex::Leafs);
+dnode_t nodes_lump[nodes_count] @ get_lump_address(LumpIndex::Nodes);
+dface_t faces_lump[faces_count] @ get_lump_address(LumpIndex::Faces);
+dmarkface_t markfaces_lump[markfaces_count] @ get_lump_address(LumpIndex::Marksurfaces);
+dsurfedge_t surfedges_lump[surfedges_count] @ get_lump_address(LumpIndex::Surfedges);
+dedge_t edges_lump[edges_count] @ get_lump_address(LumpIndex::Edges);
+dclipnode_t clipnodes_lump[clipnodes_count] @ get_lump_address(LumpIndex::Clipnodes);
+dtexinfo_t texinfo_lump[texinfo_count] @ get_lump_address(LumpIndex::Texinfo);
+dmiptexlump_t textures_lump @ get_lump_address(LumpIndex::Textures);
+VisibilityData visdata_lump @ get_lump_address(LumpIndex::Visibility);
+LightmapData lightdata_lump @ get_lump_address(LumpIndex::Lighting);
+EntityData entdata_lump @ get_lump_address(LumpIndex::Entities);
--- a/patterns/cchva.hexpat
+++ b/patterns/cchva.hexpat
@@ -0,0 +1,30 @@
+// Command and conquer voxel animation format
+
+struct vec4_s {
+	float x [[color("FF0000")]];
+	float y [[color("00FF00")]];
+	float z [[color("0000FF")]];
+	float w [[color("FFFF00")]];
+};
+
+struct mat3x4_s {
+	vec4_s row[3];
+};
+
+struct name_s {
+	char buffer[16] [[color("EECCCC")]];
+};
+
+struct hva_s {
+	name_s name;
+	u32 numFrames;
+	u32 numNodes;
+	name_s nodeNames[numNodes];
+};
+
+struct frame_s {
+	mat3x4_s mat[hva.numNodes];
+};
+
+hva_s hva @0x00;
+frame_s frames[hva.numFrames] @sizeof(hva);
--- a/patterns/ccpal.hexpat
+++ b/patterns/ccpal.hexpat
@@ -0,0 +1,13 @@
+// Command and conquer palette format
+
+struct Color {
+	u8 r;
+	u8 g;
+	u8 b;
+};
+
+struct Palette {
+	Color colors[256];
+};
+
+Palette pal @0x00;
--- a/patterns/ccvxl.hexpat
+++ b/patterns/ccvxl.hexpat
@@ -0,0 +1,69 @@
+// Command and Conquer voxel model format
+
+struct vec4_s {
+    float x [[color("FF0000")]];
+    float y [[color("00FF00")]];
+    float z [[color("0000FF")]];
+    float w [[color("FFFF00")]];
+};
+
+struct vec3_s {
+    float x [[color("FF0000")]];
+    float y [[color("00FF00")]];
+    float z [[color("0000FF")]];
+};
+
+struct mat3x4_s {
+    vec4_s row[3];
+};
+
+struct name_s {
+	char buffer[16] [[color("EECCCC")]];
+};
+
+struct color_s {
+	u8 r;
+	u8 g;
+	u8 b;
+};
+
+struct vxl_limb_header_s {
+	name_s name;
+	s32 limb_number;
+	u32 _reserved1;
+	u32 _reserved2;
+};
+
+struct vxl_limb_tailer_s {
+	u32 span_start_offset;
+	u32 span_end_offset;
+	u32 span_data_offset;
+	float scale;
+	mat3x4_s matrix;
+	vec3_s min_bounds;
+	vec3_s max_bounds;
+	u8 xsize;
+	u8 ysize;
+	u8 zsize;
+	u8 normal_type;
+};
+
+struct vxl_s {
+	name_s name;
+	u32 palette_count;
+	u32 limb_count;
+	u32 tailer_count;
+	u32 body_size;
+	u8 remap_start_index;
+	u8 remap_end_index;
+	color_s internal_palette[256];
+	vxl_limb_header_s _headers[limb_count];
+	u8 body[body_size];
+	vxl_limb_tailer_s _tailers[limb_count];
+};
+
+struct frame_s {
+	mat3x4_s mat[hva.numNodes];
+};
+
+vxl_s vxl @0x00;
--- a/patterns/cda.hexpat
+++ b/patterns/cda.hexpat
@@ -0,0 +1,29 @@
+struct Header {
+u32 RIFF;
+s32 size;
+u32 CDDA;
+u32 fmt;
+u32 lenghtofthechunck;
+u16 versionofcdformat;
+u16 numberofrange;
+u32 identifier;
+};
+
+
+struct DataInfo {
+
+u32 range;
+u32 duration;
+u8 rangepositionframes;
+u8 rangepositionseconds;
+u8 rangepositionminutes;
+u8 nullbyte;
+u8 durationtrackframes;
+u8 durationtrackseconds;
+u8 durationtrackminutes;
+u8 nullbytee;
+};
+
+
+Header header @ 0;
+DataInfo data @ 0x1C;
--- a/patterns/coff.hexpat
+++ b/patterns/coff.hexpat
@@ -1,209 +1,209 @@
-#pragma MIME application/x-coff
-
-#include <type/time.pat>
-#include <type/size.pat>
-
-enum Machine : u16 {
-    Unknown     = 0x0000,
-    AM33        = 0x01D3,
-    AMD64       = 0x8664,
-    ARM         = 0x01C0,
-    ARM64       = 0xAA64,
-    ARMNT       = 0x01C4,
-    EBC         = 0x0EBC,
-    I386        = 0x014C,
-    IA64        = 0x0200,
-    LOONGARCH32 = 0x6232,
-    LOONGARCH64 = 0x6264,
-    M32R        = 0x9041,
-    MIPS16      = 0x0226,
-    MIPSFPU     = 0x0366,
-    MIPSFPU16   = 0x0466,
-    POWERPC     = 0x01F0,
-    POWERPCFP   = 0x01F0,
-    R4000       = 0x0166,
-    RISCV32     = 0x5032,
-    RISCV64     = 0x5064,
-    RISCV128    = 0x5128,
-    SH3         = 0x01A2,
-    SH3DSP      = 0x01A3,
-    SH4         = 0x01A6,
-    SH5         = 0x01A8,
-    THUMB       = 0x01C2,
-    WCEMIPSV2   = 0x0169
-};
-
-bitfield Characteristics {
-    relocsStripped          : 1;
-    executableImage         : 1;
-    lineNumsStripped        : 1;
-    localSymsStripped       : 1;
-    aggressiveWsTrim        : 1;
-    largeAddressAware       : 1;
-    padding                 : 1;
-    bytesReversedLo         : 1;
-    _32BitMachine           : 1;
-    debugStripped           : 1;
-    removableRunFromSwap    : 1;
-    netRunFromSwap          : 1;
-    system                  : 1;
-    dll                     : 1;
-    upSystemOnly            : 1;
-    bytesReversedHi         : 1;
-} [[right_to_left]];
-
-enum Type : u16 {
-    Null    = 0,
-    Void    = 1,
-    Char    = 2,
-    Short   = 3,
-    Int     = 4,
-    Long    = 5,
-    Float   = 6,
-    Double  = 7,
-    Struct  = 8,
-    Union   = 9,
-    Enum    = 10,
-    MOE     = 11,
-    Byte    = 12,
-    Word    = 13,
-    UInt    = 14,
-    DWord   = 15
-};
-
-enum StorageClass : u8 {
-    EndOfFunction   = 0xFF,
-    Null            = 0,
-    Automatic       = 1,
-    External        = 2,
-    Static          = 3,
-    Register        = 4,
-    ExternalDef     = 5,
-    Label           = 6,
-    UndefinedLabel  = 7,
-    MemberOfStruct  = 8,
-    Argument        = 9,
-    StructTag       = 10,
-    MemberOfUnion   = 11,
-    UnionTag        = 12,
-    TypeDefinition  = 13,
-    UndefinedStatic = 14,
-    EnumTag         = 15,
-    MemberOfEnum    = 16,
-    RegisterParam   = 17,
-    BitField        = 18,
-    Block           = 100,
-    Function        = 101,
-    EndOfStruct     = 102,
-    File            = 103,
-    Section         = 104,
-    WeakExternal    = 105,
-    CLRToken        = 107
-};
-
-struct AuxSymbol {
-    u8 data[18];
-};
-
-u32 countedSymbols = 0;
-struct SymbolTable {
-    char name[8];
-    u32 value;
-    u16 sectionNumber;
-    Type type;
-    StorageClass storageClass;
-    u8 numberOfAuxSymbols;
-    
-    countedSymbols += 1 + numberOfAuxSymbols;
-    
-    AuxSymbol auxSymbols[numberOfAuxSymbols];
-    
-    if (countedSymbols >= parent.header.numberOfSymbols)
-        break;
-};
-
-struct String {
-    char value[];
-};
-
-struct StringTable {
-    u32 size;
-    String strings[while($ < addressof(size) + size)];
-};
-
-bitfield SectionFlags {
-    padding             : 3;
-    typeNoPad           : 1;
-    padding             : 1;
-    cntCode             : 1;
-    initializedData     : 1;
-    uninitializedData   : 1;
-    lnkOther            : 1;
-    lnkInfo             : 1;
-    padding             : 1;
-    lnkRemove           : 1;
-    lnkCOMDAT           : 1;
-    padding             : 2;
-    gprel               : 1;
-    padding             : 1;
-    memPurgeable        : 1;
-    memLocked           : 1;
-    memPreload          : 1;
-    alignment           : 4 [[format("format_alignment")]];
-    lnkNrelocOvfl       : 1;
-    memDiscardable      : 1;
-    memNotCached        : 1;
-    memNotPaged         : 1;
-    memShared           : 1;
-    memExecute          : 1;
-    memRead             : 1;
-    memWrite            : 1;
-} [[right_to_left]];
-
-fn format_alignment(u8 alignment) {
-    return 1 << alignment;
-};
-
-struct Relocations {
-    u32 virtualAddress;
-    u32 symbolTableIndex;
-    Type type;
-};
-
-struct Section {
-    char name[8];
-    type::Size<u32> virtualSize;
-    u32 virtualAddress;
-    type::Size<u32> sizeOfRawData;
-    u32 pointerToRawData;
-    u32 pointerToRelocations;
-    u32 pointerToLineNumbers;
-    u16 numberOfRelocations;
-    u16 numberOfLineNumbers;
-    SectionFlags characteristics;
-    
-    u8 rawData[sizeOfRawData] @ pointerToRawData [[sealed]];
-    Relocations relocations[numberOfRelocations] @ pointerToRelocations;
-};
-
-struct Header {
-    Machine machine;
-    u16 numberOfSections;
-    type::time32_t timeDateStamp;
-    u32 pointerToSymbolTable;
-    u32 numberOfSymbols;
-    u16 sizeOfOptionalHeader;
-    Characteristics characteristics;
-};
-
-
-struct COFF {
-    Header header;
-    
-    Section sectionTable[header.numberOfSections];
-    
-    SymbolTable symbolTable[header.numberOfSymbols] @ header.pointerToSymbolTable;
-    StringTable stringTable @ addressof(symbolTable) + sizeof(symbolTable);
-};
-
-COFF coff @ 0x00;
+#pragma MIME application/x-coff
+
+#include <type/time.pat>
+#include <type/size.pat>
+
+enum Machine : u16 {
+    Unknown     = 0x0000,
+    AM33        = 0x01D3,
+    AMD64       = 0x8664,
+    ARM         = 0x01C0,
+    ARM64       = 0xAA64,
+    ARMNT       = 0x01C4,
+    EBC         = 0x0EBC,
+    I386        = 0x014C,
+    IA64        = 0x0200,
+    LOONGARCH32 = 0x6232,
+    LOONGARCH64 = 0x6264,
+    M32R        = 0x9041,
+    MIPS16      = 0x0226,
+    MIPSFPU     = 0x0366,
+    MIPSFPU16   = 0x0466,
+    POWERPC     = 0x01F0,
+    POWERPCFP   = 0x01F0,
+    R4000       = 0x0166,
+    RISCV32     = 0x5032,
+    RISCV64     = 0x5064,
+    RISCV128    = 0x5128,
+    SH3         = 0x01A2,
+    SH3DSP      = 0x01A3,
+    SH4         = 0x01A6,
+    SH5         = 0x01A8,
+    THUMB       = 0x01C2,
+    WCEMIPSV2   = 0x0169
+};
+
+bitfield Characteristics {
+    relocsStripped          : 1;
+    executableImage         : 1;
+    lineNumsStripped        : 1;
+    localSymsStripped       : 1;
+    aggressiveWsTrim        : 1;
+    largeAddressAware       : 1;
+    padding                 : 1;
+    bytesReversedLo         : 1;
+    _32BitMachine           : 1;
+    debugStripped           : 1;
+    removableRunFromSwap    : 1;
+    netRunFromSwap          : 1;
+    system                  : 1;
+    dll                     : 1;
+    upSystemOnly            : 1;
+    bytesReversedHi         : 1;
+};
+
+enum Type : u16 {
+    Null    = 0,
+    Void    = 1,
+    Char    = 2,
+    Short   = 3,
+    Int     = 4,
+    Long    = 5,
+    Float   = 6,
+    Double  = 7,
+    Struct  = 8,
+    Union   = 9,
+    Enum    = 10,
+    MOE     = 11,
+    Byte    = 12,
+    Word    = 13,
+    UInt    = 14,
+    DWord   = 15
+};
+
+enum StorageClass : u8 {
+    EndOfFunction   = 0xFF,
+    Null            = 0,
+    Automatic       = 1,
+    External        = 2,
+    Static          = 3,
+    Register        = 4,
+    ExternalDef     = 5,
+    Label           = 6,
+    UndefinedLabel  = 7,
+    MemberOfStruct  = 8,
+    Argument        = 9,
+    StructTag       = 10,
+    MemberOfUnion   = 11,
+    UnionTag        = 12,
+    TypeDefinition  = 13,
+    UndefinedStatic = 14,
+    EnumTag         = 15,
+    MemberOfEnum    = 16,
+    RegisterParam   = 17,
+    BitField        = 18,
+    Block           = 100,
+    Function        = 101,
+    EndOfStruct     = 102,
+    File            = 103,
+    Section         = 104,
+    WeakExternal    = 105,
+    CLRToken        = 107
+};
+
+struct AuxSymbol {
+    u8 data[18];
+};
+
+u32 countedSymbols = 0;
+struct SymbolTable {
+    char name[8];
+    u32 value;
+    u16 sectionNumber;
+    Type type;
+    StorageClass storageClass;
+    u8 numberOfAuxSymbols;
+    
+    countedSymbols += 1 + numberOfAuxSymbols;
+    
+    AuxSymbol auxSymbols[numberOfAuxSymbols];
+    
+    if (countedSymbols >= parent.header.numberOfSymbols)
+        break;
+};
+
+struct String {
+    char value[];
+};
+
+struct StringTable {
+    u32 size;
+    String strings[while($ < addressof(size) + size)];
+};
+
+bitfield SectionFlags {
+    padding             : 3;
+    typeNoPad           : 1;
+    padding             : 1;
+    cntCode             : 1;
+    initializedData     : 1;
+    uninitializedData   : 1;
+    lnkOther            : 1;
+    lnkInfo             : 1;
+    padding             : 1;
+    lnkRemove           : 1;
+    lnkCOMDAT           : 1;
+    padding             : 2;
+    gprel               : 1;
+    padding             : 1;
+    memPurgeable        : 1;
+    memLocked           : 1;
+    memPreload          : 1;
+    alignment           : 4 [[format("format_alignment")]];
+    lnkNrelocOvfl       : 1;
+    memDiscardable      : 1;
+    memNotCached        : 1;
+    memNotPaged         : 1;
+    memShared           : 1;
+    memExecute          : 1;
+    memRead             : 1;
+    memWrite            : 1;
+};
+
+fn format_alignment(u8 alignment) {
+    return 1 << alignment;
+};
+
+struct Relocations {
+    u32 virtualAddress;
+    u32 symbolTableIndex;
+    Type type;
+};
+
+struct Section {
+    char name[8];
+    type::Size<u32> virtualSize;
+    u32 virtualAddress;
+    type::Size<u32> sizeOfRawData;
+    u32 pointerToRawData;
+    u32 pointerToRelocations;
+    u32 pointerToLineNumbers;
+    u16 numberOfRelocations;
+    u16 numberOfLineNumbers;
+    SectionFlags characteristics;
+    
+    u8 rawData[sizeOfRawData] @ pointerToRawData [[sealed]];
+    Relocations relocations[numberOfRelocations] @ pointerToRelocations;
+};
+
+struct Header {
+    Machine machine;
+    u16 numberOfSections;
+    type::time32_t timeDateStamp;
+    u32 pointerToSymbolTable;
+    u32 numberOfSymbols;
+    u16 sizeOfOptionalHeader;
+    Characteristics characteristics;
+};
+
+
+struct COFF {
+    Header header;
+    
+    Section sectionTable[header.numberOfSections];
+    
+    SymbolTable symbolTable[header.numberOfSymbols] @ header.pointerToSymbolTable;
+    StringTable stringTable @ addressof(symbolTable) + sizeof(symbolTable);
+};
+
+COFF coff @ 0x00;
--- a/patterns/cpio.pat
+++ b/patterns/cpio.pat
@@ -22,14 +22,14 @@ namespace old_binary {
    using SwappedU32 = u32 [[transform("old_binary::swap_32bit"), format("old_binary::swap_32bit")]];

    bitfield Mode {
-        file_type   : 4;
-        suid        : 1;
-        sgid        : 1;
-        sticky      : 1;
-        r           : 3;
-        w           : 3;
        x           : 3;
-    } [[left_to_right]];
+        w           : 3;
+        r           : 3;
+        sticky      : 1;
+        sgid        : 1;
+        suid        : 1;
+        file_type   : 4;
+    };

    struct CpioHeader {
        type::Oct<u16> magic;
--- a/patterns/dex.hexpat
+++ b/patterns/dex.hexpat
@@ -0,0 +1,177 @@
+#include <type/leb128.pat>
+
+struct header_item {
+    u8 magic[8];
+    u32 checksum;
+    u8 signature[20];
+    u32 file_size;
+    u32 header_size;
+    u32 endian_tag;
+    u32 link_size;
+    u32 link_off;
+    u32 map_off;
+    u32 string_ids_size;
+    u32 string_ids_off;
+    u32 type_ids_size;
+    u32 type_ids_off;
+    u32 proto_ids_size;
+    u32 proto_ids_off;
+    u32 field_ids_size;
+    u32 field_ids_off;
+    u32 method_ids_size;
+    u32 method_ids_off;
+    u32 class_defs_size;
+    u32 class_defs_off;
+    u32 data_size;
+    u32 data_off;
+};
+
+struct map_item {
+    u16 type;
+    u16 unused;
+    u32 size;
+    u32 offset;
+};
+
+struct map_list {
+    u32 size;
+    map_item list[size];
+};
+
+struct string_data_item {
+    type::uLEB128 utf16_size[[hidden]];
+    char string[utf16_size];
+}[[inline]];
+
+struct string_id_item {
+    string_data_item* string_data: u32;
+}[[name(string_data.string)]];
+
+
+struct type_id_item {
+    u32 descriptor_idx;
+    char type_name[] @ addressof(parent.string_ids[descriptor_idx].string_data.string);
+}[[name(type_name)]];
+
+struct proto_id_item {
+    u32 shorty_idx;
+    u32 return_type_idx;
+    u32 parameters_off;
+    char shorty_dec[] @ addressof(parent.string_ids[shorty_idx].string_data.string);
+    char return_type[] @ addressof(parent.type_ids[return_type_idx].type_name);
+}[[name(shorty_dec)]];
+
+struct field_id_item {
+    u16 class_idx;
+    u16 type_idx;
+    u32 name_idx;
+    char class_name[] @ addressof(parent.type_ids[class_idx].type_name);
+    char type_name[] @ addressof(parent.type_ids[type_idx].type_name);
+    char field_name[] @ addressof(parent.string_ids[name_idx].string_data.string);
+}[[name(field_name)]];
+
+struct method_id_item {
+    u16 class_idx;
+    u16 proto_idx;
+    u32 name_idx;
+    char class_name[] @ addressof(parent.type_ids[class_idx].type_name);
+    char proto_desc[] @ addressof(parent.proto_ids[proto_idx].shorty_dec);
+    char method_name[] @ addressof(parent.string_ids[name_idx].string_data.string);
+
+}[[name(class_name+method_name)]];
+
+struct class_site_id_item {
+    u32 call_site_off;
+};
+
+struct method_handle_item {
+    u16 method_handle_type;
+    u16 unused;
+    u16 field_or_method_id;
+    u16 unused2;
+};
+enum access_flag : type::uLEB128{
+    public = 0x1,
+    private = 0x2,
+    protected = 0x4,
+    static = 0x8,
+    final = 0x10,
+    synchronized = 0x20,
+    volatile = 0x40    
+};
+
+struct encoded_field {
+    type::uLEB128 field_idx_diff;
+    access_flag access_flags;
+};
+
+struct encoded_method {
+    type::uLEB128 method_idx_diff;
+    type::uLEB128 access_flags;
+    type::uLEB128 code_off;
+};
+
+struct class_data_item {
+    type::uLEB128 static_fields_size;
+    type::uLEB128 instance_fields_size;
+    type::uLEB128 direct_methods_size;
+    type::uLEB128 virtual_methods_size;
+    encoded_field static_fields[static_fields_size];
+    encoded_field instance_fields[instance_fields_size];
+    encoded_method direct_methods[direct_methods_size];
+    encoded_method virtual_methods[virtual_methods_size];
+};
+
+struct class_def_item {
+    u32 class_idx;
+    u32 access_flags;
+    u32 superclass_idx;
+    u32 interfaces_off;
+    u32 source_file_idx;
+    u32 annotations_off;
+    u32 class_data_off;
+    //class_data_item *class_data_off:u32;
+    u32 static_values_off;
+    char class_name[] @ addressof(parent.type_ids[class_idx].type_name);    
+}[[name(class_name)]];
+
+struct type_item {
+    u16 type_idx;
+};
+
+struct type_list {
+    u32 size;
+    type_item list[size];
+};
+
+struct code_item {
+    u16 registers_size;
+    u16 ins_size;
+    u16 outs_size;
+    u16 tries_size;
+    u32 debug_info_off;
+    u32 insns_size;
+    u16 insns[insns_size];
+};
+
+struct try_item {
+    u32 start_addr;
+    u16 insn_count;
+    u16 handler_off;
+};
+
+
+
+struct Dex {
+    header_item header;
+    string_id_item string_ids[header.string_ids_size] @ header.string_ids_off;
+    type_id_item type_ids[header.type_ids_size] @ header.type_ids_off;
+    proto_id_item proto_ids[header.proto_ids_size] @ header.proto_ids_off;
+    field_id_item field_ids[header.field_ids_size] @ header.field_ids_off;
+    method_id_item method_ids[header.method_ids_size] @ header.method_ids_off;
+    class_def_item class_defs[header.class_defs_size] @ header.class_defs_off;
+    u8 data[header.data_size] @header.data_off;
+    map_list map_list @ header.map_off;
+    u8 link_data[header.link_size] @ header.link_off;
+};
+Dex dex @ 0x00;
--- a/patterns/dmg.hexpat
+++ b/patterns/dmg.hexpat
@@ -0,0 +1,49 @@
+#pragma endian big
+
+#include <type/magic.pat>
+#include <type/size.pat>
+#include <type/guid.pat>
+#include <std/mem.pat>
+
+// Parse DMG Structure per http://newosxbook.com/DMG.html
+//
+// UDIFResourceFile starts at size(file) - 512
+struct UDIFResourceFile {
+    type::Magic<"koly"> Signature;  // Magic ('koly')
+    u32 Version;                    // Current version is 4
+    type::Size<u32> HeaderSize;     // sizeof(this), always 512
+    u32 Flags;
+    u64 RunningDataForkOffset;      // 
+    u64 DataForkOffset;             // Data fork offset (usually 0, beginning of file)
+    type::Size<u64> DataForkLength; // Size of data fork (usually up to the XMLOffset, below)
+    u64 RsrcForkOffset;             // Resource fork offset, if any
+    type::Size<u64> RsrcForkLength; // Resource fork length, if any
+    u32 SegmentNumber;              // Usually 1, may be 0
+    u32 SegmentCount;               // Usually 1, may be 0
+    type::GUID SegmentID;           // 128-bit GUID identifier of segment (if SegmentNumber !=0)
+    
+
+    u32 DataChecksumType;               // Data fork 
+    type::Size<u32> DataChecksumSize;   // Checksum Information
+    u32 DataChecksum[DataChecksumSize]; // Up to 128-bytes (32 x 4) of checksum
+
+    u64 XMLOffset;              // Offset of property list in DMG, from beginning
+    type::Size<u64> XMLLength;  // Length of property list
+    u8  Reserved1[120];         // 120 reserved bytes - zeroed
+
+    u32 ChecksumType;               // Master
+    type::Size<u32> ChecksumSize;   // Checksum information
+    u32 Checksum[ChecksumSize];     // Up to 128-bytes (32 x 4) of checksum
+
+    u32 ImageVariant;          // Commonly 1
+    u64 SectorCount;           // Size of DMG when expanded, in sectors
+
+    u32 reserved2;             // 0
+    u32 reserved3;             // 0 
+    u32 reserved4;             // 0
+};
+
+
+UDIFResourceFile trailer @ std::mem::size() - 512;
+
+char metadata_plist[trailer.XMLLength] @ trailer.XMLOffset;
--- a/patterns/dsstore.hexpat
+++ b/patterns/dsstore.hexpat
@@ -0,0 +1,113 @@
+// Apple macOS .DS_Store format
+#pragma endian big
+#include <std/io.pat>
+
+struct RecordEntry {
+  u32 length;
+  char16 filename[length];
+  
+  char id[4];
+  // either blob or length
+  char type[4];
+  
+  if (type == "blob") {
+    u32 blobCount;
+    u8 blobData[blobCount];
+  }
+  else if (type == "long") {
+    u32 value;
+  }
+  else if (type == "shor") {
+    u32 value;
+  }
+  else if (type == "bool") {
+    u8 value;
+  }
+};
+
+struct TreeBlock {
+  u32 mode;
+  u32 count;
+  RecordEntry entries[count];
+};
+
+struct BuddyRootBlockOffsets {
+  u32 count;
+  u8 reserved[4];
+  u32 addresses[count];
+  padding[(1024 - (count * 4))];
+};
+
+struct BuddyTableOfContentEntry {
+  u8 count;
+  char name[count];
+  u32 value;
+};
+
+struct BuddyTableOfContents {
+  u32 count;
+  BuddyTableOfContentEntry toc[count];
+};
+
+struct BuddyFreeList {
+  u32 count;
+  u32 offsets[count];
+};
+
+struct BuddyRootBlock {
+  BuddyRootBlockOffsets offsets;
+  BuddyTableOfContents toc;
+  BuddyFreeList freelists[32];
+};
+
+struct BuddyBlock {
+  u32 blockCount;
+  u8 reserved[4];
+  // padding for next multiple of 256 entries (1024 bytes)
+  u32 addresses[blockCount];
+  
+  // u8 padding[paddingCount];
+  u32 directoryCount;
+  
+  // directory entries
+  u8 count;
+  u8 name[count];
+  u32 blockNumber;
+  
+  // free lists
+  // 32 free lists
+  BuddyRootBlockOffsets off[32];
+};
+
+struct BlocksList {
+  u32 blockId [[color("E57373")]];
+  u32 internalBlocks [[color("80CBC4")]];
+  u32 countRecords [[color("ffeb3b")]];
+  u32 countBlocks [[color("64b5f6")]];
+  u32 reserved [[color("a1887f")]];
+};
+
+struct BuddyAllocator {
+  char header[4];
+  u32 offsetBookkeeping;
+  u32 sizeBookkeeping;
+  u32 offsetBookkeeping2;
+  u32 offsetData;
+  u8 reserved[12];
+  
+  BuddyRootBlock root @ offsetBookkeeping + 4;
+
+  std::print("TOC {} address 0x{:08x}",
+    root.toc.toc[0].value,
+    root.offsets.addresses[root.toc.toc[0].value] >> 0x5 << 0x5);
+
+  BlocksList blocks @ (root.offsets.addresses[root.toc.toc[0].value] >> 0x5 << 0x5) + 4;
+  
+  std::print("Blocks start at address 0x{:08x}, size 0x{:04x}",
+    root.offsets.addresses[blocks.blockId] >> 0x5 << 0x5,
+    1 << (root.offsets.addresses[blocks.blockId] & 0x1f));
+
+  TreeBlock entries @ (root.offsets.addresses[blocks.blockId] >> 0x5 << 0x5) + 4;
+};
+
+BuddyAllocator buddy @0x04;
--- a/patterns/elf.hexpat
+++ b/patterns/elf.hexpat
@@ -5,8 +5,11 @@
 #pragma MIME application/x-sharedlib

 #include <std/core.pat>
+#include <std/io.pat>
 #include <std/mem.pat>

+using BitfieldOrder = std::core::BitfieldOrder;
+
 using EI_ABIVERSION     = u8;
 using Elf32_Addr        = u32;
 using Elf32_BaseAddr    = u32;
@@ -457,37 +460,37 @@ enum VER_NEED : Elf32_Half {
 };

 bitfield SYMINFO_FLG {
-    padding     : 10;
-    NOEXTDIRECT : 1;
-    DIRECTBIND  : 1;
-    LAZYLOAD    : 1;
-    COPY        : 1;
-    RESERVED    : 1;
    DIRECT      : 1;
-} [[left_to_right]];
+    RESERVED    : 1;
+    COPY        : 1;
+    LAZYLOAD    : 1;
+    DIRECTBIND  : 1;
+    NOEXTDIRECT : 1;
+    padding     : 10;
+};

 bitfield ST {
    ST_BIND : 4;
    ST_TYPE : 4;
-} [[left_to_right]];
+} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 8)]];

 bitfield SHF {
-    MASKPROC         : 4;
-    MASKOS           : 8;
-    UNKNOWN          : 8;
-    COMPRESSED       : 1;
-    TLS              : 1;
-    GROUP            : 1;
-    OS_NONCONFORMING : 1;
-    LINK_ORDER       : 1;
-    INFO_LINK        : 1;
-    STRINGS          : 1;
-    MERGE            : 1;
-    padding          : 1;
-    EXECINSTR        : 1;
-    ALLOC            : 1;
    WRITE            : 1;
-} [[left_to_right]];
+    ALLOC            : 1;
+    EXECINSTR        : 1;
+    padding          : 1;
+    MERGE            : 1;
+    STRINGS          : 1;
+    INFO_LINK        : 1;
+    LINK_ORDER       : 1;
+    OS_NONCONFORMING : 1;
+    GROUP            : 1;
+    TLS              : 1;
+    COMPRESSED       : 1;
+    UNKNOWN          : 8;
+    MASKOS           : 8;
+    MASKPROC         : 4;
+};

 bitfield ELF32_R_INFO {
    SYM  : 8;
@@ -500,13 +503,13 @@ bitfield ELF64_R_INFO {
 } [[left_to_right]];

 bitfield PF {
-    MASKPROC : 4;
-    MASKOS   : 4;
-    padding  : 17;
-    R        : 1;
-    W        : 1;
    X        : 1;
-} [[left_to_right]];
+    W        : 1;
+    R        : 1;
+    padding  : 17;
+    MASKOS   : 4;
+    MASKPROC : 4;
+};

 struct E_IDENT {
    char EI_MAG[4];
@@ -561,7 +564,7 @@ struct Elf32_Phdr {
    Elf32_Word p_align;
    
    if (p_offset > 0 && p_filesz > 0 && (p_offset + p_filesz) < std::mem::size() && p_filesz < std::mem::size())
-    	u8 p_data[p_filesz] @ p_offset;
+        u8 p_data[p_filesz] @ p_offset [[sealed]];
 };

 struct Elf64_Phdr {
@@ -575,7 +578,7 @@ struct Elf64_Phdr {
    Elf64_Xword p_align;
    
    if (p_offset > 0 && p_filesz > 0 && (p_offset + p_filesz) < std::mem::size() && p_filesz < std::mem::size())
-    	u8 p_data[p_filesz] @ p_offset;
+        u8 p_data[p_filesz] @ p_offset [[sealed]];
 };

 struct Elf32_Chdr {
@@ -637,12 +640,12 @@ struct Elf32_Shdr {
 		} else if (sh_type == SHT::STRTAB) {
 			String stringTable[while($ < (sh_offset + sh_size))] @ sh_offset;
 			stringTableIndex = std::core::array_index();	
-		} else if (sh_type == SHT::DYNSYM) {
+		} else if (sh_type == SHT::SYMTAB || sh_type == SHT::DYNSYM) {
 			Elf32_Sym symbolTable[sh_size / sh_entsize] @ sh_offset;
 		} else if (sh_type == SHT::INIT_ARRAY || sh_type == SHT::FINI_ARRAY) {
 			u32 pointer[while($ < (sh_offset + sh_size))] @ sh_offset;
 		} else {
-			u8 data[sh_size] @ sh_offset;
+			u8 data[sh_size] @ sh_offset [[sealed]];
 		}
    }
 } [[format("format_section_header")]];;
@@ -697,12 +700,12 @@ struct Elf64_Shdr {
 		} else if (sh_type == SHT::STRTAB) {
 			String stringTable[while($ < (sh_offset + sh_size))] @ sh_offset;
 			stringTableIndex = std::core::array_index();	
-		} else if (sh_type == SHT::DYNSYM) {
+		} else if (sh_type == SHT::SYMTAB || sh_type == SHT::DYNSYM) {
 			Elf64_Sym symbolTable[sh_size / sh_entsize] @ sh_offset;
 		} else if (sh_type == SHT::INIT_ARRAY || sh_type == SHT::FINI_ARRAY) {
 			u32 pointer[while($ < (sh_offset + sh_size))] @ sh_offset;
 		} else {
-			u8 data[sh_size] @ sh_offset;
+			u8 data[sh_size] @ sh_offset [[sealed]];
 		}
    }
 } [[format("format_section_header")]];
@@ -742,3 +745,78 @@ struct ELF {
 };

 ELF elf @ 0x00;
+
+
+fn gen_shdr_disp_name(ref auto pattern, str member_name, u8 member_index) {
+    return std::format(
+        "{}@shdr[{}]({})",
+        member_name,
+        member_index,
+        format_section_header(pattern)
+    );
+};
+
+fn gen_shdr_sub_disp_name(ref auto pattern, str member_name, u8 member_index, u64 submember_index) {
+    return std::format(
+        "{}[{}]@shdr[{}]({})",
+        member_name,
+        submember_index,
+        member_index,
+        format_section_header(pattern)
+    );
+};
+
+fn gen_phdr_disp_name(ref auto pattern, str member_name, u8 member_index) {
+    return std::format(
+        "{}@phdr[{}]({})",
+        member_name,
+        member_index,
+        pattern.p_type
+    );
+};
+
+bool displaySectionNames in;
+
+fn main() {
+    if (!displaySectionNames)
+        return;
+
+    for (u32 i = 0, i < std::core::member_count(elf.shdr), i += 1) {
+        if (std::core::has_member(elf.shdr[i], "stringTable")) {
+            std::core::set_display_name(
+                elf.shdr[i].stringTable,
+                gen_shdr_disp_name(elf.shdr[i], "stringTable", i)
+            );
+            for (u64 j = 0, j < std::core::member_count(elf.shdr[i].stringTable), j += 1) {
+                std::core::set_display_name(
+                    elf.shdr[i].stringTable[j],
+                    gen_shdr_sub_disp_name(elf.shdr[i], "String", i, j)
+                );
+            }
+        } else if (std::core::has_member(elf.shdr[i], "symbolTable")) {
+            std::core::set_display_name(
+                elf.shdr[i].symbolTable,
+                gen_shdr_disp_name(elf.shdr[i], "symbolTable", i)
+            );
+        } else if (std::core::has_member(elf.shdr[i], "pointer")) {
+            std::core::set_display_name(
+                elf.shdr[i].pointer,
+                gen_shdr_disp_name(elf.shdr[i], "pointer", i)
+            );
+        } else if (std::core::has_member(elf.shdr[i], "data")) {
+            std::core::set_display_name(
+                elf.shdr[i].data,
+                gen_shdr_disp_name(elf.shdr[i], "data", i)
+            );
+        }
+    }
+
+    for (u32 i = 0, i < std::core::member_count(elf.phdr), i += 1) {
+        if (std::core::has_member(elf.phdr[i], "p_data")) {
+            std::core::set_display_name(
+                elf.phdr[i].p_data,
+                gen_phdr_disp_name(elf.phdr[i], "p_data", i)
+            );
+        }
+    }
+};
--- a/patterns/evtx.hexpat
+++ b/patterns/evtx.hexpat
@@ -0,0 +1,57 @@
+#pragma endian little
+
+struct Header {
+    char signature[0x8];
+    u64  first_chunk_number;
+    u64  last_chunk_number;
+    u64  next_record_identifier;
+    u32  header_size;
+    u16  minor_format_version;
+    u16  major_format_version;
+    u16  header_block_size;
+    u16  number_of_chunks;
+    u8   unknown[0x4C];
+    u32  file_Flag;
+    u32  checkSum;
+    u8   unknown2[3968];
+};
+
+struct BinaryXML{
+    u8 fragment_header_token;
+    u8 major_version;
+    u8 minor_version;
+    u8 flags;
+};
+
+struct Event_Record{
+    u32 signature;
+    u32 size;
+    u64 event_record_identifier;
+    u64 written_data_amd_time;
+    BinaryXML binaryxml;
+};
+
+struct Chunk{
+    char signature[0x8];
+    u64 first_event_record_number;
+    u64 last_event_record_number;
+    u64 first_event_record_identifier;
+    u64 last_event_record_identifier;
+    u32 header_size;
+    u32 last_event_record_data_offset;
+    u32 free_space_offset;
+    u32 event_records_checksum;
+    u8 unknown[64];
+    u32 unknown2;
+    u32 checksum;
+    u8 common_string_offset_array[256];
+    u8 templatePtr[128];
+    Event_Record event_record;
+};
+
+struct Evtx {
+    Header header;
+    Chunk chunk;
+};
+
+Evtx evtx @ 0x00;
--- a/patterns/flac.hexpat
+++ b/patterns/flac.hexpat
@@ -1,321 +1,323 @@
-#include <std/sys.pat>
-#include <std/core.pat>
-#include <std/io.pat>
-
-#pragma endian big
-
-u32 sampleSize;
-u32 bitsPerSample;
-
-// METADATA
-
-enum BLOCK_TYPE : u8 {
-	STREAMINFO = 0,
-	PADDING = 1,
-	APPLICATION = 2,
-	SEEKTABLE = 3,
-	VORBIS_COMMENT = 4,
-	CUESHEET = 5,
-	PICTURE = 6,
-	
-	INVALID = 127
-};
-
-bitfield METADATA_BLOCK_HEADER {
-	lastMetadataBlock 	: 1;
-	blockType 			: 7;
-	length				: 24;
-} [[left_to_right]];
-
-bitfield STREAMINFO_FLAGS {
-	sampleRate 			: 20;
-	numChannels 		: 3 [[format("format_channels")]];
-	bitsPerSample 		: 5;
-	numSamplesInStream	: 36;
-} [[inline, left_to_right]];
-
-fn format_channels(u8 value) {
-	return value + 1;
-};
-
-struct METADATA_BLOCK_STREAMINFO {
-	u16 minBlockSize, maxBlockSize;
-	u24 minFrameSize, maxFrameSize;
-	STREAMINFO_FLAGS flags;
-	u128 md5Signature;
-	
-	bitsPerSample = flags.bitsPerSample;
-};
-
-struct METADATA_BLOCK_PADDING {
-	padding[parent.header.length];
-};
-
-struct METADATA_BLOCK_APPLICATION {
-	char applicationID[4];
-	u8 applicationData[parent.header.length - sizeof(applicationID)];
-};
-
-struct SEEKPOINT {
-	u64 sampleNumber;
-	u64 byteOffset;
-	u16 numSamples;
-};
-
-struct METADATA_BLOCK_SEEKTABLE {
-	SEEKPOINT seekPoints[parent.header.length / 18];
-};
-
-struct VORBIS_USER_COMMENT {
-	le u32 length;
-	char comment[length];
-};
-
-struct METADATA_BLOCK_VORBIS_COMMENT {
-	le u32 vendorLength;
-	u8 vendor[vendorLength];
-	
-	le u32 userCommentListLength;
-	VORBIS_USER_COMMENT userCommentList[userCommentListLength];
-};
-
-bitfield TRACK_FLAGS {
-	audioTrack 	: 1;
-	preEmphasis : 1;
-	padding 	: 6;
-} [[inline]];
-
-struct CUESHEET_TRACK_INDEX {
-	u64 sampleOffset;
-	u8 indexPointNumber;
-	padding[3];
-};
-
-struct CUESHEET_TRACK {
-	u64 trackOffset;
-	u8 trackNumber;
-	char trackISRC[12];
-	TRACK_FLAGS flags;
-	padding[13];
-	u8 numTrackIndexPoints;
-	CUESHEET_TRACK_INDEX indexes[numTrackIndexPoints];
-};
-
-struct METADATA_BLOCK_CUESHEET {
-	char mediaCatalogNumber[128];
-	u64 numLeadInSamples;
-	bool isCD;
-	padding[258];
-	u8 numTracks;
-	CUESHEET_TRACK tracks[numTracks];
-};
-
-enum PICTURE_TYPE : u32 {
-	Other 				= 0,
-	FileIcon 			= 1,
-	OtherFileIcon 		= 2,
-	CoverFront			= 3,
-	CoverBack			= 4,
-	LeafletPage			= 5,
-	Media				= 6,
-	LeadArtist			= 7,
-	Artist				= 8,
-	Conductor			= 9,
-	Band				= 10,
-	Composer			= 11,
-	Lyricist			= 12,
-	RecordingLocation	= 13,
-	DuringRecording		= 14,
-	DuringPerformance	= 15,
-	MovieScreenCapture	= 16,
-	ABrightColoredFish	= 17,
-	Illustration		= 18,
-	BandLogoType		= 19,
-	PublisherLogoType	= 20
-};
-
-struct METADATA_BLOCK_PICTURE {
-	PICTURE_TYPE pictureType;
-	u32 mimeTypeLength;
-	char mimeType[mineTypeLength];
-	u32 descriptionLength;
-	char description[descriptionLength];
-	u32 width, height;
-	u32 colorDepth;
-	u32 colorCount;
-	u32 pictureDataLength;
-	u8 pictureData[pictureDataLength];
-};
-
-
-
-// FRAME DATA
-// TODO: THIS IS INCOMPLETE / NOT WORKING CURRENTLY
-
-bitfield FRAME_HEADER_FLAGS {
-	syncCode			: 14;
-	padding				: 1;
-	blockingStrategy	: 1;
-	blockSize			: 4;
-	sampleRate			: 4;
-	channelAssignment	: 4;
-	sampleSize			: 3;
-	padding				: 1;
-} [[inline]];
-
-struct FRAME_HEADER {
-	FRAME_HEADER_FLAGS flags;
-	
-	sampleSize = flags.sampleSize;
-	
-	if (flags.blockingStrategy)
-		char16 sampleNumber[7];
-	else
-		char16 frameNumber[6];
-	
-	if (flags.blockSize == 0b0110)
-		u8 blockSize;
-	else if (flags.blockSize == 0b0111)
-		u16 blockSize;
-		
-	if (flags.sampleRate == 0b1100)
-		u8 sampleRate;
-	else if (flags.sampleRate == 0b1101 || flags.sampleRate == 0b1110)
-		u16 sampleRate;
-		
-	u8 crc8;
-};
-
-struct FRAME_FOOTER {
-	u16 crc16;
-};
-
-bitfield SUBFRAME_HEADER {
-	padding	: 1;
-	type	: 6;
-	wastedBits : 1;
-};
-
-fn getBitsPerSample() {
-	if (sampleSize == 0b000)
-		return bitsPerSample;
-	else if (sampleSize == 0b001)
-		return 8;
-	else if (sampleSize == 0b010)
-		return 12;
-	else if (sampleSize == 0b100)
-		return 16;
-	else if (sampleSize == 0b101)
-		return 20;
-	else if (sampleSize == 0b110)
-		return 24;
-};
-
-bitfield SUBFRAME_CONSTANT {
-	value : getBitsPerSample();
-};
-
-bitfield SUBFRAME_VERBATIM {
-	value : getBitsPerSample() * parent.parent.header.flags.blockSize;
-};
-
-bitfield SUBFRAME_FIXED_VALUE {
-	value : getBitsPerSample() * (parent.parent.header.type & 0b111);
-	codingMethod : 2;
-} [[inline]];
-
-bitfield RESIDUAL_CODING_METHOD_PARTITIONED_RICE {
-	partitionOrder : 4;
-	riceParameter : 4;
-	if (riceParameter == 0b1111)
-		bitsPerSample : 5;
-} [[right_to_left]];
-
-bitfield RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 {
-	partitionOrder : 4;
-	riceParameter  : 5;
-	if (riceParameter == 0b11111)
-		bitsPerSample : 5;
-} [[right_to_left]];
-
-struct RESIDUAL {
-	if (parent.value.codingMethod == 0b00)
-		RESIDUAL_CODING_METHOD_PARTITIONED_RICE rice;
-	else if (parent.value.codingMethod == 0b01)
-		RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 rice;
-		
-		
-	if ((parent.parent.header.type & 0b111) == 0b000)
-		u8 samples[(getBitsPerSample() * (parent.parent.parent.header.flags.blockSize - (parent.parent.header.type & 0b111))) / 8];
-	else if (std::core::array_index() != 0)
-		u8 samples[(getBitsPerSample() * (parent.parent.parent.header.flags.blockSize / (1 << rice.partitionOrder))) / 8];
-	else
-		u8 samples[(getBitsPerSample() * ((parent.parent.parent.header.flags.blockSize / (1 << rice.partitionOrder)) - (parent.parent.header.type & 0b111))) / 8];
-};
-
-struct SUBFRAME_FIXED {
-	SUBFRAME_FIXED_VALUE value;
-	RESIDUAL residual;
-};
-
-bitfield SUBFRAME_LPC_VALUE {
-	warmUpSamples : getBitsPerSample() * ((parent.header.type & 0b011111) + 1);
-	quantizedLinearPredictorCoefficient : 4;
-	quantizedLinearPredictorCoefficientShift : 5;
-	predictorCoefficients : quantizedLinearPredictorCoefficient * ((parent.header.type & 0b011111) + 1);
-} [[inline]];
-
-struct SUBFRAME_LPC {
-	SUBFRAME_LPC_VALUE value;
-	RESIDUAL residual;
-};
-
-
-struct SUBFRAME {
-	SUBFRAME_HEADER header;
-	
-	if (header.type == 0b00000)
-		SUBFRAME_CONSTANT constant;
-	else if (header.type == 0b000001)
-		SUBFRAME_VERBATIM verbatim;
-	else if ((header.type >> 3) == 0b001 && (header.type & 0b111) <= 4)
-		SUBFRAME_FIXED fixed;
-	else if (header.type == 0b100000)
-		SUBFRAME_LPC lpc;
-};
-
-struct FRAME {
-	FRAME_HEADER header;
-	SUBFRAME subframes[parent.metadata[0].data.flags.numChannels + 1];
-	FRAME_FOOTER footer;
-};
-
-
-struct METADATA_BLOCK {
-	METADATA_BLOCK_HEADER header;
-	if (header.lastMetadataBlock)
-		break;
-	
-	if (header.blockType == BLOCK_TYPE::STREAMINFO)
-		METADATA_BLOCK_STREAMINFO data;
-	else if (header.blockType == BLOCK_TYPE::PADDING)
-		METADATA_BLOCK_PADDING data;
-	else if (header.blockType == BLOCK_TYPE::APPLICATION)
-		METADATA_BLOCK_APPLICATION data;
-	else if (header.blockType == BLOCK_TYPE::VORBIS_COMMENT)
-		METADATA_BLOCK_VORBIS_COMMENT data;
-	else if (header.blockType == BLOCK_TYPE::CUESHEET)
-		METADATA_BLOCK_CUESHEET data;
-	else if (header.blockType == BLOCK_TYPE::PICTURE)
-		METADATA_BLOCK_PICTURE data;
-	else
-		std::error("Invalid metadata block type!");
-};
-
-struct STREAM {
-	char magic[4];
-	METADATA_BLOCK metadata[while(true)];
-	//FRAME frames[while(!std::mem::eof())];
-};
-
+#include <std/sys.pat>
+#include <std/core.pat>
+#include <std/io.pat>
+
+#pragma endian big
+
+using BitfieldOrder = std::core::BitfieldOrder;
+
+u32 sampleSize;
+u32 bitsPerSample;
+
+// METADATA
+
+enum BLOCK_TYPE : u8 {
+	STREAMINFO = 0,
+	PADDING = 1,
+	APPLICATION = 2,
+	SEEKTABLE = 3,
+	VORBIS_COMMENT = 4,
+	CUESHEET = 5,
+	PICTURE = 6,
+	
+	INVALID = 127
+};
+
+bitfield METADATA_BLOCK_HEADER {
+	lastMetadataBlock 	: 1;
+	blockType 			: 7;
+	length				: 24;
+};
+
+bitfield STREAMINFO_FLAGS {
+	sampleRate 			: 20;
+	numChannels 		: 3 [[format("format_channels")]];
+	bitsPerSample 		: 5;
+	numSamplesInStream	: 36;
+} [[inline]];
+
+fn format_channels(u8 value) {
+	return value + 1;
+};
+
+struct METADATA_BLOCK_STREAMINFO {
+	u16 minBlockSize, maxBlockSize;
+	u24 minFrameSize, maxFrameSize;
+	STREAMINFO_FLAGS flags;
+	u128 md5Signature;
+	
+	bitsPerSample = flags.bitsPerSample;
+};
+
+struct METADATA_BLOCK_PADDING {
+	padding[parent.header.length];
+};
+
+struct METADATA_BLOCK_APPLICATION {
+	char applicationID[4];
+	u8 applicationData[parent.header.length - sizeof(applicationID)];
+};
+
+struct SEEKPOINT {
+	u64 sampleNumber;
+	u64 byteOffset;
+	u16 numSamples;
+};
+
+struct METADATA_BLOCK_SEEKTABLE {
+	SEEKPOINT seekPoints[parent.header.length / 18];
+};
+
+struct VORBIS_USER_COMMENT {
+	le u32 length;
+	char comment[length];
+};
+
+struct METADATA_BLOCK_VORBIS_COMMENT {
+	le u32 vendorLength;
+	u8 vendor[vendorLength];
+	
+	le u32 userCommentListLength;
+	VORBIS_USER_COMMENT userCommentList[userCommentListLength];
+};
+
+bitfield TRACK_FLAGS {
+	audioTrack 	: 1;
+	preEmphasis : 1;
+} [[inline,bitfield_order(BitfieldOrder::LeastToMostSignificant, 8)]];
+
+struct CUESHEET_TRACK_INDEX {
+	u64 sampleOffset;
+	u8 indexPointNumber;
+	padding[3];
+};
+
+struct CUESHEET_TRACK {
+	u64 trackOffset;
+	u8 trackNumber;
+	char trackISRC[12];
+	TRACK_FLAGS flags;
+	padding[13];
+	u8 numTrackIndexPoints;
+	CUESHEET_TRACK_INDEX indexes[numTrackIndexPoints];
+};
+
+struct METADATA_BLOCK_CUESHEET {
+	char mediaCatalogNumber[128];
+	u64 numLeadInSamples;
+	bool isCD;
+	padding[258];
+	u8 numTracks;
+	CUESHEET_TRACK tracks[numTracks];
+};
+
+enum PICTURE_TYPE : u32 {
+	Other 				= 0,
+	FileIcon 			= 1,
+	OtherFileIcon 		= 2,
+	CoverFront			= 3,
+	CoverBack			= 4,
+	LeafletPage			= 5,
+	Media				= 6,
+	LeadArtist			= 7,
+	Artist				= 8,
+	Conductor			= 9,
+	Band				= 10,
+	Composer			= 11,
+	Lyricist			= 12,
+	RecordingLocation	= 13,
+	DuringRecording		= 14,
+	DuringPerformance	= 15,
+	MovieScreenCapture	= 16,
+	ABrightColoredFish	= 17,
+	Illustration		= 18,
+	BandLogoType		= 19,
+	PublisherLogoType	= 20
+};
+
+struct METADATA_BLOCK_PICTURE {
+	PICTURE_TYPE pictureType;
+	u32 mimeTypeLength;
+	char mimeType[mimeTypeLength];
+	u32 descriptionLength;
+	char description[descriptionLength];
+	u32 width, height;
+	u32 colorDepth;
+	u32 colorCount;
+	u32 pictureDataLength;
+	u8 pictureData[pictureDataLength];
+};
+
+
+
+// FRAME DATA
+// TODO: THIS IS INCOMPLETE / NOT WORKING CURRENTLY
+
+bitfield FRAME_HEADER_FLAGS {
+	syncCode			: 14;
+	padding				: 1;
+	blockingStrategy	: 1;
+	blockSize			: 4;
+	sampleRate			: 4;
+	channelAssignment	: 4;
+	sampleSize			: 3;
+} [[inline,bitfield_order(BitfieldOrder::LeastToMostSignificant, 32)]];
+
+struct FRAME_HEADER {
+	FRAME_HEADER_FLAGS flags;
+	
+	sampleSize = flags.sampleSize;
+	
+	if (flags.blockingStrategy)
+		char16 sampleNumber[7];
+	else
+		char16 frameNumber[6];
+	
+	if (flags.blockSize == 0b0110)
+		u8 blockSize;
+	else if (flags.blockSize == 0b0111)
+		u16 blockSize;
+		
+	if (flags.sampleRate == 0b1100)
+		u8 sampleRate;
+	else if (flags.sampleRate == 0b1101 || flags.sampleRate == 0b1110)
+		u16 sampleRate;
+		
+	u8 crc8;
+};
+
+struct FRAME_FOOTER {
+	u16 crc16;
+};
+
+bitfield SUBFRAME_HEADER {
+	padding	: 1;
+	type	: 6;
+	wastedBits : 1;
+};
+
+fn getBitsPerSample() {
+	if (sampleSize == 0b000)
+		return bitsPerSample;
+	else if (sampleSize == 0b001)
+		return 8;
+	else if (sampleSize == 0b010)
+		return 12;
+	else if (sampleSize == 0b100)
+		return 16;
+	else if (sampleSize == 0b101)
+		return 20;
+	else if (sampleSize == 0b110)
+		return 24;
+    else
+		std::error(std::format("Invalid sample size {}.", sampleSize));
+};
+
+bitfield SUBFRAME_CONSTANT {
+	value : getBitsPerSample();
+};
+
+bitfield SUBFRAME_VERBATIM {
+	value : getBitsPerSample() * parent.parent.header.flags.blockSize;
+};
+
+bitfield SUBFRAME_FIXED_VALUE {
+	value : getBitsPerSample() * (parent.parent.header.type & 0b111);
+	codingMethod : 2;
+} [[inline]];
+
+bitfield RESIDUAL_CODING_METHOD_PARTITIONED_RICE {
+	partitionOrder : 4;
+	riceParameter : 4;
+	if (riceParameter == 0b1111)
+		bitsPerSample : 5;
+};
+
+bitfield RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 {
+	partitionOrder : 4;
+	riceParameter  : 5;
+	if (riceParameter == 0b11111)
+		bitsPerSample : 5;
+};
+
+struct RESIDUAL {
+	if (parent.value.codingMethod == 0b00)
+		RESIDUAL_CODING_METHOD_PARTITIONED_RICE rice;
+	else if (parent.value.codingMethod == 0b01)
+		RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 rice;
+		
+		
+	if ((parent.parent.header.type & 0b111) == 0b000)
+		u8 samples[(getBitsPerSample() * (parent.parent.parent.header.flags.blockSize - (parent.parent.header.type & 0b111))) / 8];
+	else if (std::core::array_index() != 0)
+		u8 samples[(getBitsPerSample() * (parent.parent.parent.header.flags.blockSize / (1 << rice.partitionOrder))) / 8];
+	else
+		u8 samples[(getBitsPerSample() * ((parent.parent.parent.header.flags.blockSize / (1 << rice.partitionOrder)) - (parent.parent.header.type & 0b111))) / 8];
+};
+
+struct SUBFRAME_FIXED {
+	SUBFRAME_FIXED_VALUE value;
+	RESIDUAL residual;
+};
+
+bitfield SUBFRAME_LPC_VALUE {
+	warmUpSamples : getBitsPerSample() * ((parent.header.type & 0b011111) + 1);
+	quantizedLinearPredictorCoefficient : 4;
+	quantizedLinearPredictorCoefficientShift : 5;
+	predictorCoefficients : quantizedLinearPredictorCoefficient * ((parent.header.type & 0b011111) + 1);
+} [[inline]];
+
+struct SUBFRAME_LPC {
+	SUBFRAME_LPC_VALUE value;
+	RESIDUAL residual;
+};
+
+
+struct SUBFRAME {
+	SUBFRAME_HEADER header;
+	
+	if (header.type == 0b00000)
+		SUBFRAME_CONSTANT constant;
+	else if (header.type == 0b000001)
+		SUBFRAME_VERBATIM verbatim;
+	else if ((header.type >> 3) == 0b001 && (header.type & 0b111) <= 4)
+		SUBFRAME_FIXED fixed;
+	else if (header.type == 0b100000)
+		SUBFRAME_LPC lpc;
+};
+
+struct FRAME {
+	FRAME_HEADER header;
+	SUBFRAME subframes[parent.metadata[0].data.flags.numChannels + 1];
+	FRAME_FOOTER footer;
+};
+
+
+struct METADATA_BLOCK {
+	METADATA_BLOCK_HEADER header;
+	if (header.lastMetadataBlock)
+		break;
+	
+	if (header.blockType == BLOCK_TYPE::STREAMINFO)
+		METADATA_BLOCK_STREAMINFO data;
+	else if (header.blockType == BLOCK_TYPE::PADDING)
+		METADATA_BLOCK_PADDING data;
+	else if (header.blockType == BLOCK_TYPE::APPLICATION)
+		METADATA_BLOCK_APPLICATION data;
+	else if (header.blockType == BLOCK_TYPE::VORBIS_COMMENT)
+		METADATA_BLOCK_VORBIS_COMMENT data;
+	else if (header.blockType == BLOCK_TYPE::CUESHEET)
+		METADATA_BLOCK_CUESHEET data;
+	else if (header.blockType == BLOCK_TYPE::PICTURE)
+		METADATA_BLOCK_PICTURE data;
+	else
+		std::error("Invalid metadata block type!");
+};
+
+struct STREAM {
+	char magic[4];
+	METADATA_BLOCK metadata[while(true)];
+	//FRAME frames[while(!std::mem::eof())];
+};
+
 STREAM stream @ 0x00;
--- a/patterns/fs.hexpat
+++ b/patterns/fs.hexpat
@@ -13,7 +13,7 @@ bitfield CHS {
 	h : 8;
 	s : 6;
 	c : 10;
-} [[right_to_left, format("chs_formatter")]];
+} [[format("chs_formatter")]];

 fn chs_formatter(CHS chs) {
 	return std::format("({:X}, {:X}, {:X}) | 0x{:X}", chs.c, chs.h, chs.s, (chs.c * 16 + chs.h) * 63 + (chs.s - 1));
--- a/patterns/gb.hexpat
+++ b/patterns/gb.hexpat
@@ -0,0 +1,337 @@
+#include <type/size.pat>
+#include <std/io.pat>
+#include <std/string.pat>
+
+#pragma MIME application/x-gameboy-rom
+
+namespace format {
+    
+    fn rom_type(u8 romType) {
+        u32 romSize = 32768 * (1 << romType);
+        u16 romBanks = 2 * (1 << romType);
+        if(romType == 0x52) {
+            romSize = 1153434;
+            romBanks = 72;
+        } 
+        if(romType == 0x53) {
+            romSize = 1258291;
+            romBanks = 80;
+        } 
+        return std::format("size: {}, banks: {}", type::impl::size_formatter(romSize), romBanks);
+    };
+    
+    fn ram_type(u8 ramType) {
+        u16 ramSize;
+        u16 ramBanks;
+        if(ramType == 2) {
+            ramSize = 8192;
+            ramBanks = 1;
+        }
+        if(ramType == 3) {
+            ramSize = 32768;
+            ramBanks = 4;
+        }
+        if(ramType == 4) {
+            ramSize = 131072;
+            ramBanks = 16;
+        }
+        if(ramType == 5) {
+            ramSize = 65536;
+            ramBanks = 8;
+        }
+        return std::format("size: {}, banks: {}", type::impl::size_formatter(ramSize), ramBanks);
+    };
+    
+    fn rom_features(u8 type) {
+        str result = "( ";
+        match(type) {
+            (0x00): result += "no_mbc ";
+            (0x01): result += "mbc1 ";
+            (0x02): result += "mbc1 | ram "; 
+            (0x03): result += "mbc1 | ram | battery ";
+            (0x05): result += "mbc2 "; 
+            (0x06): result += "mbc2 | battery ";
+            (0x08): result += "no_mbc | ram "; 
+            (0x09): result += "no_mbc | ram | battery ";
+            (0x0B): result += "mmm01 "; 
+            (0x0C): result += "mmm01 | ram ";
+            (0x0D): result += "mmm01 | ram | battery "; 
+            (0x0F): result += "mbc3 | timer | battery ";
+            (0x10): result += "mbc3 | timer | ram | battery "; 
+            (0x11): result += "mbc3 ";
+            (0x12): result += "mbc3 | ram "; 
+            (0x13): result += "mbc3 | ram | battery ";
+            (0x19): result += "mbc5 "; 
+            (0x1A): result += "mbc5 | ram ";
+            (0x1B): result += "mbc5 | ram | battery "; 
+            (0x1C): result += "mbc5 | rumble ";
+            (0x1D): result += "mbc5 | rumble | ram "; 
+            (0x1E): result += "mbc5 | rumble | ram | battery ";
+            (0x20): result += "mbc6 "; 
+            (0x22): result += "mbc7 | sensor | rumble ";
+            (0xFC): result += "camera "; 
+            (0xFD): result += "tama5 ";
+            (0xFE): result += "huc3 "; 
+            (0xFF): result += "huc1 | ram | battery ";
+        }
+        return result + ")"; 
+    };
+    
+    fn licensee_code(u8 code) {
+        match(code) {
+            (0x00): return "None";
+            (0x01 | 0x31): return "Nintendo";
+            (0x08 | 0x38): return "Capcom";
+            (0x09): return "Hot-B";
+            (0x0A | 0xE0): return "Jaleco";
+            (0x0B): return "Coconuts Japan";
+            (0x0C | 0x6E): return "Elite Systems";
+            (0x13 | 0x69): return "EA (Electronic Arts)";
+            (0x18): return "Hudsonsoft";
+            (0x19): return "ITC Entertainment";
+            (0x1A): return "Yanoman";
+            (0x1D): return "Japan Clary";
+            (0x1F | 0x4A | 0x61): return "Virgin Interactive";
+            (0x24): return "PCM Complete";
+            (0x25): return "San-X";
+            (0x28): return "Kotobuki Systems";
+            (0x29): return "Seta";
+            (0x30 | 0x70): return "Infogrames";
+            (0x32 | 0xA2 | 0xB2 | 0xC4): return "Bandai";
+            (0x33): return "See new licensee";
+            (0x34 | 0xA4): return "Konami";
+            (0x35): return "HectorSoft";
+            (0x39 | 0x9D): return "Banpresto";
+            (0x3C): return ".Entertainment i";
+            (0x3E): return "Gremlin";
+            (0x41): return "Ubisoft";
+            (0x42 | 0xEB): return "Atlus";
+            (0x44 | 0x4D): return "Malibu";
+            (0x46 | 0xCF): return "Angel";
+            (0x47): return "Spectrum Holoby";
+            (0x49): return "Irem";
+            (0x50): return "Absolute";
+            (0x51 | 0xB0): return "Acclaim";
+            (0x52): return "Activision";
+            (0x53): return "American Sammy";
+            (0x54): return "GameTek";
+            (0x55): return "Park Place";
+            (0x56 | 0xDB | 0xFF): return "LJN";
+            (0x57): return "Matchbox";
+            (0x59): return "Milton Bradley";
+            (0x5A): return "Mindscape";
+            (0x5B): return "Romstar";
+            (0x5C | 0xD6): return "Naxat Soft";
+            (0x5D): return "Tradewest";
+            (0x60): return "Titus";
+            (0x67): return "Ocean Interactive";
+            (0x6F): return "Electro Brain";
+            (0x71): return "Interplay";
+            (0x72 | 0xAA): return "Broderbund";
+            (0x73): return "Sculptered Soft";
+            (0x75): return "The Sales Curve";
+            (0x78): return "t.hq";
+            (0x79): return "Accolade";
+            (0x7A): return "Triffix Entertainment";
+            (0x7C): return "Microprose";
+            (0x7F | 0xC2): return "Kemco";
+            (0x80): return "Misawa Entertainment";
+            (0x83): return "Lozc";
+            (0x86 | 0xC4): return "Tokuma Shoten Intermedia";
+            (0x8B): return "Bullet-Proof Software";
+            (0x8C): return "Vic Tokai";
+            (0x8E): return "Ape";
+            (0x8F): return "I'Max";
+            (0x91): return "Chunksoft Co.";
+            (0x92): return "Video System";
+            (0x93): return "Tsubaraya Productions Co.";
+            (0x95): return "Varie Corporation";
+            (0x96): return "Yonezawa/S’Pal";
+            (0x97): return "Kaneko";
+            (0x99): return "Arc";
+            (0x9A): return "Nihon Bussan";
+            (0x9B): return "Tecmo";
+            (0x9C): return "Imagineer";
+            (0x9F): return "Nova";
+            (0xA1): return "Hori Electric";
+            (0xA6): return "Kawada";
+            (0xA7): return "Takara";
+            (0xA9): return "Technos Japan";
+            (0xAC): return "Toei Animation";
+            (0xAD): return "Toho";
+            (0xAF): return "Namco";
+            (0xB1): return "ASCII or Nexsoft";
+            (0xB4): return "Square Enix";
+            (0xB6): return "HAL Laboratory";
+            (0xB7): return "SNK";
+            (0xB9 | 0xCE): return "Pony Canyon";
+            (0xBA): return "Culture Brain";
+            (0xBB): return "Sunsoft";
+            (0xBD): return "Sony Imagesoft";
+            (0xBF): return "Sammy";
+            (0xC0 | 0xD0): return "Taito";
+            (0xC3): return "Squaresoft";
+            (0xC5): return "Data East";
+            (0xC6): return "Tonkinhouse";
+            (0xC8): return "Koei";
+            (0xC9): return "UFL";
+            (0xCA): return "Ultra";
+            (0xCB): return "Vap";
+            (0xCC): return "Use Corporation";
+            (0xCD): return "Meldac"; 
+            (0xD1): return "Sofel";
+            (0xD2): return "Quest";
+            (0xD3): return "Sigma Enterprises";
+            (0xD4): return "ASK Kodansha Co.";
+            (0xD7): return "Copya System";
+            (0xDA): return "Tomy";
+            (0xDD): return "NCS";
+            (0xDE): return "Human";
+            (0xDF): return "Altron";
+            (0xE1): return "Towa Chiki";
+            (0xE2): return "Yutaka";
+            (0xE3): return "Varie";
+            (0xE5): return "Epoch";
+            (0xE7): return "Athena";
+            (0xE8): return "Asmik";
+            (0xE9): return "Natsume";
+            (0xEA): return "King Records";
+            (0xEE): return "IGS";
+            (0xF0): return "A Wave";
+            (0xF3): return "Extreme Entertainment";
+        }
+        return "Unknown Licensee";
+    };
+    
+    fn new_licensee_code(str a) {        
+        if(a[0] == 0 && a[1] == 0) return "See old licensee";
+        match(a) {
+            ("00"): return "None";
+            ("01"): return "Nintendo R&D1";
+            ("08"): return "Capcom";
+            ("13"): return "Electronic Arts";
+            ("18"): return "Hudson Soft";
+            ("19"): return "b-ai";
+            ("20"): return "kss";
+            ("22"): return "pow";
+            ("24"): return "PCM Complete";
+            ("25"): return "san-x";
+            ("28"): return "Kemco Japan";
+            ("29"): return "seta";
+            ("30"): return "Viacom";
+            ("31"): return "Nintendo";
+            ("32"): return "Bandai";
+            ("33"): return "Ocean/Acclaim";
+            ("34"): return "Konami";
+            ("35"): return "Hector";
+            ("37"): return "Taito";
+            ("38"): return "Hudson";
+            ("39"): return "Banpresto";
+            ("41"): return "Ubi Soft";
+            ("42"): return "Atlus";
+            ("44"): return "Malibu";
+            ("46"): return "angel";
+            ("47"): return "Bullet-Proof";
+            ("49"): return "irem";
+            ("50"): return "Absolute";
+            ("51"): return "Acclaim";
+            ("52"): return "Activision";
+            ("53"): return "American sammy";
+            ("54"): return "Konami";
+            ("55"): return "Hi tech entertainment";
+            ("56"): return "LJN";
+            ("57"): return "Matchbox";
+            ("58"): return "Mattel";
+            ("59"): return "Milton Bradley";
+            ("60"): return "Titus";
+            ("61"): return "Virgin";
+            ("64"): return "LucasArts";
+            ("67"): return "Ocean";
+            ("69"): return "Electronic Arts";
+            ("70"): return "Infogrames";
+            ("71"): return "Interplay";
+            ("72"): return "Broderbund";
+            ("73"): return "sculptured";
+            ("75"): return "sci";
+            ("78"): return "THQ";
+            ("79"): return "Accolade";
+            ("80"): return "misawa";
+            ("83"): return "lozc";
+            ("86"): return "Tokuma Shoten Intermedia";
+            ("87"): return "Tsukuda Original";
+            ("91"): return "Chunksoft";
+            ("92"): return "Video system";
+            ("93"): return "Ocean/Acclaim";
+            ("95"): return "Varie";
+            ("96"): return "Yonezawa/s’pal";
+            ("97"): return "Kaneko";
+            ("99"): return "Pack in soft";
+            ("A4"): return "Konami (Yu-Gi-Oh!)";
+        }
+        return "Unknown";
+    };
+}
+
+bitfield pixel_packed {
+    p1 : 1;
+    p2 : 1;
+    p3 : 1;
+    p4 : 1;
+    p5 : 1;
+    p6 : 1;
+    p7 : 1;
+    p8 : 1;
+};
+
+enum CGB : u8 {
+    NO_CGB = 0x00 ... 0x7F,
+    BACKWARDS_COMPATIBLE = 0x80,
+    CGB_ONLY = 0xC0
+};
+
+  
+struct Logo {
+    pixel_packed rawData[0x30];
+};
+
+struct JumpVectors {
+    u8 rst1[8] [[comment("rst $1")]];
+    u8 rst2[8] [[comment("rst $2")]];
+    u8 rst3[8] [[comment("rst $3")]];
+    u8 rst4[8] [[comment("rst $4")]];
+    u8 rst5[8] [[comment("rst $5")]];;
+    u8 rst6[8] [[comment("rst $6")]];
+    u8 rst7[8] [[comment("rst $7")]];
+    u8 rst8[8] [[comment("rst $8")]];
+    u8 int1[8] [[comment("vblank")]];
+    u8 int2[8] [[comment("lcd stat")]];
+    u8 int3[8] [[comment("timer")]];
+    u8 int4[8] [[comment("serial")]];
+    u8 int5[8] [[comment("joypad")]];
+};
+    
+struct Header {
+    u32 jmpInstruction;
+    Logo logo;
+    char title[0xF];
+    CGB cgb;
+    char newLicenseeCode[2] [[format("format::new_licensee_code")]];
+    bool sgbFlag;
+    u8 type [[format("format::rom_features")]];
+    u8 romType [[format("format::rom_type")]];
+    u8 ramType [[format("format::ram_type")]];
+    bool japanOnly;
+    u8 licenseeCode [[format("format::licensee_code")]];
+    u8 version;
+    u8 checksum [[comment("Checksum for: $134-$14C")]];
+    u16 gloalChecksum [[comment("Checksum for entire range")]];
+};
+
+struct Cartrige {
+    JumpVectors jumpVectors [[comment("Instructions called on interupts or rst instructions")]];
+    padding[0x100 - sizeof(JumpVectors)];
+    Header header;
+};
+
+
+Cartrige cart @ 0x00;
--- a/patterns/gif.hexpat
+++ b/patterns/gif.hexpat
@@ -1,153 +1,183 @@
-#include <std/mem.pat>
-
 #pragma MIME image/gif

-#pragma bitfield_order left_to_right
+// Extension Labels
+#define LABEL_GC 0xF9
+#define LABEL_COMMENT 0xFE
+#define LABEL_APPLICATION 0xFF
+#define LABEL_PLAINTEXT 0x01

-// gif89a
+// Indentifier Magics
+#define IMAGE_SEPERATOR_MAGIC 0x2C
+#define EXTENSION_INTRODUCER_MAGIC 0x21
+#define GIF_TRAILER_MAGIC 0x3B

-struct data_subblock_t {
-    u8 block_size;
-    u8 data_values[block_size];
+#include <std/io.pat>
+#include <std/core.pat>
+#include <std/mem.pat>
+#include <std/string.pat>
+#include <std/math.pat>
+
+#include <type/magic.pat>
+
+bitfield GCT_Flags {
+    size : 3 [[comment("physical size = 2^(flags.size + 1)")]];
+    sort : 1 [[comment("Indicates if the table is sorted by importance")]];
+    colorRes : 3 [[comment("Indicates the richness of the original pallet")]];
+    enabled : 1;
+};
+    
+bitfield ImageDescriptorFlags {
+    lctSize: 3;
+    reserved: 2;
+    lctSort: 1;
+    interlaceFlag: 1;
+    lctEnable: 1;
+};
+    
+bitfield GCE_Flags {
+    transparent : 1;
+    userInput : 1;
+    disposalMode : 3 [[format("format::dispose_enum")]];
+    reserved : 3;
 };

-struct data_subblocks_t {
-    data_subblock_t data[while (std::mem::read_unsigned($, 1) != 0x00)];
-    u8 block_terminator;        // 0x00
-} [[inline]];
+struct Color {
+  u8 red;
+  u8 green;
+  u8 blue;
+} [[color(std::format("{:02X}{:02X}{:02X}", red, green, blue))]];

-struct header_t {
-    char header[3];
+struct _SubBlocks {
+    u8 data_size;
+    u8 data[data_size];
+};
+
+struct DataSubBlocks {
+    _SubBlocks subBlocks[while(std::mem::read_unsigned($, 1) != 0)];
+};
+
+struct Header {
+    type::Magic<"GIF"> magic;
    char version[3];
 };

-bitfield lsd_fields_t {
-    global_color_table_flag : 1;
-    color_resolution        : 3;
-    sort_flag               : 1;
-    size_of_global_color_table : 3;
-} [[inline]];
-
-struct logical_screen_descriptor_t {
+struct LogicalScreenDescriptor {
    u16 width;
    u16 height;
-    lsd_fields_t fields;
-    u8 background_color_index;
-    u8 pixel_aspect_ratio;
+    GCT_Flags gctFlags;
+    u8 bgColorIndex;
+    u8 pixelAscpet;
+    if (gctFlags.enabled) {
+        Color gct[std::math::pow(2, gctFlags.size + 1)];
+    }
 };

-struct color_table_entry_t {
-    u8 red;
-    u8 green;
-    u8 blue;
+struct ImageDescriptor {
+    u16 imageLeftPosition;
+    u16 imageTopPosition;
+    u16 imageWidth;
+    u16 imageHeight;
+    ImageDescriptorFlags flags;
+    if(flags.lctEnable) {
+        Color lct[std::math::pow(2, flags.lctSize + 1)];
+    }
+    u8 lzwMinCode [[comment("This byte determines the initial number of bits used for LZW codes in the image data")]];
+    DataSubBlocks lzwCompressedData [[comment("Data is pallet indecies either into current LDC or GCT and is compressed using LZW")]];
 };

-bitfield gce_fields_t {
-    padding         : 3;
-    disposal_method : 3;
-    user_input_flag : 1;
-    transparent_color_flag : 1;
-} [[inline]];
-
-struct graphic_coltrol_extension_t {
-    u8 extension_introducer;    // 0x21
-    u8 graphic_control_label;   // 0xf9
-    u8 block_size;
-    gce_fields_t fields;
-    u16 delay_time;
-    u8 transparent_color_index;
-    u8 block_terminator;
+struct CommentExtension {
+    DataSubBlocks commentData;
 };

-struct comment_extension_t {
-    u8 extension_introducer;    // 0x21
-    u8 comment_label;           // 0xfe
-    data_subblocks_t comment_data;
+struct ApplicationExtension {
+    u8 blockSize;
+    char identifier[8];
+    char authenticationCode[3];
+    DataSubBlocks applicationData;
 };

-struct plaintext_extension_t {
-    u8 extension_introducer;    // 0x21
-    u8 plain_text_label;        // 0x01
-
-    u8 block_size;              // 12
-    u16 text_grid_left_position;
-    u16 text_grid_top_position;
-    u16 text_grid_width;
-    u16 text_grid_height;
-    u8 character_cell_width;
-    u8 character_cell_height;
-    u8 text_foreground_color_index;
-    u8 text_background_color_index;
-    data_subblocks_t plain_text_data;
-};
-
-struct application_extension_t {
-    u8 extension_introducer;    // 0x21
-    u8 extension_label;         // 0xff
-
-    u8 block_size;              // 11
-    u8 application_identifier[8];
-    u8 application_authentication_code[3];
+struct PlainTextExtension {
+    u8 blockSize;
+    u16 textGridLeftPos;
+    u16 textGridTopPos;
+    u16 textGridWidth;
+    u16 textGridHeight;
+    u8 charCellWidth;
+    u8 charCellHeight;
+    u8 textForegroundColorIndex;
+    u8 textBackgroundColorIndex;
+    DataSubBlocks plainTextData;
    
-    data_subblocks_t data;
 };

-bitfield id_fields_t {
-    local_color_table : 1;
-    interlace_flag    : 1;
-    sort_fla          : 1;
-    padding           : 2;
-    size_of_local_color_table : 3;
-} [[inline]];
-
-struct image_descriptor_t {
-    u8 image_separator;         // 0x2c
-    u16 image_left_position;
-    u16 image_top_position;
-    u16 image_width;
-    u16 image_height;
-    id_fields_t fields;
+struct GraphicControlExtension {
+    u8 blockSize;
+    std::assert_warn(blockSize == 4, "Unexpected GCE block size");
+    GCE_Flags flags;
+    u16 delay [[format("format::delay")]];
+    u8 transparentColorIndex;
 };

-struct table_based_image_t {
-    u8 lzw_minimum_code_size;
-    data_subblocks_t data;
+struct Extension {
+    u8 label [[format("format::extension_name")]];
+    if(label == LABEL_GC) GraphicControlExtension gce [[inline]];
+    if(label == LABEL_COMMENT) CommentExtension c [[inline]];
+    if(label == LABEL_APPLICATION) ApplicationExtension a [[inline]];
+    if(label == LABEL_PLAINTEXT) PlainTextExtension p [[inline]];
 };

-struct gif_block_t {
-    if (std::mem::read_unsigned($, 1) == 0x21) {
-        if (std::mem::read_unsigned($+1, 1) == 0x01) {
-            plaintext_extension_t plaintext_extension;
-        }
-        else if (std::mem::read_unsigned($+1, 1) == 0xf9) {
-            graphic_coltrol_extension_t graphic_coltrol_extension;
-        }
-        else if (std::mem::read_unsigned($+1, 1) == 0xfe) {
-            comment_extension_t comment;
-        } else {
-            application_extension_t application_extension;
-        }
-    }
-    else if (std::mem::read_unsigned($, 1) == 0x2c) {
-        image_descriptor_t image_descriptor;
-        if (image_descriptor.fields.local_color_table) {
-            color_table_entry_t local_color_table[1<<(image_descriptor.fields.size_of_local_color_table + 1)];
-        }
-        table_based_image_t image;
-    }
-} [[inline]];
+struct Block {
+    u8 identifier [[format("format::identifier_name")]];
+    if(identifier == IMAGE_SEPERATOR_MAGIC) ImageDescriptor i [[inline]];
+    if(identifier == EXTENSION_INTRODUCER_MAGIC) Extension e [[inline]];
+    if(identifier == GIF_TRAILER_MAGIC) break;
+    u8 blockTerminator;
+} [[format("format::block_name")]];

-struct gif_t {
-    header_t header;
-    logical_screen_descriptor_t logical_screen_descriptor;
-    if (logical_screen_descriptor.fields.global_color_table_flag) {
-        color_table_entry_t global_color_table[1<<(logical_screen_descriptor.fields.size_of_global_color_table + 1)];
-    }
+namespace format {
+    fn dispose_enum(u8 value) {
+        if(value == 0x00) return "Do nothing";
+        if(value == 0x01) return "Do not remove pixels";
+        if(value == 0x02) return "Restore background pixels";
+        if(value == 0x03) return "Restore previous pixels"; 
+    };
    
-    gif_block_t blocks[while (std::mem::read_unsigned($, 1) != 0x3b)];
+    fn extension_name(u8 label) {
+        if(label == LABEL_GC) return "Graphical Control Extension";
+        if(label == LABEL_COMMENT) return "Comment Extension";
+        if(label == LABEL_APPLICATION) return "Application Extension";
+        if(label == LABEL_PLAINTEXT) return "Plaintext Extension";
+        return "Unknown Extension";
+    };

-    u8 trailer;                 // 0x3b
-};
+    fn block_name(ref Block b) {
+        if(b.identifier == IMAGE_SEPERATOR_MAGIC) return "Image Descriptor";
+        if(b.identifier == EXTENSION_INTRODUCER_MAGIC) return "Extension";
+        if(b.identifier == GIF_TRAILER_MAGIC) return "Trailer";
+        return "Unknown Block Type";
+    };

-gif_t gif @ 0x00;
+    fn identifier_name(u8 identifier) {
+        if(identifier == IMAGE_SEPERATOR_MAGIC) return "Image Separator";
+        if(identifier == EXTENSION_INTRODUCER_MAGIC) return "Extension Introducer";
+        if(identifier == GIF_TRAILER_MAGIC) return "GIF Trailer";
+        return "Unknown Identifier";
+    };

+    fn delay(u16 delay) {
+        if(delay == -1) return "forever";
+        else if(delay < 2) return "100ms";
+        else return std::string::to_string(delay * 10) + "ms";
+        return "notime";
+    };
+}
+
+struct Gif {
+    u8 data[std::mem::size()] [[no_unique_address, hidden]];
+    Header header;
+    std::assert_warn(header.version == "89a" || header.version == "87a", "Unsupported format version");
+    LogicalScreenDescriptor logicalScreenDescriptor;
+    Block blocks[while(!std::mem::eof())];
+} [[hex::visualize("image", this.data)]];
+
+Gif gif @ 0x00;
--- a/patterns/gzip.hexpat
+++ b/patterns/gzip.hexpat
@@ -1,77 +1,79 @@
-#pragma MIME application/gzip
-
-#include <type/time.pat>
-#include <type/size.pat>
-#include <std/mem.pat>
-
-bitfield Flags {
-    FTEXT       : 1;
-    FHCRC       : 1;
-    FEXTRA      : 1;
-    FNAME       : 1;
-    FCOMMENT    : 1;
-    padding     : 3;
-} [[right_to_left]];
-
-bitfield ExtraFlags {
-    padding : 1;
-    maximumCompression : 1;
-    fastestCompression : 1;
-    padding : 5;
-};
-
-enum CompressionMethod : u8 {
-    Reserved = 0 ... 7,
-    Deflate = 8
-};
-
-enum OperatingSystemID : u8 {
-    FATFileSystem = 0x00,
-    Amiga = 0x01,
-    VMS = 0x02,
-    Unix = 0x03,
-    VM_CMS = 0x04,
-    AtariTOS = 0x05,
-    HPFSFileSystem = 0x06,
-    Macintosh = 0x07,
-    ZSystem = 0x08,
-    CP_M = 0x09,
-    TOPS_20 = 0x0A,
-    NTFSFileSystem = 0x0B,
-    QDOS = 0x0C,
-    AcordRISCOS = 0x0D,
-    Unknown = 0xFF
-};
-
-struct GZip {
-    u16 signature;
-    CompressionMethod compressionMethod;
-    Flags flags;
-    type::time32_t modificationTime;
-    ExtraFlags extraFlags;
-    OperatingSystemID operatingSystemId;
-    
-    if (flags.FEXTRA) {
-        u16 extraLength;
-        u8 extraField[extraLength];
-    }
-    
-    if (flags.FNAME) {
-        char originalFileName[];
-    }
-    
-    if (flags.FCOMMENT) {
-        char comment[];
-    }
-    
-    if (flags.FHCRC) {
-        u16 crc16;
-    }
-    
-    u8 data[while($ < std::mem::size() - 8)] [[sealed]];
-    
-    u32 crc32;
-    type::Size<u32> isize;
-};
-
+#pragma MIME application/gzip
+
+#include <type/time.pat>
+#include <type/size.pat>
+#include <std/core.pat>
+#include <std/mem.pat>
+
+using BitfieldOrder = std::core::BitfieldOrder;
+
+bitfield Flags {
+    FTEXT       : 1;
+    FHCRC       : 1;
+    FEXTRA      : 1;
+    FNAME       : 1;
+    FCOMMENT    : 1;
+} [[bitfield_order(BitfieldOrder::LeastToMostSignificant, 8)]];
+
+bitfield ExtraFlags {
+    padding : 1;
+    maximumCompression : 1;
+    fastestCompression : 1;
+    padding : 5;
+};
+
+enum CompressionMethod : u8 {
+    Reserved = 0 ... 7,
+    Deflate = 8
+};
+
+enum OperatingSystemID : u8 {
+    FATFileSystem = 0x00,
+    Amiga = 0x01,
+    VMS = 0x02,
+    Unix = 0x03,
+    VM_CMS = 0x04,
+    AtariTOS = 0x05,
+    HPFSFileSystem = 0x06,
+    Macintosh = 0x07,
+    ZSystem = 0x08,
+    CP_M = 0x09,
+    TOPS_20 = 0x0A,
+    NTFSFileSystem = 0x0B,
+    QDOS = 0x0C,
+    AcordRISCOS = 0x0D,
+    Unknown = 0xFF
+};
+
+struct GZip {
+    u16 signature;
+    CompressionMethod compressionMethod;
+    Flags flags;
+    type::time32_t modificationTime;
+    ExtraFlags extraFlags;
+    OperatingSystemID operatingSystemId;
+    
+    if (flags.FEXTRA) {
+        u16 extraLength;
+        u8 extraField[extraLength];
+    }
+    
+    if (flags.FNAME) {
+        char originalFileName[];
+    }
+    
+    if (flags.FCOMMENT) {
+        char comment[];
+    }
+    
+    if (flags.FHCRC) {
+        u16 crc16;
+    }
+    
+    u8 data[while($ < std::mem::size() - 8)] [[sealed]];
+    
+    u32 crc32;
+    type::Size<u32> isize;
+};
+
 GZip gzip @ 0x00;
--- a/patterns/ip.hexpat
+++ b/patterns/ip.hexpat
@@ -1,5 +1,4 @@
 #pragma endian big
- #pragma bitfield_order left_to_right

 #include <std/sys.pat>
 #include <std/io.pat>
--- a/patterns/java_class.hexpat
+++ b/patterns/java_class.hexpat
--- a/patterns/jpeg.hexpat
+++ b/patterns/jpeg.hexpat
@@ -0,0 +1,122 @@
+#include <std/mem.pat>
+#pragma endian big
+
+#pragma MIME image/jpeg
+
+enum Marker : u8 {
+    TEM     = 0x01,
+    SOF0    = 0xC0,
+    SOF1    = 0xC1,
+    SOF2    = 0xC2,
+    SOF3    = 0xC3,
+    DHT     = 0xC4,
+    SOF5    = 0xC5,
+    SOF6    = 0xC6,
+    SOF7    = 0xC7,
+    SOI     = 0xD8,
+    EOI     = 0xD9,
+    SOS     = 0xDA,
+    DQT     = 0xDB,
+    DNL     = 0xDC,
+    DRI     = 0xDD,
+    DHP     = 0xDE,
+    APP0    = 0xE0,
+    APP1    = 0xE1,
+    APP2    = 0xE2,
+    APP3    = 0xE3,
+    APP4    = 0xE4,
+    APP5    = 0xE5,
+    APP6    = 0xE6,
+    APP7    = 0xE7,
+    APP8    = 0xE8,
+    APP9    = 0xE9,
+    APP10   = 0xEA,
+    APP11   = 0xEB,
+    APP12   = 0xEC,
+    APP13   = 0xED,
+    APP14   = 0xEE,
+    APP15   = 0xEF,
+    COM     = 0xFE
+};
+
+enum DensityUnit : u8 {
+    NoUnit = 0x00,
+    PixelsPerInch = 0x01,
+    PixelsPerCm = 0x02
+};
+
+struct Pixel {
+    u8 r, g, b;
+} [[sealed, transform("transform_pixel")]];
+
+fn transform_pixel(Pixel pixel) {
+    return (0xFF << 24) | (pixel.b << 16) | (pixel.g << 8) | (pixel.r << 0);
+};
+
+
+struct APP0 {
+    char magic[5];
+    u8 versionMajor, versionMinor;
+    DensityUnit densityUnit;
+    u16 densityX, densityY;
+    u8 thumbnailX, thumbnailY;
+    Pixel thumbnail[thumbnailX * thumbnailY] [[sealed]];
+};
+
+enum ComponentId : u8 {
+    Y   = 1,
+    CB  = 2,
+    CR  = 3,
+    I   = 4,
+    Q   = 5
+};
+
+struct SOF0Component {
+    ComponentId componentId;
+    u8 samplingFactors;
+    u8 quantizationTableId;
+};
+
+struct SOF0 {
+    u8 bitsPerSample;
+    u16 imageHeight, imageWidth;
+    u8 numComponents;
+    SOF0Component components[numComponents];
+};
+
+struct SOSComponent {
+    ComponentId componentId;
+    u8 huffmanTable;
+};
+
+struct SOS {
+    u8 numComponents;
+    SOSComponent components[numComponents];
+    u8 startSpectralSelection;
+    u8 endSpectral;
+    u8 apprBitPos;
+    
+    u8 image_data[while(!std::mem::eof())] [[sealed]];
+};
+
+struct Segment {
+    u8 magic;
+    Marker marker;
+    
+    if (marker == Marker::SOI || marker == Marker::EOI) {
+        
+    } else {
+        u16 length;
+        if (marker == Marker::APP0) {
+            APP0 data;
+        } else if (marker == Marker::SOF0) {
+            SOF0 data;
+        } else if (marker == Marker::SOS) {
+            SOS data;
+        } else {
+            u8 data[length - sizeof(length)] [[sealed]];
+        }
+    }
+};
+
+Segment segments[while(!std::mem::eof())] @ 0x00 [[hex::visualize("image", this)]];
--- a/patterns/lnk.hexpat
+++ b/patterns/lnk.hexpat
@@ -1,459 +1,462 @@
-#pragma MIME application/x-ms-shortcut
-
-#include <type/guid.pat>
-#include <type/size.pat>
-
-bitfield LinkFlags {
-    HasLinkTargetIDList         : 1;
-    HasLinkInfo                 : 1;
-    HasName                     : 1;
-    HasRelativePath             : 1;
-    HasWorkingDir               : 1;
-    HasArguments                : 1;
-    HasIconLocation             : 1;
-    IsUnicode                   : 1;
-    ForceNoLinkInfo             : 1;
-    HasExpString                : 1;
-    RunInSeparateProcess        : 1;
-    padding                     : 1;
-    HasDarwinID                 : 1;
-    RunAsUser                   : 1;
-    HasExpIcon                  : 1;
-    NoPidlAlias                 : 1;
-    padding                     : 1;
-    RunWithShimLayer            : 1;
-    ForceNoLinkTrack            : 1;
-    EnableTargetMetadata        : 1;
-    DisableLinkPathTracking     : 1;
-    DisableKnownFolderTracking  : 1;
-    DisableKnownFolderAlias     : 1;
-    AllowLinkToLink             : 1;
-    UnaliasOnSave               : 1;
-    PreferEnvironmentPath       : 1;
-    KeepLocalIDListForUNCTarget : 1;
-    padding                     : 5;
-} [[right_to_left]];
-
-bitfield FileAttributesFlags {
-    FILE_ATTRIBUTE_READONLY             : 1;
-    FILE_ATTRIBUTE_HIDDEN               : 1;
-    FILE_ATTRIBUTE_SYSTEM               : 1;
-    padding                             : 1;
-    FILE_ATTRIBUTE_DIRECTORY            : 1;
-    FILE_ATTRIBUTE_ARCHIVE              : 1;
-    padding                             : 1;
-    FILE_ATTRIBUTE_NORMAL               : 1;
-    FILE_ATTRIBUTE_TEMPORARY            : 1;
-    FILE_ATTRIBUTE_SPARSE_FILE          : 1;
-    FILE_ATTRIBUTE_REPARSE_POINT        : 1;
-    FILE_ATTRIBUTE_COMPRESSED           : 1;
-    FILE_ATTRIBUTE_OFFLINE              : 1;
-    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  : 1;
-    FILE_ATTRIBUTE_ENCRYPTED            : 1;
-    padding                             : 17;
-} [[right_to_left]];
-
-bitfield ModifierKeys {
-    HOTKEYF_SHIFT   : 1;
-    HOTKEYF_CONTROL : 1;
-    HOTKEYF_ALT     : 1;
-    padding         : 5;
-} [[right_to_left]];
-
-enum Keys : u8 {
-    KEY_NONE    = 0x00,
-    KEY_0       = 0x30,
-    KEY_1       = 0x31,
-    KEY_2       = 0x32,
-    KEY_3       = 0x33,
-    KEY_4       = 0x34,
-    KEY_5       = 0x35,
-    KEY_6       = 0x36,
-    KEY_7       = 0x37,
-    KEY_8       = 0x38,
-    KEY_9       = 0x39,
-    KEY_A       = 0x41,
-    KEY_B       = 0x42,
-    KEY_C       = 0x43,
-    KEY_D       = 0x44,
-    KEY_E       = 0x45,
-    KEY_F       = 0x46,
-    KEY_G       = 0x47,
-    KEY_H       = 0x48,
-    KEY_I       = 0x49,
-    KEY_J       = 0x4A,
-    KEY_K       = 0x4B,
-    KEY_L       = 0x4C,
-    KEY_M       = 0x4D,
-    KEY_N       = 0x4E,
-    KEY_O       = 0x4F,
-    KEY_P       = 0x50,
-    KEY_Q       = 0x51,
-    KEY_R       = 0x52,
-    KEY_S       = 0x53,
-    KEY_T       = 0x54,
-    KEY_U       = 0x55,
-    KEY_V       = 0x56,
-    KEY_W       = 0x57,
-    KEY_X       = 0x58,
-    KEY_Y       = 0x59,
-    KEY_Z       = 0x5A,
-    
-    VK_F1       = 0x70,
-    VK_F2       = 0x71,
-    VK_F3       = 0x72,
-    VK_F4       = 0x73,
-    VK_F5       = 0x74,
-    VK_F6       = 0x75,
-    VK_F7       = 0x76,
-    VK_F8       = 0x77,
-    VK_F9       = 0x78,
-    VK_F10      = 0x79,
-    VK_F11      = 0x7A,
-    VK_F12      = 0x7B,
-    VK_F13      = 0x7C,
-    VK_F14      = 0x7D,
-    VK_F15      = 0x7E,
-    VK_F16      = 0x7F,
-    VK_F17      = 0x80,
-    VK_F18      = 0x81,
-    VK_F19      = 0x82,
-    VK_F20      = 0x83,
-    VK_F21      = 0x84,
-    VK_F22      = 0x85,
-    VK_F23      = 0x86,
-    VK_F24      = 0x87,
-    VK_NUMLOCK  = 0x90,
-    VK_SCROLL   = 0x91,
-};
-
-struct HotKeyFlags {
-    Keys Key;
-    ModifierKeys ModifierKeys;
-};
-
-struct FILETIME {
-    u32 dwLowDateTime;
-    u32 dwHighDateTime;
-};
-
-enum SHOWWINDOW_FLAGS : u32 {
-    SW_SHOWNORMAL       = 0x00000001,
-    SW_SHOWMAXIMIZED    = 0x00000003,
-    SW_SHOWMINNOACTIVE  = 0x00000007
-};
-
-struct ShellLinkHeader {
-    type::Size32 HeaderSize;
-    type::GUID LinkCLSID;
-    LinkFlags LinkFlags;
-    FileAttributesFlags FileAttributes;
-    FILETIME CreationTime, AccessTime, WriteTime;
-    type::Size32 FileSize;
-    u32 IconIndex;
-    SHOWWINDOW_FLAGS ShowCommand;
-    HotKeyFlags HotKey;
-    padding[2];
-    padding[4];
-    padding[4];	
-};
-
-struct ItemID {
-    type::Size16 ItemIDSize;
-    
-    if (ItemIDSize == 0x00)
-        break;
-    else
-        u8 Data[ItemIDSize - sizeof(ItemIDSize)];
-};
-
-struct IDList {
-    ItemID ItemIDList[while(true)];
-};
-
-struct LinkTargetIDList {
-    type::Size16 IDListSize;
-    IDList IDList[while($ < (addressof(IDListSize) + IDListSize))];
-};
-
-bitfield LinkInfoFlags {
-    VolumeIDAndLocalBasePath                    : 1;
-    CommonNetworkRelativeLinkAndPathSuffix	: 1;
-    padding                                     : 30;
-};
-
-enum DriveType : u32 {
-    DRIVE_UNKNOWN       = 0x00000000,
-    DRIVE_NO_ROOT_DIR   = 0x00000001,
-    DRIVE_REMOVABLE     = 0x00000002,
-    DRIVE_FIXED         = 0x00000003,
-    DRIVE_REMOTE        = 0x00000004,
-    DRIVE_CDROM         = 0x00000005,
-    DRIVE_RAMDISK       = 0x00000006
-};
-
-struct VolumeID {
-    type::Size32 VolumeIDSize;
-    DriveType DriveType;
-    u32 DriveSerialNumber;
-    u32 VolumeLabelOffset;
-    if (VolumeLabelOffset == 0x14)
-        u32 VolumeLabelOffsetUnicode;
-    char Data[VolumeIDSize - ($ - addressof(this))];
-};
-
-bitfield CommonNetworkRelativeLinkFlags {
-    ValidDevice     : 1;
-    ValidNetType    : 1;
-    padding         : 30;
-} [[right_to_left]];
-
-enum NetworkProviderType : u32 {
-    WNNC_NET_AVID           = 0x001A0000,
-    WNNC_NET_DOCUSPACE      = 0x001B0000,
-    WNNC_NET_MANGOSOFT      = 0x001C0000,
-    WNNC_NET_SERNET         = 0x001D0000,
-    WNNC_NET_RIVERFRONT1    = 0x001E0000,
-    WNNC_NET_RIVERFRONT2    = 0x001F0000,
-    WNNC_NET_DECORB         = 0x00200000,
-    WNNC_NET_PROTSTOR       = 0x00210000,
-    WNNC_NET_FJ_REDIR       = 0x00220000,
-    WNNC_NET_DISTINCT       = 0x00230000,
-    WNNC_NET_TWINS          = 0x00240000,
-    WNNC_NET_RDR2SAMPLE     = 0x00250000,
-    WNNC_NET_CSC            = 0x00260000,
-    WNNC_NET_3IN1           = 0x00270000,
-    WNNC_NET_EXTENDNET      = 0x00290000,
-    WNNC_NET_STAC           = 0x002A0000,
-    WNNC_NET_FOXBAT         = 0x002B0000,
-    WNNC_NET_YAHOO          = 0x002C0000,
-    WNNC_NET_EXIFS          = 0x002D0000,
-    WNNC_NET_DAV            = 0x002E0000,
-    WNNC_NET_KNOWARE        = 0x002F0000,
-    WNNC_NET_OBJECT_DIRE    = 0x00300000,
-    WNNC_NET_MASFAX         = 0x00310000,
-    WNNC_NET_HOB_NFS        = 0x00320000,
-    WNNC_NET_SHIVA          = 0x00330000,
-    WNNC_NET_IBMAL          = 0x00340000,
-    WNNC_NET_LOCK           = 0x00350000,
-    WNNC_NET_TERMSRV        = 0x00360000,
-    WNNC_NET_SRT            = 0x00370000,
-    WNNC_NET_QUINCY         = 0x00380000,
-    WNNC_NET_OPENAFS        = 0x00390000,
-    WNNC_NET_AVID1          = 0x003A0000,
-    WNNC_NET_DFS            = 0x003B0000,
-    WNNC_NET_KWNP           = 0x003C0000,
-    WNNC_NET_ZENWORKS       = 0x003D0000,
-    WNNC_NET_DRIVEONWEB     = 0x003E0000,
-    WNNC_NET_VMWARE         = 0x003F0000,
-    WNNC_NET_RSFX           = 0x00400000,
-    WNNC_NET_MFILES         = 0x00410000,
-    WNNC_NET_MS_NFS         = 0x00420000,
-    WNNC_NET_GOOGLE         = 0x00430000
-};
-
-struct CommonNetworkRelativeLink {
-    type::Size32 CommonNetworkRelativeLinkSize;
-    CommonNetworkRelativeLinkFlags CommonNetworkRelativeLinkFlags;
-    u32 NetNameOffset;
-    u32 DeviceNameOffset;
-    NetworkProviderType NetworkProviderType;
-    
-    if (NetNameOffset > 0x14) {
-        u32 NetNameOffsetUnicode;
-        u32 DeviceNameOffsetUnicode;
-    }
-    
-    char NetName[];
-    char DeviceName[];
-        
-    if (NetNameOffset > 0x14) {
-        char16 NetNameUnicode[];
-        char16 DeviceNameUnicode[];
-    }
-};
-
-struct LinkInfo {
-    type::Size32 LinkInfoSize;
-    type::Size32 LinkInfoHeaderSize;
-    LinkInfoFlags LinkInfoFlags;
-    u32 VolumeIDOffset;
-    u32 LocalBasePathOffset;
-    u32 CommonNetworkRelativeLinkOffset;
-    u32 CommonPathSuffixOffset;
-    
-    if (LinkInfoHeaderSize >= 0x24) {
-        u32 LocalBasePathOffsetUnicode;
-        u32 CommonPathSuffixOffsetUnicode;
-    }
-    
-    if (LinkInfoFlags.VolumeIDAndLocalBasePath) {
-        VolumeID VolumeID;
-        char LocalBasePath[];
-    }	
-    
-    if (LinkInfoFlags.CommonNetworkRelativeLinkAndPathSuffix)
-        CommonNetworkRelativeLink CommonNetworkRelativeLink;
-        
-    char CommonPathSuffix[];
-    
-    if (LinkInfoHeaderSize >= 0x24) {
-        if (LinkInfoFlags.VolumeIDAndLocalBasePath)
-            char16 LocalBasePathUnicode[];
-        char16 CommonPathSuffixUnicode[];
-    }
-};
-
-struct String {
-    u16 CountCharacters;
-    char16 String[CountCharacters];
-};
-
-struct StringData {
-    if (parent.ShellLinkHeader.LinkFlags.HasName)
-        String NAME_STRING;
-    if (parent.ShellLinkHeader.LinkFlags.HasRelativePath)
-        String RELATIVE_PATH;
-    if (parent.ShellLinkHeader.LinkFlags.HasWorkingDir)
-        String WORKING_DIR;
-    if (parent.ShellLinkHeader.LinkFlags.HasArguments)
-        String COMMAND_LINE_ARGUMENTS;
-    if (parent.ShellLinkHeader.LinkFlags.HasIconLocation)
-        String ICON_LOCATION;
-};
-
-bitfield FillAttributes {
-    FOREGROUND_BLUE         : 1;
-    FOREGROUND_GREEN        : 1;
-    FOREGROUND_RED          : 1;
-    FOREGROUND_INTENSITY    : 1;
-    
-    BACKGROUND_BLUE         : 1;
-    BACKGROUND_GREEN        : 1;
-    BACKGROUND_RED          : 1;
-    BACKGROUND_INTENSITY    : 1;
-    
-    padding                 : 8;
-} [[right_to_left]];
-
-struct ConsoleDataBlock {
-    FillAttributes FillAttributes;
-    FillAttributes PopupFillAttributes;
-    u16 ScreenBufferSizeX, ScreenBufferSizeY;
-    u16 WindowSizeX, WindowSizeY;
-    u16 WindowOriginX, WindowOriginY;
-    padding[4];
-    padding[4];
-    u32 FontSize;
-    u32 FontFamily;
-    u32 FontWeight;
-    char16 FaceName[32];
-    u32 CursorSize;
-    u32 FullScreen;
-    u32 QuickEdit;
-    u32 InsertMode;
-    u32 AutoPosition;
-    u32 HistoryBufferSize;
-    u32 NumberOfHistoryBuffers;
-    u32 HistoryNoDup;
-    u32 ColorTable[16];
-};
-
-struct ConsoleFEDataBlock {
-    u32 CodePage;
-};
-
-struct DarwinDataBlock {
-    char DarwinDataAnsi[260];
-    char16 DarwinDataUnicode[260];
-};
-
-struct EnvironmentVariableDataBlock {
-    char TargetAnsi[260];
-    char16 TargetUnicode[260];
-};
-
-struct IconEnvironmentDataBlock {
-    char TargetAnsi[260];
-    char16 TargetUnicode[260];
-};
-
-struct KnownFolderDataBlock {
-    type::GUID KnownFolderID;
-    u32 Offset;
-};
-
-struct PropertyStoreDataBlock {
-    u8 Bytes[parent.BlockSize - sizeof(parent.BlockSize) - sizeof(parent.BlockSignature)];
-    std::warning("PropertyStoreDataBlock is not yet implemented!");
-};
-
-struct ShimDataBlock {
-    char16 LayerName[(parent.BlockSize - sizeof(parent.BlockSize) - sizeof(parent.BlockSignature)) / sizeof(char16)];
-};
-
-struct SpecialFolderDataBlock {
-    u32 SpecialFolderID;
-    u32 Offset;
-};
-
-struct TrackerDataBlock {
-    type::Size32 Length;
-    u32 Version;
-    char MachineID[16];
-    type::GUID Droid[2];
-    type::GUID DroidBirth[2];
-};
-
-struct VistaAndAboveIDListDataBlock {
-    IDList IDList;
-};
-
-struct ExtraDataBlock {
-    type::Size32 BlockSize;
-    
-    if (BlockSize < 0x04)
-        break;
-    else {
-        u32 BlockSignature;
-    
-        if (BlockSignature == 0xA000'0002)
-            ConsoleDataBlock CONSOLE_PROPS;
-        else if (BlockSignature == 0xA000'0004)
-            ConsoleFEDataBlock CONSOLE_FE_PROPS;
-        else if (BlockSignature == 0xA000'0006)
-            DarwinDataBlock DARWIN_PROPS;
-        else if (BlockSignature == 0xA000'0001)
-            EnvironmentVariableDataBlock ENVIRONMENT_PROPS;
-        else if (BlockSignature == 0xA000'0007)
-            IconEnvironmentDataBlock ICON_ENVIRONMENT_PROPS;
-        else if (BlockSignature == 0xA000'000B)
-            KnownFolderDataBlock KNOWN_FOLDER_PROPS;
-        else if (BlockSignature == 0xA000'0009)
-            PropertyStoreDataBlock PROPERTY_STORE_PROPS;
-        else if (BlockSignature == 0xA000'0008)
-            ShimDataBlock SHIM_PROPS;
-        else if (BlockSignature == 0xA000'0005)
-            SpecialFolderDataBlock SPECIAL_FOLDER_PROPS;
-        else if (BlockSignature == 0xA000'0003)
-            TrackerDataBlock TRACKER_PROPS;
-        else if (BlockSignature == 0xA000'000C)
-            VistaAndAboveIDListDataBlock VISTA_AND_ABOVE_IDLIST_PROPS;
-    }
-};
-
-struct ExtraData {
-    ExtraDataBlock ExtraDataBlock[while(true)];
-};
-
-struct LNK {
-    ShellLinkHeader ShellLinkHeader;
-    if (ShellLinkHeader.LinkFlags.HasLinkTargetIDList)
-        LinkTargetIDList LinkTargetIDList;
-    if (ShellLinkHeader.LinkFlags.HasLinkInfo)
-        LinkInfo LinkInfo;
-    StringData StringData;
-    ExtraData ExtraData;
-};
-
-LNK lnk @ 0x00;
+#pragma MIME application/x-ms-shortcut
+
+#include <std/core.pat>
+#include <type/guid.pat>
+#include <type/size.pat>
+
+using BitfieldOrder = std::core::BitfieldOrder;
+
+bitfield LinkFlags {
+    HasLinkTargetIDList         : 1;
+    HasLinkInfo                 : 1;
+    HasName                     : 1;
+    HasRelativePath             : 1;
+    HasWorkingDir               : 1;
+    HasArguments                : 1;
+    HasIconLocation             : 1;
+    IsUnicode                   : 1;
+    ForceNoLinkInfo             : 1;
+    HasExpString                : 1;
+    RunInSeparateProcess        : 1;
+    padding                     : 1;
+    HasDarwinID                 : 1;
+    RunAsUser                   : 1;
+    HasExpIcon                  : 1;
+    NoPidlAlias                 : 1;
+    padding                     : 1;
+    RunWithShimLayer            : 1;
+    ForceNoLinkTrack            : 1;
+    EnableTargetMetadata        : 1;
+    DisableLinkPathTracking     : 1;
+    DisableKnownFolderTracking  : 1;
+    DisableKnownFolderAlias     : 1;
+    AllowLinkToLink             : 1;
+    UnaliasOnSave               : 1;
+    PreferEnvironmentPath       : 1;
+    KeepLocalIDListForUNCTarget : 1;
+    padding                     : 5;
+};
+
+bitfield FileAttributesFlags {
+    FILE_ATTRIBUTE_READONLY             : 1;
+    FILE_ATTRIBUTE_HIDDEN               : 1;
+    FILE_ATTRIBUTE_SYSTEM               : 1;
+    padding                             : 1;
+    FILE_ATTRIBUTE_DIRECTORY            : 1;
+    FILE_ATTRIBUTE_ARCHIVE              : 1;
+    padding                             : 1;
+    FILE_ATTRIBUTE_NORMAL               : 1;
+    FILE_ATTRIBUTE_TEMPORARY            : 1;
+    FILE_ATTRIBUTE_SPARSE_FILE          : 1;
+    FILE_ATTRIBUTE_REPARSE_POINT        : 1;
+    FILE_ATTRIBUTE_COMPRESSED           : 1;
+    FILE_ATTRIBUTE_OFFLINE              : 1;
+    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  : 1;
+    FILE_ATTRIBUTE_ENCRYPTED            : 1;
+    padding                             : 17;
+};
+
+bitfield ModifierKeys {
+    HOTKEYF_SHIFT   : 1;
+    HOTKEYF_CONTROL : 1;
+    HOTKEYF_ALT     : 1;
+    padding         : 5;
+};
+
+enum Keys : u8 {
+    KEY_NONE    = 0x00,
+    KEY_0       = 0x30,
+    KEY_1       = 0x31,
+    KEY_2       = 0x32,
+    KEY_3       = 0x33,
+    KEY_4       = 0x34,
+    KEY_5       = 0x35,
+    KEY_6       = 0x36,
+    KEY_7       = 0x37,
+    KEY_8       = 0x38,
+    KEY_9       = 0x39,
+    KEY_A       = 0x41,
+    KEY_B       = 0x42,
+    KEY_C       = 0x43,
+    KEY_D       = 0x44,
+    KEY_E       = 0x45,
+    KEY_F       = 0x46,
+    KEY_G       = 0x47,
+    KEY_H       = 0x48,
+    KEY_I       = 0x49,
+    KEY_J       = 0x4A,
+    KEY_K       = 0x4B,
+    KEY_L       = 0x4C,
+    KEY_M       = 0x4D,
+    KEY_N       = 0x4E,
+    KEY_O       = 0x4F,
+    KEY_P       = 0x50,
+    KEY_Q       = 0x51,
+    KEY_R       = 0x52,
+    KEY_S       = 0x53,
+    KEY_T       = 0x54,
+    KEY_U       = 0x55,
+    KEY_V       = 0x56,
+    KEY_W       = 0x57,
+    KEY_X       = 0x58,
+    KEY_Y       = 0x59,
+    KEY_Z       = 0x5A,
+    
+    VK_F1       = 0x70,
+    VK_F2       = 0x71,
+    VK_F3       = 0x72,
+    VK_F4       = 0x73,
+    VK_F5       = 0x74,
+    VK_F6       = 0x75,
+    VK_F7       = 0x76,
+    VK_F8       = 0x77,
+    VK_F9       = 0x78,
+    VK_F10      = 0x79,
+    VK_F11      = 0x7A,
+    VK_F12      = 0x7B,
+    VK_F13      = 0x7C,
+    VK_F14      = 0x7D,
+    VK_F15      = 0x7E,
+    VK_F16      = 0x7F,
+    VK_F17      = 0x80,
+    VK_F18      = 0x81,
+    VK_F19      = 0x82,
+    VK_F20      = 0x83,
+    VK_F21      = 0x84,
+    VK_F22      = 0x85,
+    VK_F23      = 0x86,
+    VK_F24      = 0x87,
+    VK_NUMLOCK  = 0x90,
+    VK_SCROLL   = 0x91,
+};
+
+struct HotKeyFlags {
+    Keys Key;
+    ModifierKeys ModifierKeys;
+};
+
+struct FILETIME {
+    u32 dwLowDateTime;
+    u32 dwHighDateTime;
+};
+
+enum SHOWWINDOW_FLAGS : u32 {
+    SW_SHOWNORMAL       = 0x00000001,
+    SW_SHOWMAXIMIZED    = 0x00000003,
+    SW_SHOWMINNOACTIVE  = 0x00000007
+};
+
+struct ShellLinkHeader {
+    type::Size32 HeaderSize;
+    type::GUID LinkCLSID;
+    LinkFlags LinkFlags;
+    FileAttributesFlags FileAttributes;
+    FILETIME CreationTime, AccessTime, WriteTime;
+    type::Size32 FileSize;
+    u32 IconIndex;
+    SHOWWINDOW_FLAGS ShowCommand;
+    HotKeyFlags HotKey;
+    padding[2];
+    padding[4];
+    padding[4];	
+};
+
+struct ItemID {
+    type::Size16 ItemIDSize;
+    
+    if (ItemIDSize == 0x00)
+        break;
+    else
+        u8 Data[ItemIDSize - sizeof(ItemIDSize)];
+};
+
+struct IDList {
+    ItemID ItemIDList[while(true)];
+};
+
+struct LinkTargetIDList {
+    type::Size16 IDListSize;
+    IDList IDList[while($ < (addressof(IDListSize) + IDListSize))];
+};
+
+bitfield LinkInfoFlags {
+    VolumeIDAndLocalBasePath               : 1;
+    CommonNetworkRelativeLinkAndPathSuffix : 1;
+    padding                                : 30;
+};
+
+enum DriveType : u32 {
+    DRIVE_UNKNOWN       = 0x00000000,
+    DRIVE_NO_ROOT_DIR   = 0x00000001,
+    DRIVE_REMOVABLE     = 0x00000002,
+    DRIVE_FIXED         = 0x00000003,
+    DRIVE_REMOTE        = 0x00000004,
+    DRIVE_CDROM         = 0x00000005,
+    DRIVE_RAMDISK       = 0x00000006
+};
+
+struct VolumeID {
+    type::Size32 VolumeIDSize;
+    DriveType DriveType;
+    u32 DriveSerialNumber;
+    u32 VolumeLabelOffset;
+    if (VolumeLabelOffset == 0x14)
+        u32 VolumeLabelOffsetUnicode;
+    char Data[VolumeIDSize - ($ - addressof(this))];
+};
+
+bitfield CommonNetworkRelativeLinkFlags {
+    ValidDevice     : 1;
+    ValidNetType    : 1;
+    padding         : 30;
+};
+
+enum NetworkProviderType : u32 {
+    WNNC_NET_AVID           = 0x001A0000,
+    WNNC_NET_DOCUSPACE      = 0x001B0000,
+    WNNC_NET_MANGOSOFT      = 0x001C0000,
+    WNNC_NET_SERNET         = 0x001D0000,
+    WNNC_NET_RIVERFRONT1    = 0x001E0000,
+    WNNC_NET_RIVERFRONT2    = 0x001F0000,
+    WNNC_NET_DECORB         = 0x00200000,
+    WNNC_NET_PROTSTOR       = 0x00210000,
+    WNNC_NET_FJ_REDIR       = 0x00220000,
+    WNNC_NET_DISTINCT       = 0x00230000,
+    WNNC_NET_TWINS          = 0x00240000,
+    WNNC_NET_RDR2SAMPLE     = 0x00250000,
+    WNNC_NET_CSC            = 0x00260000,
+    WNNC_NET_3IN1           = 0x00270000,
+    WNNC_NET_EXTENDNET      = 0x00290000,
+    WNNC_NET_STAC           = 0x002A0000,
+    WNNC_NET_FOXBAT         = 0x002B0000,
+    WNNC_NET_YAHOO          = 0x002C0000,
+    WNNC_NET_EXIFS          = 0x002D0000,
+    WNNC_NET_DAV            = 0x002E0000,
+    WNNC_NET_KNOWARE        = 0x002F0000,
+    WNNC_NET_OBJECT_DIRE    = 0x00300000,
+    WNNC_NET_MASFAX         = 0x00310000,
+    WNNC_NET_HOB_NFS        = 0x00320000,
+    WNNC_NET_SHIVA          = 0x00330000,
+    WNNC_NET_IBMAL          = 0x00340000,
+    WNNC_NET_LOCK           = 0x00350000,
+    WNNC_NET_TERMSRV        = 0x00360000,
+    WNNC_NET_SRT            = 0x00370000,
+    WNNC_NET_QUINCY         = 0x00380000,
+    WNNC_NET_OPENAFS        = 0x00390000,
+    WNNC_NET_AVID1          = 0x003A0000,
+    WNNC_NET_DFS            = 0x003B0000,
+    WNNC_NET_KWNP           = 0x003C0000,
+    WNNC_NET_ZENWORKS       = 0x003D0000,
+    WNNC_NET_DRIVEONWEB     = 0x003E0000,
+    WNNC_NET_VMWARE         = 0x003F0000,
+    WNNC_NET_RSFX           = 0x00400000,
+    WNNC_NET_MFILES         = 0x00410000,
+    WNNC_NET_MS_NFS         = 0x00420000,
+    WNNC_NET_GOOGLE         = 0x00430000
+};
+
+struct CommonNetworkRelativeLink {
+    type::Size32 CommonNetworkRelativeLinkSize;
+    CommonNetworkRelativeLinkFlags CommonNetworkRelativeLinkFlags;
+    u32 NetNameOffset;
+    u32 DeviceNameOffset;
+    NetworkProviderType NetworkProviderType;
+    
+    if (NetNameOffset > 0x14) {
+        u32 NetNameOffsetUnicode;
+        u32 DeviceNameOffsetUnicode;
+    }
+    
+    char NetName[];
+    char DeviceName[];
+        
+    if (NetNameOffset > 0x14) {
+        char16 NetNameUnicode[];
+        char16 DeviceNameUnicode[];
+    }
+};
+
+struct LinkInfo {
+    type::Size32 LinkInfoSize;
+    type::Size32 LinkInfoHeaderSize;
+    LinkInfoFlags LinkInfoFlags;
+    u32 VolumeIDOffset;
+    u32 LocalBasePathOffset;
+    u32 CommonNetworkRelativeLinkOffset;
+    u32 CommonPathSuffixOffset;
+    
+    if (LinkInfoHeaderSize >= 0x24) {
+        u32 LocalBasePathOffsetUnicode;
+        u32 CommonPathSuffixOffsetUnicode;
+    }
+    
+    if (LinkInfoFlags.VolumeIDAndLocalBasePath) {
+        VolumeID VolumeID;
+        char LocalBasePath[];
+    }	
+    
+    if (LinkInfoFlags.CommonNetworkRelativeLinkAndPathSuffix)
+        CommonNetworkRelativeLink CommonNetworkRelativeLink;
+        
+    char CommonPathSuffix[];
+    
+    if (LinkInfoHeaderSize >= 0x24) {
+        if (LinkInfoFlags.VolumeIDAndLocalBasePath)
+            char16 LocalBasePathUnicode[];
+        char16 CommonPathSuffixUnicode[];
+    }
+};
+
+struct String {
+    u16 CountCharacters;
+    char16 String[CountCharacters];
+};
+
+struct StringData {
+    if (parent.ShellLinkHeader.LinkFlags.HasName)
+        String NAME_STRING;
+    if (parent.ShellLinkHeader.LinkFlags.HasRelativePath)
+        String RELATIVE_PATH;
+    if (parent.ShellLinkHeader.LinkFlags.HasWorkingDir)
+        String WORKING_DIR;
+    if (parent.ShellLinkHeader.LinkFlags.HasArguments)
+        String COMMAND_LINE_ARGUMENTS;
+    if (parent.ShellLinkHeader.LinkFlags.HasIconLocation)
+        String ICON_LOCATION;
+};
+
+bitfield FillAttributes {
+    FOREGROUND_BLUE         : 1;
+    FOREGROUND_GREEN        : 1;
+    FOREGROUND_RED          : 1;
+    FOREGROUND_INTENSITY    : 1;
+    
+    BACKGROUND_BLUE         : 1;
+    BACKGROUND_GREEN        : 1;
+    BACKGROUND_RED          : 1;
+    BACKGROUND_INTENSITY    : 1;
+    
+    padding                 : 8;
+};
+
+struct ConsoleDataBlock {
+    FillAttributes FillAttributes;
+    FillAttributes PopupFillAttributes;
+    u16 ScreenBufferSizeX, ScreenBufferSizeY;
+    u16 WindowSizeX, WindowSizeY;
+    u16 WindowOriginX, WindowOriginY;
+    padding[4];
+    padding[4];
+    u32 FontSize;
+    u32 FontFamily;
+    u32 FontWeight;
+    char16 FaceName[32];
+    u32 CursorSize;
+    u32 FullScreen;
+    u32 QuickEdit;
+    u32 InsertMode;
+    u32 AutoPosition;
+    u32 HistoryBufferSize;
+    u32 NumberOfHistoryBuffers;
+    u32 HistoryNoDup;
+    u32 ColorTable[16];
+};
+
+struct ConsoleFEDataBlock {
+    u32 CodePage;
+};
+
+struct DarwinDataBlock {
+    char DarwinDataAnsi[260];
+    char16 DarwinDataUnicode[260];
+};
+
+struct EnvironmentVariableDataBlock {
+    char TargetAnsi[260];
+    char16 TargetUnicode[260];
+};
+
+struct IconEnvironmentDataBlock {
+    char TargetAnsi[260];
+    char16 TargetUnicode[260];
+};
+
+struct KnownFolderDataBlock {
+    type::GUID KnownFolderID;
+    u32 Offset;
+};
+
+struct PropertyStoreDataBlock {
+    u8 Bytes[parent.BlockSize - sizeof(parent.BlockSize) - sizeof(parent.BlockSignature)];
+    std::warning("PropertyStoreDataBlock is not yet implemented!");
+};
+
+struct ShimDataBlock {
+    char16 LayerName[(parent.BlockSize - sizeof(parent.BlockSize) - sizeof(parent.BlockSignature)) / sizeof(char16)];
+};
+
+struct SpecialFolderDataBlock {
+    u32 SpecialFolderID;
+    u32 Offset;
+};
+
+struct TrackerDataBlock {
+    type::Size32 Length;
+    u32 Version;
+    char MachineID[16];
+    type::GUID Droid[2];
+    type::GUID DroidBirth[2];
+};
+
+struct VistaAndAboveIDListDataBlock {
+    IDList IDList;
+};
+
+struct ExtraDataBlock {
+    type::Size32 BlockSize;
+    
+    if (BlockSize < 0x04)
+        break;
+    else {
+        u32 BlockSignature;
+    
+        if (BlockSignature == 0xA000'0002)
+            ConsoleDataBlock CONSOLE_PROPS;
+        else if (BlockSignature == 0xA000'0004)
+            ConsoleFEDataBlock CONSOLE_FE_PROPS;
+        else if (BlockSignature == 0xA000'0006)
+            DarwinDataBlock DARWIN_PROPS;
+        else if (BlockSignature == 0xA000'0001)
+            EnvironmentVariableDataBlock ENVIRONMENT_PROPS;
+        else if (BlockSignature == 0xA000'0007)
+            IconEnvironmentDataBlock ICON_ENVIRONMENT_PROPS;
+        else if (BlockSignature == 0xA000'000B)
+            KnownFolderDataBlock KNOWN_FOLDER_PROPS;
+        else if (BlockSignature == 0xA000'0009)
+            PropertyStoreDataBlock PROPERTY_STORE_PROPS;
+        else if (BlockSignature == 0xA000'0008)
+            ShimDataBlock SHIM_PROPS;
+        else if (BlockSignature == 0xA000'0005)
+            SpecialFolderDataBlock SPECIAL_FOLDER_PROPS;
+        else if (BlockSignature == 0xA000'0003)
+            TrackerDataBlock TRACKER_PROPS;
+        else if (BlockSignature == 0xA000'000C)
+            VistaAndAboveIDListDataBlock VISTA_AND_ABOVE_IDLIST_PROPS;
+    }
+};
+
+struct ExtraData {
+    ExtraDataBlock ExtraDataBlock[while(true)];
+};
+
+struct LNK {
+    ShellLinkHeader ShellLinkHeader;
+    if (ShellLinkHeader.LinkFlags.HasLinkTargetIDList)
+        LinkTargetIDList LinkTargetIDList;
+    if (ShellLinkHeader.LinkFlags.HasLinkInfo)
+        LinkInfo LinkInfo;
+    StringData StringData;
+    ExtraData ExtraData;
+};
+
+LNK lnk @ 0x00;
--- a/patterns/lua54.hexpat
+++ b/patterns/lua54.hexpat
@@ -0,0 +1,135 @@
+#include <std/io.pat>
+#include <std/mem.pat>
+
+namespace impl {
+
+    fn transform_Size_array(auto array) {
+        u128 res = 0;
+        for(u8 i = 0, (array[i] & 0x80 == 0) && (i < 9), i+=1) {
+            res <<= 7;
+            res |= array[i] & 0x7f;
+        }
+        res <<= 7;
+        res |= array[sizeof(array)-1] & 0x7f;
+        return res;
+    };
+    
+    fn format_Size(auto leb128) {
+        u128 res = impl::transform_Size_array(leb128.array);
+        return std::format("{} ({:#x})", res, res);
+    };
+
+    fn transform_Size(auto leb128) {
+        return impl::transform_Size_array(leb128.array);
+    };
+    
+    fn format_LuaString(auto string) {
+       if (string.size == 0) {
+           return "None";
+        }
+        return std::format("\"{}\"", string.data);
+    };
+    
+    fn format_Constant(auto const) {
+       return const.data;
+    };
+    
+    fn format_Version(auto ver) {
+       return std::format("Ver. {}.{}", ver.major, ver.minor);
+    };
+}
+
+
+using LuaFunction;
+
+struct Size {
+        u8 array[while(addressof(this) == $ || ((addressof(this)-$ < 9) && (std::mem::read_unsigned($-1, 1) & 0x80 == 0)))] [[hidden]];
+} [[sealed, format("impl::format_Size"), transform("impl::transform_Size")]];
+    
+
+bitfield Version {
+    minor : 4;
+    major : 4;
+} [[format("impl::format_Version")]];
+
+struct LuaBinaryHeader {
+    u32 magic;
+    Version version_number;
+    u8 format_version;
+    u8 error_detection_data[6];
+    u8 size_of_int;
+    u8 size_of_size_t;
+    u8 size_of_number;
+    u64 luac_int;
+    double luac_num;
+};
+struct LuaString {
+    Size size;
+    if (size > 0) {
+        char data[size-1];
+    }
+}[[format("impl::format_LuaString")]];
+
+struct LuaConstant {
+    u8 type;
+    if (type == 3) {
+        u64 data;
+    } else if (type == 0x13) {
+        double data;
+    } else if (type == 0x4 || type == 0x14) {
+        LuaString data;
+    }
+}[[format("impl::format_Constant")]];
+
+struct LuaUpvalue {
+    u8 instack;
+    u8 idx;
+    u8 kind;
+};
+
+struct Vector<T> {
+    Size size;
+    T values[size];
+};
+
+
+struct AbsLineInfo {
+    Size pc;
+    Size line;
+};
+
+struct LocalVar {
+    LuaString varname;
+    Size startpc;
+    Size endpc;
+};
+
+struct LuaDebugInfo {
+    Vector<s8> lineInfo;
+    Vector<AbsLineInfo> abslineinfo;
+    Vector<LocalVar> local_vars;
+    Vector<LuaString> upvalues;
+};
+
+struct LuaFunction {
+    LuaString source;
+    Size line_defined;
+    Size last_line_defined;
+    u8 number_of_parameters;
+    u8 is_vararg;
+    u8 maxstacksize;
+    Vector<u32> code;
+    Vector<LuaConstant> constants;
+    Vector<LuaUpvalue> upvalues;
+    Vector<LuaFunction> protos;
+    LuaDebugInfo debugInfo;
+
+};
+
+struct LuaFile {
+    LuaBinaryHeader header;
+    u8 size_of_upvalues;
+    LuaFunction func;
+};
+
+LuaFile file @ 0;
--- a/patterns/macho.hexpat
+++ b/patterns/macho.hexpat
@@ -1,383 +1,386 @@
-#pragma MIME application/x-mach-binary
-
-#include <type/size.pat>
-
-enum Magic : u32 {
-    _32BitMagic = 0xFEEDFACE,
-    _64BitMagic = 0xFEEDFACF
-};
-
-enum CpuType : u32 {
-    VAX = 1,
-    ROMP = 2,
-    BS32032 = 4,
-    BS32332 = 5,
-    MC680x0 = 6,
-    I386 = 7,
-    X86_64 = CpuType::I386 | 0x100'0000,
-    MIPS = 8,
-    NS32532 = 9,
-    HPPA = 11,
-    ARM = 12,
-    MC88000 = 13,
-    SPARC = 14,
-    I860 = be u32(15),
-    I860_LITTLE = 16,
-    RS6000 = 17,
-    MC980000 = 18,
-    POWERPC = 18,
-    POWERPC64 = CpuType::POWERPC | 0x100'0000,
-    VEO = 255
-};
-
-enum SubCpuTypeVAX : u24 {
-    ALL = 0,
-    VAX780 = 1,
-    VAX785 = 2,
-    VAX750 = 3,
-    VAX730 = 4,
-    UVAXI = 5,
-    UVAXII = 6,
-    VAX8200 = 7,
-    VAX8500 = 8,
-    VAX8600 = 9,
-    VAX8650 = 10,
-    VAX8800 = 11,
-    UVAXIII = 12
-};
-
-enum SubCpuTypeROMP : u24 {
-    ALL = 0,
-    PC = 1,
-    APC = 2,
-    _135 = 3
-};
-
-enum SubCpuType32XXX : u24 {
-    ALL = 0,
-    MMAX_DPC = 1,
-    SQT = 2,
-    MMAX_APC_FPU = 3,
-    MMAX_APC_FPA = 4,
-    MMAX_XPC = 5
-};
-
-enum SubCpuTypeI386 : u24 {
-    _386 = 3,
-    _486 = 4,
-    _486SX =  SubCpuTypeI386::_486 + 128,
-    _586 = 5,
-    IntelPentium = 5 + (0 << 4),
-    IntelPentiumPro = 6 + (1 << 4),
-    IntelPentiumIIM3 = 6 + (3 << 4),
-    IntelPentiumIIM5 = 6 + (5 << 4),
-    IntelPentium4 = 10 + (0 << 4),
-};
-
-enum SubCpuTypeMips : u24 {
-    ALL = 0,
-    R2300 = 1,
-    R2600 = 2,
-    R2800 = 3,
-    R2000a = 4
-};
-
-enum SubCpuType680x0 : u24 {
-    ALL = 1,
-    MC68030 = 1,
-    MC68040 = 2,
-    MC68030_Only = 3
-};
-
-enum SubCpuTypeHPPA : u24 {
-    ALL = 0,
-    _7100 = 0,
-    _7100LC = 1
-};
-
-enum SubCpuTypeARM : u24 {
-    ALL = 0,
-    A500_ARCH = 1,
-    A500 = 2,
-    A440 = 3,
-    M4 = 4,
-    V4T = 5,
-    V6 = 6,
-    V5TEJ = 7,
-    XSCALE = 8,
-    V7 = 9,
-    V7F = 10, /* Cortex A9 */
-    V7S = 11, /* Swift */
-    V7K = 12  /* Kirkwood40 */
-};
-
-enum SubCpuTypeMC88000 : u24 {
-    ALL = 0,
-    MMAX_JPC = 1,
-    MC88100 = 1,
-    MC88110 = 2
-};
-
-enum SubCpuTypeMC98000 : u24 {
-    ALL = 0,
-    MC98601 = 1
-};
-
-enum SubCpuTypeI860 : u24 {
-    ALL = 0,
-    _860 = 1
-};
-
-enum SubCpuTypeI860Little : u24 {
-    ALL = 0 ... 1
-};
-
-enum SubCpuTypeRS6000 : u24 {
-    ALL = 0 ... 1
-};
-
-enum SubCpuTypeSparc : u24 {
-    ALL = 0,
-    _260 = 1,
-    _110 = 2
-};
-
-enum SubCpuTypePowerPC : u24 {
-    ALL = 0,
-    _601 = 1,
-    _602 = 2,
-    _603 = 3,
-    _603e = 4,
-    _603ev = 5,
-    _604 = 6,
-    _604e = 7,
-    _620 = 8,
-    _750 = 9,
-    _7400 = 10,
-    _7450 = 11,
-    _970 = 100
-};
-
-enum SubCpuTypeVEO : u24 {
-    _1 = 1,
-    _2 = 2,
-    _3 = 3,
-    _4 = 4,
-    ALL = SubCpuTypeVEO::_2
-};
-
-bitfield Capabilities {
-    padding : 7;
-    lib64   : 1;
-} [[right_to_left]];
-
-enum FileType : u32 {
-    Object = 1,
-    Execute = 2,
-    FVMLib = 3,
-    Core = 4,
-    Preload = 5,
-    DyLib = 6,
-    DyLinker = 7,
-    Bundle = 8,
-    DyLibStub = 9,
-    DSym = 10,
-    KExtBundle = 11,
-};
-
-bitfield Flags {
-    noUndefs    : 1;
-    incrLink    : 1;
-    dyldLink    : 1;
-    binDatLoad  : 1;
-    prebound    : 1;
-    splitSegs   : 1;
-    lazyInit    : 1;
-    twoLevel : 1;
-    forceFlat : 1;
-    noMultiDefs : 1;
-    noFixPrebinding : 1;
-    prebindable : 1;
-    allModsBound : 1;
-    subSectionsViaSymbols : 1;
-    canonical : 1;
-    weakDefines : 1;
-    bindsToWeak : 1;
-    allowStackExecution : 1;
-    rootSafe : 1;
-    setuidSafe : 1;
-    noReexportedDylibs : 1;
-    pie : 1;
-    deadStrippableDylib : 1;
-    hasTlvDescriptors : 1;
-    noHeapExecution : 1;
-    appExtensionSafe : 1;
-    nlistOutOfSyncWithDyldinof : 1;
-    simSupport : 1;
-} [[right_to_left]];
-
-struct Header {
-    Magic magic;
-    CpuType cpuType;
-    if (cpuType == CpuType::VAX) SubCpuTypeVAX subCpuType;
-    else if (cpuType == CpuType::ROMP) SubCpuTypeROMP subCpuType;
-    else if (cpuType == CpuType::BS32032 || cpuType == CpuType::BS32332 || cpuType == CpuType::NS32532) SubCpuType32XXX subCpuType;
-    else if (cpuType == CpuType::I386 || cpuType == CpuType::X86_64) SubCpuTypeI386 subCpuType;
-    else if (cpuType == CpuType::MIPS) SubCpuTypeMips subCpuType;
-    else if (cpuType == CpuType::HPPA) SubCpuTypeHPPA subCpuType;    
-    else if (cpuType == CpuType::ARM) SubCpuTypeARM subCpuType;
-    else if (cpuType == CpuType::MC88000) SubCpuTypeMC88000 subCpuType;
-    else if (cpuType == CpuType::MC98000) SubCpuTypeMC98000 subCpuType;
-    else if (cpuType == CpuType::I860 || cpuType == CpuType::I860_LITTLE) SubCpuTypeI860 subCpuType;
-    else if (cpuType == CpuType::SPARC) SubCpuTypeSparc subCpuType;
-    else if (cpuType == CpuType::POWERPC || cpuType == CpuType::POWERPC64) SubCpuTypePowerPC subCpuType;
-    else if (cpuType == CpuType::VEO) SubCpuTypeVEO subCpuType;
-    else u24 subCpuType;
-    Capabilities capabilities;
-    FileType fileType;
-    u32 numCommands;
-    type::Size<u32> sizeOfCommands;
-    Flags flags;
-    
-    if (magic == Magic::_64BitMagic) padding[sizeof(u32)];
-};
-
-enum Command : u32 {
-    ReqDyLd = 0x8000'0000,
-
-    Segment = 0x01,
-    SymTab = 0x02,
-    SymSeg = 0x03,
-    Thread = 0x04,
-    UnixThread = 0x05,
-    LoadFVMLib = 0x06,
-    IdFVMLib = 0x07,
-    Ident = 0x08,
-    FVMFile = 0x09,
-    PrePage = 0x0A,
-    DySymTab = 0x0B,
-    LoadDyLib = 0x0C,
-    IdDyLib = 0x0D,
-    LoadDyLinker = 0x0E,
-    IdDyLinker = 0x0F,
-    PreboundDyLib = 0x10,
-    Routines = 0x11,
-    SubFramework = 0x12,
-    SubUmbrella = 0x13,
-    SubClient = 0x14,
-    SubLibrary = 0x15,
-    TwoLevelHints = 0x16,
-    PrebindCksum = 0x17,
-    LoadWeakDyLib = 0x18 | Command::ReqDyLd,
-    Segment64 = 0x19,
-    Routines64 = 0x1A,
-    UUID = 0x1B,
-    RPath = 0x1C | 0x8000'0000,
-    CodeSignature = 0x1D,
-    SegmentSplitInfo = 0x1E,
-    ReExportDyLib = 0x1F | Command::ReqDyLd,
-    LazyLoadDyLib = 0x20,
-    EncryptionInfo = 0x21,
-    DyLdInfo = 0x22,
-    DyLdInfoOnly = 0x22 | Command::ReqDyLd,
-    LoadUpwardDyLib = 0x23 | Command::ReqDyLd,
-    VersionMinMacOSX = 0x24,
-    VersionMinIPhoneOS = 0x25,
-    FunctionStarts = 0x26,
-    DyLdEnvironment = 0x27,
-    Main = 0x28 | Command::ReqDyLd,
-    DataInCode = 0x29,
-    SourceVersion = 0x2A,
-    DyLibCodeSignDRS = 0x2B
-};
-
-struct CommandUUID {
-    u128 uuid;
-};
-
-struct Section {
-    char sectionName[16];
-    char segmentName[16];
-    u32 address;
-    type::Size<u32> size;
-    u32 offset;
-    u32 align;
-    u32 reloff;
-    u32 numRelocs;
-    u32 flags;
-    padding[8];
-    
-    if (offset > 0)
-        u8 data[size] @ offset [[sealed]];
-};
-
-struct CommandSegment {
-    char segmentName[16];
-    u32 vmAddress;
-    type::Size<u32> vmSize;
-    u32 fileOffset;
-    type::Size<u32> fileSize;
-    u32 maxProtection;
-    u32 initProtection;
-    u32 numSections;
-    u32 flags;
-    
-    Section sections[numSections];
-    
-    if (fileOffset > 0)
-        u8 data[fileSize] @ fileOffset [[sealed]];
-};
-
-struct Section64 {
-    char sectionName[16];
-    char segmentName[16];
-    u64 address;
-    type::Size<u64> size;
-    u32 offset;
-    u32 align;
-    u32 reloff;
-    u32 numRelocs;
-    u32 flags;
-    padding[12];
-    
-    if (offset > 0)
-        u8 data[size] @ offset [[sealed]];
-};
-
-struct CommandSegment64 {
-    char segmentName[16];
-    u64 vmAddress;
-    type::Size<u64> vmSize;
-    u64 fileOffset;
-    type::Size<u64> fileSize;
-    u32 maxProtection;
-    u32 initProtection;
-    u32 numSections;
-    u32 flags;
-    
-    Section64 sections[numSections];
-    
-    if (fileOffset > 0)
-        u8 data[fileSize] @ fileOffset [[sealed]];
-};
-
-struct LoadCommand {
-    Command command;
-    type::Size<u32> commandSize;
-    
-    if (command == Command::UUID)
-        CommandUUID data;
-    else if (command == Command::Segment)
-        CommandSegment data;
-    else if (command == Command::Segment64)
-        CommandSegment64 data;
-    else
-        u8 data[commandSize - 8] [[sealed]];
-};
-
-struct MachO {
-    Header header;
-    LoadCommand loadCommands[header.numCommands];
-};
-
+#pragma MIME application/x-mach-binary
+
+#include <type/size.pat>
+
+enum Magic : u32 {
+    _32BitMagic = 0xFEEDFACE,
+    _64BitMagic = 0xFEEDFACF
+};
+
+enum CpuType : u32 {
+    ANY = -1,
+    VAX = 1,
+    ROMP = 2,
+    BS32032 = 4,
+    BS32332 = 5,
+    MC680x0 = 6,
+    I386 = 7,
+    X86_64 = CpuType::I386 | 0x100'0000,
+    MIPS = 8,
+    NS32532 = 9,
+    MC98000 = 10,
+    HPPA = 11,
+    ARM = 12,
+    ARM64 = CpuType::ARM | 0x100'0000,
+    ARM64_32 = CpuType::ARM | 0x200'0000,
+    MC88000 = 13,
+    SPARC = 14,
+    I860 = be u32(15),
+    I860_LITTLE = 16,
+    RS6000 = 17,
+    POWERPC = 18,
+    POWERPC64 = CpuType::POWERPC | 0x100'0000,
+    VEO = 255
+};
+
+enum SubCpuTypeVAX : u24 {
+    ALL = 0,
+    VAX780 = 1,
+    VAX785 = 2,
+    VAX750 = 3,
+    VAX730 = 4,
+    UVAXI = 5,
+    UVAXII = 6,
+    VAX8200 = 7,
+    VAX8500 = 8,
+    VAX8600 = 9,
+    VAX8650 = 10,
+    VAX8800 = 11,
+    UVAXIII = 12
+};
+
+enum SubCpuTypeROMP : u24 {
+    ALL = 0,
+    PC = 1,
+    APC = 2,
+    _135 = 3
+};
+
+enum SubCpuType32XXX : u24 {
+    ALL = 0,
+    MMAX_DPC = 1,
+    SQT = 2,
+    MMAX_APC_FPU = 3,
+    MMAX_APC_FPA = 4,
+    MMAX_XPC = 5
+};
+
+enum SubCpuTypeI386 : u24 {
+    _386 = 3,
+    _486 = 4,
+    _486SX =  SubCpuTypeI386::_486 + 128,
+    _586 = 5,
+    IntelPentium = 5 + (0 << 4),
+    IntelPentiumPro = 6 + (1 << 4),
+    IntelPentiumIIM3 = 6 + (3 << 4),
+    IntelPentiumIIM5 = 6 + (5 << 4),
+    IntelPentium4 = 10 + (0 << 4),
+};
+
+enum SubCpuTypeMips : u24 {
+    ALL = 0,
+    R2300 = 1,
+    R2600 = 2,
+    R2800 = 3,
+    R2000a = 4
+};
+
+enum SubCpuType680x0 : u24 {
+    ALL = 1,
+    MC68030 = 1,
+    MC68040 = 2,
+    MC68030_Only = 3
+};
+
+enum SubCpuTypeHPPA : u24 {
+    ALL = 0,
+    _7100 = 0,
+    _7100LC = 1
+};
+
+enum SubCpuTypeARM : u24 {
+    ALL = 0,
+    A500_ARCH = 1,
+    A500 = 2,
+    A440 = 3,
+    M4 = 4,
+    V4T = 5,
+    V6 = 6,
+    V5TEJ = 7,
+    XSCALE = 8,
+    V7 = 9,
+    V7F = 10, /* Cortex A9 */
+    V7S = 11, /* Swift */
+    V7K = 12  /* Kirkwood40 */
+};
+
+enum SubCpuTypeMC88000 : u24 {
+    ALL = 0,
+    MMAX_JPC = 1,
+    MC88100 = 1,
+    MC88110 = 2
+};
+
+enum SubCpuTypeMC98000 : u24 {
+    ALL = 0,
+    MC98601 = 1
+};
+
+enum SubCpuTypeI860 : u24 {
+    ALL = 0,
+    _860 = 1
+};
+
+enum SubCpuTypeI860Little : u24 {
+    ALL = 0 ... 1
+};
+
+enum SubCpuTypeRS6000 : u24 {
+    ALL = 0 ... 1
+};
+
+enum SubCpuTypeSparc : u24 {
+    ALL = 0,
+    _260 = 1,
+    _110 = 2
+};
+
+enum SubCpuTypePowerPC : u24 {
+    ALL = 0,
+    _601 = 1,
+    _602 = 2,
+    _603 = 3,
+    _603e = 4,
+    _603ev = 5,
+    _604 = 6,
+    _604e = 7,
+    _620 = 8,
+    _750 = 9,
+    _7400 = 10,
+    _7450 = 11,
+    _970 = 100
+};
+
+enum SubCpuTypeVEO : u24 {
+    _1 = 1,
+    _2 = 2,
+    _3 = 3,
+    _4 = 4,
+    ALL = SubCpuTypeVEO::_2
+};
+
+bitfield Capabilities {
+    padding : 7;
+    lib64   : 1;
+};
+
+enum FileType : u32 {
+    Object = 1,
+    Execute = 2,
+    FVMLib = 3,
+    Core = 4,
+    Preload = 5,
+    DyLib = 6,
+    DyLinker = 7,
+    Bundle = 8,
+    DyLibStub = 9,
+    DSym = 10,
+    KExtBundle = 11,
+};
+
+bitfield Flags {
+    noUndefs    : 1;
+    incrLink    : 1;
+    dyldLink    : 1;
+    binDatLoad  : 1;
+    prebound    : 1;
+    splitSegs   : 1;
+    lazyInit    : 1;
+    twoLevel : 1;
+    forceFlat : 1;
+    noMultiDefs : 1;
+    noFixPrebinding : 1;
+    prebindable : 1;
+    allModsBound : 1;
+    subSectionsViaSymbols : 1;
+    canonical : 1;
+    weakDefines : 1;
+    bindsToWeak : 1;
+    allowStackExecution : 1;
+    rootSafe : 1;
+    setuidSafe : 1;
+    noReexportedDylibs : 1;
+    pie : 1;
+    deadStrippableDylib : 1;
+    hasTlvDescriptors : 1;
+    noHeapExecution : 1;
+    appExtensionSafe : 1;
+    nlistOutOfSyncWithDyldinof : 1;
+    simSupport : 1;
+};
+
+struct Header {
+    Magic magic;
+    CpuType cpuType;
+    if (cpuType == CpuType::VAX) SubCpuTypeVAX subCpuType;
+    else if (cpuType == CpuType::ROMP) SubCpuTypeROMP subCpuType;
+    else if (cpuType == CpuType::BS32032 || cpuType == CpuType::BS32332 || cpuType == CpuType::NS32532) SubCpuType32XXX subCpuType;
+    else if (cpuType == CpuType::I386 || cpuType == CpuType::X86_64) SubCpuTypeI386 subCpuType;
+    else if (cpuType == CpuType::MIPS) SubCpuTypeMips subCpuType;
+    else if (cpuType == CpuType::HPPA) SubCpuTypeHPPA subCpuType;    
+    else if (cpuType == CpuType::ARM) SubCpuTypeARM subCpuType;
+    else if (cpuType == CpuType::MC88000) SubCpuTypeMC88000 subCpuType;
+    else if (cpuType == CpuType::MC98000) SubCpuTypeMC98000 subCpuType;
+    else if (cpuType == CpuType::I860 || cpuType == CpuType::I860_LITTLE) SubCpuTypeI860 subCpuType;
+    else if (cpuType == CpuType::SPARC) SubCpuTypeSparc subCpuType;
+    else if (cpuType == CpuType::POWERPC || cpuType == CpuType::POWERPC64) SubCpuTypePowerPC subCpuType;
+    else if (cpuType == CpuType::VEO) SubCpuTypeVEO subCpuType;
+    else u24 subCpuType;
+    Capabilities capabilities;
+    FileType fileType;
+    u32 numCommands;
+    type::Size<u32> sizeOfCommands;
+    Flags flags;
+    
+    if (magic == Magic::_64BitMagic) padding[sizeof(u32)];
+};
+
+enum Command : u32 {
+    ReqDyLd = 0x8000'0000,
+
+    Segment = 0x01,
+    SymTab = 0x02,
+    SymSeg = 0x03,
+    Thread = 0x04,
+    UnixThread = 0x05,
+    LoadFVMLib = 0x06,
+    IdFVMLib = 0x07,
+    Ident = 0x08,
+    FVMFile = 0x09,
+    PrePage = 0x0A,
+    DySymTab = 0x0B,
+    LoadDyLib = 0x0C,
+    IdDyLib = 0x0D,
+    LoadDyLinker = 0x0E,
+    IdDyLinker = 0x0F,
+    PreboundDyLib = 0x10,
+    Routines = 0x11,
+    SubFramework = 0x12,
+    SubUmbrella = 0x13,
+    SubClient = 0x14,
+    SubLibrary = 0x15,
+    TwoLevelHints = 0x16,
+    PrebindCksum = 0x17,
+    LoadWeakDyLib = 0x18 | Command::ReqDyLd,
+    Segment64 = 0x19,
+    Routines64 = 0x1A,
+    UUID = 0x1B,
+    RPath = 0x1C | 0x8000'0000,
+    CodeSignature = 0x1D,
+    SegmentSplitInfo = 0x1E,
+    ReExportDyLib = 0x1F | Command::ReqDyLd,
+    LazyLoadDyLib = 0x20,
+    EncryptionInfo = 0x21,
+    DyLdInfo = 0x22,
+    DyLdInfoOnly = 0x22 | Command::ReqDyLd,
+    LoadUpwardDyLib = 0x23 | Command::ReqDyLd,
+    VersionMinMacOSX = 0x24,
+    VersionMinIPhoneOS = 0x25,
+    FunctionStarts = 0x26,
+    DyLdEnvironment = 0x27,
+    Main = 0x28 | Command::ReqDyLd,
+    DataInCode = 0x29,
+    SourceVersion = 0x2A,
+    DyLibCodeSignDRS = 0x2B
+};
+
+struct CommandUUID {
+    u128 uuid;
+};
+
+struct Section {
+    char sectionName[16];
+    char segmentName[16];
+    u32 address;
+    type::Size<u32> size;
+    u32 offset;
+    u32 align;
+    u32 reloff;
+    u32 numRelocs;
+    u32 flags;
+    padding[8];
+    
+    if (offset > 0)
+        u8 data[size] @ offset [[sealed]];
+};
+
+struct CommandSegment {
+    char segmentName[16];
+    u32 vmAddress;
+    type::Size<u32> vmSize;
+    u32 fileOffset;
+    type::Size<u32> fileSize;
+    u32 maxProtection;
+    u32 initProtection;
+    u32 numSections;
+    u32 flags;
+    
+    Section sections[numSections];
+    
+    if (fileOffset > 0)
+        u8 data[fileSize] @ fileOffset [[sealed]];
+};
+
+struct Section64 {
+    char sectionName[16];
+    char segmentName[16];
+    u64 address;
+    type::Size<u64> size;
+    u32 offset;
+    u32 align;
+    u32 reloff;
+    u32 numRelocs;
+    u32 flags;
+    padding[12];
+    
+    if (offset > 0)
+        u8 data[size] @ offset [[sealed]];
+};
+
+struct CommandSegment64 {
+    char segmentName[16];
+    u64 vmAddress;
+    type::Size<u64> vmSize;
+    u64 fileOffset;
+    type::Size<u64> fileSize;
+    u32 maxProtection;
+    u32 initProtection;
+    u32 numSections;
+    u32 flags;
+    
+    Section64 sections[numSections];
+    
+    if (fileOffset > 0)
+        u8 data[fileSize] @ fileOffset [[sealed]];
+};
+
+struct LoadCommand {
+    Command command;
+    type::Size<u32> commandSize;
+    
+    if (command == Command::UUID)
+        CommandUUID data;
+    else if (command == Command::Segment)
+        CommandSegment data;
+    else if (command == Command::Segment64)
+        CommandSegment64 data;
+    else
+        u8 data[commandSize - 8] [[sealed]];
+};
+
+struct MachO {
+    Header header;
+    LoadCommand loadCommands[header.numCommands];
+};
+
 MachO macho @ 0x00;
--- a/patterns/max_v104.hexpat
+++ b/patterns/max_v104.hexpat
@@ -0,0 +1,831 @@
+#include <std/sys.pat>
+#include <std/mem.pat>
+
+#pragma array_limit 12544
+#pragma pattern_limit 2000000
+#pragma eval_depth 32
+
+enum FileType : u8
+{
+  Custom,
+  Tutorial,
+  Campaign,
+  Hot_seat,
+  Multiplayer,
+  Demo,
+  Debug,
+  Text,
+  Scenario,
+  Multi_scenario
+};
+
+enum PlanetType : u8
+{
+  Snowcrab,
+  Frigia,
+  Ice_Berg,
+  The_Cooler,
+  Ultima_Thule,
+  Long_Floes,
+  Iron_Cross,
+  Splatterscape,
+  Peak_a_boo,
+  Valentines_Planet,
+  Three_Rings,
+  Great_divide,
+  New_Luzon,
+  Middle_Sea,
+  High_Impact,
+  Sanctuary,
+  Islandia,
+  Hammerhead,
+  Freckles,
+  Sandspit,
+  Great_Circle,
+  Long_Passage,
+  Flash_Point,
+  Bottleneck
+};
+
+enum TeamType : u8
+{
+  None = 0,
+  Human = 1,
+  Computer = 2,
+  Remote = 3,
+  Eliminated = 4
+};
+
+enum TeamIndex : u8
+{
+  Red = 0,
+  Green = 1,
+  Blue = 2,
+  Gray = 3
+};
+
+enum TeamIndex16 : u16
+{
+  Red = 0,
+  Green = 1,
+  Blue = 2,
+  Gray = 3
+};
+
+enum PlayMode : u8
+{
+  Turn_Based = 0,
+  Simultaneous_Moves = 1
+};
+
+enum TeamClan : u8
+{
+  None = 0,
+  The_Chosen = 1,
+  Crimson_Path = 2,
+  Von_Griffin = 3,
+  Ayers_Hand = 4,
+  Musashi = 5,
+  Sacred_Eights = 6,
+  Seven_Knights = 7,
+  Axis_Inc = 8
+};
+
+enum OpponentType : u8
+{
+  Clueless = 0,
+  Apprentice = 1,
+  Average = 2,
+  Expert = 3,
+  Master = 4,
+  God = 5
+};
+
+enum VictoryType : u8
+{
+  Duration = 0,
+  Score = 1
+};
+
+struct IniOptions
+{
+  s32 world;
+  s32 turn_timer;
+  s32 endturn;
+  s32 start_gold;
+  s32 play_mode;
+  s32 victory_type;
+  s32 victory_limit;
+  s32 opponent;
+  s32 raw_resource;
+  s32 fuel_resource;
+  s32 gold_resource;
+  s32 alien_derelicts;
+};
+
+struct IniPreferences
+{
+  s32 effects;
+  s32 click_scroll;
+  s32 quick_scroll;
+  s32 fast_movement;
+  s32 follow_unit;
+  s32 auto_select;
+  s32 enemy_halt;
+};
+
+enum SurfaceType : u8
+{
+  Land = 1,
+  Water = 2,
+  Coast = 4,
+  Air = 8
+};
+
+enum AiStrategy : u8
+{
+  Random,
+  Defensive,
+  Missiles,
+  Air,
+  Sea,
+  Scout_horde,
+  Tank_horde,
+  Fast_attack,
+  Combined_arms,
+  Espionage
+};
+
+bitfield GridResourceMapEntry
+{
+  padding : 2;
+  team_visibility_gray : 1;
+  team_visibility_blue : 1;
+  team_visibility_green : 1;
+  team_visibility_red : 1;
+  padding : 2;
+  cargo_amount : 5;
+  cargo_type_fuel : 1;
+  cargo_type_gold : 1;
+  cargo_type_material : 1;
+};
+
+bitfield UnitFlags
+{
+  // MSB
+  requires_slab: 1;
+  turret_sprite: 1;
+  sentry_unit: 1;
+  spinning_turret: 1;
+  padding: 4;
+
+  hovering: 1;
+  has_firing_sprite: 1;
+  fires_missiles: 1;
+  constructor_unit: 1;
+  padding: 1;
+  electronic_unit: 1;
+  selectable: 1;
+  standalone: 1;
+
+  mobile_land_unit: 1;
+  stationary: 1;
+  padding: 4;
+  upgradeable: 1;
+  padding: 1;
+
+  // LSB
+  ground_cover : 1;
+  exploding: 1;
+  animated: 1;
+  connector_unit: 1;
+  building: 1;
+  missile_unit: 1;
+  mobile_air_unit: 1;
+  mobile_sea_unit: 1;
+};
+
+struct Point
+{
+  s16 x;
+  s16 y;
+};
+
+struct ResearchTopicInfo
+{
+  u32 research_level;
+  u32 turns_to_complete;
+  s32 allocation;
+};
+
+struct ScreenLocation
+{
+  s8 x;
+  s8 y;
+};
+
+struct TeamInfo
+{
+  Point markers[10];
+  TeamType team_type;
+  s8 field_41;
+  TeamClan team_clan;
+  ResearchTopicInfo research_topics[8];
+  u32 victory_points;
+  u16 next_unit_id;
+  u8 unit_counters[93];
+  ScreenLocation screen_location[6];
+  u16 score_graph[50];
+  u16 selected_unit;
+  u16 zoom_level;
+  Point screen_position;
+  bool gui_button_state_range;
+  bool gui_button_state_scan;
+  bool gui_button_state_status;
+  bool gui_button_state_colors;
+  bool gui_button_state_hits;
+  bool gui_button_state_ammo;
+  bool gui_button_state_names;
+  bool gui_button_state_minimap_2x;
+  bool gui_button_state_minimap_tnt;
+  bool gui_button_state_grid;
+  bool gui_button_state_survey;
+  u16 stats_factories_built;
+  u16 stats_mines_built;
+  u16 stats_buildings_built;
+  u16 stats_units_built;
+  u16 casualties[93];
+  u16 stats_gold_spent_on_upgrades;
+};
+
+struct UnitValues
+{
+  u16 object_index;
+
+  if(CheckObjectId(object_index, true) == true)
+  {
+    u16 class_type;
+    u16 turns;
+    u16 hits;
+    u16 armor;
+    u16 attack;
+    u16 speed;
+    u16 range;
+    u16 rounds;
+    bool move_and_fire;
+    u16 scan;
+    u16 storage;
+    u16 ammo;
+    u16 attack_radius;
+    u16 agent_adjust;
+    u16 version;
+    u8 units_built;
+  }
+};
+
+struct Complex
+{
+  u16 object_index;
+  
+  if(CheckObjectId(object_index, true) == true)
+  {
+    u16 class_type;
+    s16 material;
+    s16 fuel;
+    s16 gold;
+    s16 power;
+    s16 workers;
+    s16 buildings;
+    s16 id;
+  }
+};
+
+struct TeamUnits
+{
+  s16 gold;
+  UnitValues base_unit_values[93];
+  UnitValues current_unit_values[93];
+  u16 complex_count;
+  Complex complexes[complex_count];
+};
+
+enum UnitType : u16
+{
+  UNIT_TYPE_GOLD_REFINERY = 0,
+  UNIT_TYPE_POWER_STATION = 1,
+  UNIT_TYPE_POWER_GENERATOR = 2,
+  UNIT_TYPE_BARRACKS = 3,
+  UNIT_TYPE_ALIEN_BUILDING_1 = 4,
+  UNIT_TYPE_RADAR = 5,
+  UNIT_TYPE_STORAGE_UNIT = 6,
+  UNIT_TYPE_FUEL_TANK = 7,
+  UNIT_TYPE_GOLD_VAULT = 8,
+  UNIT_TYPE_DEPOT = 9,
+  UNIT_TYPE_HANGAR = 10,
+  UNIT_TYPE_DOCK = 11,
+  UNIT_TYPE_CONNECTOR = 12,
+  UNIT_TYPE_LARGE_RUBBLE_1 = 13,
+  UNIT_TYPE_SMALL_RUBBLE_1 = 14,
+  UNIT_TYPE_LARGE_TAPE = 15,
+  UNIT_TYPE_SMALL_TAPE = 16,
+  UNIT_TYPE_LARGE_SLAB = 17,
+  UNIT_TYPE_SMALL_SLAB = 18,
+  UNIT_TYPE_LARGE_CONES = 19,
+  UNIT_TYPE_SMALL_CONES = 20,
+  UNIT_TYPE_ROAD = 21,
+  UNIT_TYPE_LANDING_PAD = 22,
+  UNIT_TYPE_SHIPYARD = 23,
+  UNIT_TYPE_LIGHT_VEHICLE_PLANT = 24,
+  UNIT_TYPE_HEAVY_VEHICLE_PLANT = 25,
+  UNIT_TYPE_ALIEN_BUILDING_2 = 26,
+  UNIT_TYPE_AIR_UNITS_PLANT = 27,
+  UNIT_TYPE_HABITAT = 28,
+  UNIT_TYPE_RESEARCH_CENTER = 29,
+  UNIT_TYPE_ECOSPHERE = 30,
+  UNIT_TYPE_ALIEN_BUILDING_3 = 31,
+  UNIT_TYPE_TRAINING_HALL = 32,
+  UNIT_TYPE_WATER_PLATFORM = 33,
+  UNIT_TYPE_GUN_TURRET = 34,
+  UNIT_TYPE_ANTI_AIRCRAFT = 35,
+  UNIT_TYPE_ARTILLERY = 36,
+  UNIT_TYPE_MISSILE_LAUNCHER = 37,
+  UNIT_TYPE_CONCRETE_BLOCK = 38,
+  UNIT_TYPE_BRIDGE = 39,
+  UNIT_TYPE_MINING_STATION = 40,
+  UNIT_TYPE_LAND_MINE = 41,
+  UNIT_TYPE_SEA_MINE = 42,
+  UNIT_TYPE_LAND_EXPLOSION = 43,
+  UNIT_TYPE_AIR_EXPLOSION = 44,
+  UNIT_TYPE_SEA_EXPLOSION = 45,
+  UNIT_TYPE_BUILDING_EXPLOSION = 46,
+  UNIT_TYPE_HIT_EXPLOSION = 47,
+  UNIT_TYPE_MASTER_BUILDER = 48,
+  UNIT_TYPE_CONSTRUCTOR = 49,
+  UNIT_TYPE_SCOUT = 50,
+  UNIT_TYPE_TANK = 51,
+  UNIT_TYPE_ASSAULT_GUN  = 52,
+  UNIT_TYPE_ROCKET_LAUNCHER = 53,
+  UNIT_TYPE_MISSILE_CRAWLER = 54,
+  UNIT_TYPE_MOBILE_ANTI_AIRCRAFT = 55,
+  UNIT_TYPE_MINE_LAYER = 56,
+  UNIT_TYPE_SURVEYOR = 57,
+  UNIT_TYPE_SCANNER = 58,
+  UNIT_TYPE_SUPPLY_TRUCK = 59,
+  UNIT_TYPE_GOLD_TRUCK = 60,
+  UNIT_TYPE_ENGINEER = 61,
+  UNIT_TYPE_BULLDOZER = 62,
+  UNIT_TYPE_REPAIR_UNIT = 63,
+  UNIT_TYPE_FUEL_TRUCK = 64,
+  UNIT_TYPE_PERSONNEL_CARRIER = 65,
+  UNIT_TYPE_INFILTRATOR = 66,
+  UNIT_TYPE_INFANTRY = 67,
+  UNIT_TYPE_ESCORT = 68,
+  UNIT_TYPE_CORVETTE = 69,
+  UNIT_TYPE_GUNBOAT = 70,
+  UNIT_TYPE_SUBMARINE = 71,
+  UNIT_TYPE_SEA_TRANSPORT = 72,
+  UNIT_TYPE_MISSILE_CRUISER = 73,
+  UNIT_TYPE_SEA_MINE_LAYER = 74,
+  UNIT_TYPE_CARGO_SHIP = 75,
+  UNIT_TYPE_FIGHTER = 76,
+  UNIT_TYPE_GROUND_ATTACK_PLANE = 77,
+  UNIT_TYPE_AIR_TRANSPORT = 78,
+  UNIT_TYPE_AWAC = 79,
+  UNIT_TYPE_ALIEN_GUNBOAT = 80,
+  UNIT_TYPE_ALIEN_TANK = 81,
+  UNIT_TYPE_ALIEN_ASSAULT_GUN = 82,
+  UNIT_TYPE_ALIEN_ATTACK_PLANE = 83,
+  UNIT_TYPE_MISSILE = 84,
+  UNIT_TYPE_TORPEDO = 85,
+  UNIT_TYPE_ALIEN_MISSILE = 86,
+  UNIT_TYPE_TANK_PLASMA_BALL = 87,
+  UNIT_TYPE_ARTILLERY_PLASMA_BALL = 88,
+  UNIT_TYPE_SMOKE_TRAIL = 89,
+  UNIT_TYPE_BUBBLE_TRAIL = 90,
+  UNIT_TYPE_HARVESTER = 91,
+  UNIT_TYPE_DEAD_WALDO = 92
+};
+
+enum OrderType : u8
+{
+  ORDER_TYPE_AWAITING = 0x0,
+  ORDER_TYPE_TRANSFORMING = 0x1,
+  ORDER_TYPE_MOVING = 0x2,
+  ORDER_TYPE_FIRING = 0x3,
+  ORDER_TYPE_ORDER_BUILDING = 0x4,
+  ORDER_TYPE_ACTIVATE_ORDER = 0x5,
+  ORDER_TYPE_NEW_ALLOCATE_ORDER = 0x6,
+  ORDER_TYPE_POWER_ON = 0x7,
+  ORDER_TYPE_POWER_OFF = 0x8,
+  ORDER_TYPE_EXPLODING = 0x9,
+  ORDER_TYPE_UNLOADING = 0xA,
+  ORDER_TYPE_CLEARING = 0xB,
+  ORDER_TYPE_SENTRY = 0xC,
+  ORDER_TYPE_LANDING = 0xD,
+  ORDER_TYPE_TAKING_OFF = 0xE,
+  ORDER_TYPE_LOADING = 0xF,
+  ORDER_TYPE_IDLE = 0x10,
+  ORDER_TYPE_REPAIRING = 0x11,
+  ORDER_TYPE_REFUELING = 0x12,
+  ORDER_TYPE_RELOADING = 0x13,
+  ORDER_TYPE_TRANSFERRING = 0x14,
+  ORDER_TYPE_AWAITING_21 = 0x15,
+  ORDER_TYPE_AWAITING_22 = 0x16,
+  ORDER_TYPE_AWAITING_23 = 0x17,
+  ORDER_TYPE_AWAITING_24 = 0x18,
+  ORDER_TYPE_AWAITING_25 = 0x19,
+  ORDER_TYPE_DISABLED = 0x1A,
+  ORDER_TYPE_MOVING_27 = 0x1B,
+  ORDER_TYPE_REPAIRING_28 = 0x1C,
+  ORDER_TYPE_TRANSFERRING_29 = 0x1D,
+  ORDER_TYPE_ATTACKING = 0x1E,
+  ORDER_TYPE_BUILDING_HALTED = 0x1F
+};
+
+struct Rect
+{
+  s32 ulx;
+  s32 uly;
+  s32 lrx;
+  s32 lry;
+};
+
+struct PathStep
+{
+  s8 x;
+  s8 y;
+};
+
+struct Path
+{
+  u16 object_index;
+  
+  if(CheckObjectId(object_index, true) == true)
+  {
+    u16 class_type;
+    
+    // Air path
+    if (class_type == 1)
+    {
+      s16 length;
+      u8 angle;
+      Point pixel_start;
+      Point pixel_end;
+      s32 x_step;
+      s32 y_step;
+      s32 delta_x;
+      s32 delta_y;
+    }
+    // Ground path
+    else if (class_type == 4)
+    {
+      Point pixel_end;
+      s16 index;
+      s16 steps_count;
+      PathStep steps[steps_count];
+    }
+    // Builder path
+    else if (class_type == 2)
+    {
+      Point coordinate;
+    }
+    else
+    {
+      std::assert(0, "Unknown path class");
+    }
+  }
+};
+
+struct UnitTypeArray
+{
+  u16 object_count;
+
+  UnitType array[object_count];
+};
+
+struct UnitInfo
+{
+  u16 object_index;
+
+  if(CheckObjectId(object_index, true) == true)
+  {
+    u16 class_type;
+    UnitType unit_type;
+    
+    if (unit_type == UnitType::UNIT_TYPE_DEAD_WALDO)
+    {
+      std::print("Found Waldo!");
+    }
+    
+    u16 hash_id;
+    UnitFlags flags;
+    Point pixel_position;
+    Point grid_position;
+    u16 name_length;
+    s8 name[name_length];
+    Point shadow_offset;
+    TeamIndex team;
+    u8 name_index;
+    u8 brightness;
+    u8 angle;
+    u8 visible_to_team[5];
+    u8 spotted_by_team[5];
+    u8 max_velocity;
+    u8 velocity;
+    u8 sound;
+    u8 scaler_adjust;
+    Rect sprite_bounds;
+    Rect shadow_bounds;
+    u8 turret_angle;
+    s8 turret_offset_x;
+    s8 turret_offset_y;
+    u16 total_images;
+    u16 image_base;
+    u16 turret_image_base;
+    u16 firing_image_base;
+    u16 connector_image_base;
+    u16 image_index;
+    u16 turret_image_index;
+    u16 image_index_max;
+    OrderType orders;
+    u8 state;
+    OrderType prior_orders;
+    u8 prior_state;
+    u8 laying_state;
+    Point target_grid;
+    u8 build_time;
+    u8 total_mining;
+    u8 raw_mining;
+    u8 fuel_mining;
+    u8 gold_mining;
+    u8 raw_mining_max;
+    u8 gold_mining_max;
+    u8 fuel_mining_max;
+    u8 hits;
+    u8 speed;
+    u8 shots;
+    u8 move_and_fire;
+    u16 storage;
+    u8 ammo;
+    u8 targeting_mode;
+    u8 enter_mode;
+    u8 cursor;
+    u8 recoil_delay;
+    u8 delayed_reaction;
+    u8 damaged_this_turn;
+    u8 research_topic;
+    u8 moved;
+    u8 bobbed;
+    u8 shake_effect_state;
+    u8 engine;
+    u8 weapon;
+    u8 comm;
+    u8 fuel_distance;
+    u8 move_fraction;
+    u8 energized;
+    u8 repeat_build;
+    u16 build_rate;
+    u8 disabled_reaction_fire;
+    u8 auto_survey;
+    u32 field_221;
+    Path path;
+    u16 connectors;
+    UnitValues base_values;
+    Complex complex;
+    UnitInfo parent_unit;
+    UnitInfo enemy_unit;
+    UnitTypeArray build_list;
+  }
+};
+
+struct UnitInfoList
+{
+  u16 unitinfo_count;
+  UnitInfo units[unitinfo_count];
+};
+
+struct HashMapUnitInfo
+{
+  u16 hash_size;
+  UnitInfoList map[hash_size];
+};
+
+struct MapHash
+{
+  Point coordinates;
+  UnitInfoList units;
+};
+
+struct MapHashList
+{
+  u16 maphash_count;
+  MapHash objects[maphash_count];
+};
+
+struct HashMapMapHash
+{
+  u16 hash_size;
+  s16 x_shift;
+  MapHashList map[hash_size];
+};
+
+struct TeamHeatMaps
+{
+  u8 heatmap_complete[12544];
+  u8 heatmap_stealth_sea[12544];
+  u8 heatmap_stealth_land[12544];
+};
+
+struct MessageLog
+{
+  s16 length;
+  char text[length];
+  UnitInfo unit;
+  Point coordinates;
+  bool is_alert_message;
+  u16 resource_id;
+};
+
+struct MessageLogList
+{
+  u16 message_log_count;
+  MessageLog entires[message_log_count];
+};
+
+struct AiMap
+{
+  UnitInfo unit;
+  TeamIndex16 team;
+  bool visible_to_team;
+  Point point;
+};
+
+struct AiMapList
+{
+  u16 ai_map_count;
+  AiMap objects[ai_map_count];
+};
+
+struct AiPlayer
+{
+  TeamIndex16 team;
+  AiStrategy strategy;
+  s16 field_3;
+  s16 field_5;
+  s16 field_7;
+  TeamIndex16 target_team;
+  AiMapList map_list;
+  u16 has_info_map;
+  
+  if (has_info_map)
+  {
+  	u8 info_map[12544];
+  }
+  
+  u16 has_mine_map;
+  
+  if (has_mine_map)
+  {
+    u8 mine_map[12544];
+  }
+  
+  Point target_location;
+};
+
+u16 last_object_index;
+bool context;
+
+fn Init()
+{
+    context = false;
+	last_object_index = 0;
+};
+
+fn CheckObjectId(u16 index, bool caller)
+{
+  bool result = false;
+
+  // ImHex bug workaround
+  if (context) { context = false; return result; }
+
+  // null object?
+  if (index == 0)
+  {
+    return false;
+  }
+
+  // already serialized object?
+  if (last_object_index < index)
+  {
+  	last_object_index = index;
+  	result = true;
+  }
+  
+  return result;
+};
+
+struct SaveFile
+{
+  Init();
+
+  s16 version;
+  FileType save_file_type;
+  char save_game_name[30];
+  PlanetType planet;
+  s16 mission_index;
+  char team_name_red[30];
+  char team_name_green[30];
+  char team_name_blue[30];
+  char team_name_gray[30];
+  TeamType team_type_red;
+  TeamType team_type_green;
+  TeamType team_type_blue;
+  TeamType team_type_gray;
+  TeamType team_type_alien;
+  TeamClan team_clan_red;
+  TeamClan team_clan_green;
+  TeamClan team_clan_blue;
+  TeamClan team_clan_gray;
+  TeamClan team_clan_alien;
+  u32 rng_seed;
+  OpponentType opponent;
+  s16 turn_timer;
+  s16 endturn;
+  PlayMode play_mode;
+  IniOptions options;
+  SurfaceType surface_map[12544];
+  GridResourceMapEntry GridResourceMap[12544];
+  TeamInfo team_info_red;
+  TeamInfo team_info_green;
+  TeamInfo team_info_blue;
+  TeamInfo team_info_gray;
+  TeamIndex active_turn_team;
+  TeamIndex player_team;
+  s32 turn_counter;
+  s16 game_state;
+  u16 turn_timer_;
+  IniPreferences preferences;
+  TeamUnits team_units_red;
+  TeamUnits team_units_green;
+  TeamUnits team_units_blue;
+  TeamUnits team_units_gray;
+  UnitInfoList unit_info_list_ground_cover_units;
+  UnitInfoList unit_info_list_mobile_land_sea_units;
+  UnitInfoList unit_info_list_stationary_units;
+  UnitInfoList unit_info_list_mobile_air_units;
+  UnitInfoList unit_info_list_particles;
+  HashMapUnitInfo hash_map_unit_info;
+  HashMapMapHash hash_map_map_hash;
+
+  if (team_type_red != TeamType::None)
+  {
+    TeamHeatMaps heat_maps_red;
+  }
+
+  if (team_type_green != TeamType::None)
+  {
+    TeamHeatMaps heat_maps_green;
+  }
+
+  if (team_type_blue != TeamType::None)
+  {
+    TeamHeatMaps heat_maps_blue;
+  }
+
+  if (team_type_gray != TeamType::None)
+  {
+    TeamHeatMaps heat_maps_gray;
+  }
+
+  MessageLogList message_log_red;
+  MessageLogList message_log_green;
+  MessageLogList message_log_blue;
+  MessageLogList message_log_gray;
+  
+  if (team_type_red == TeamType::Computer)
+  {
+    AiPlayer ai_player_red;
+  }
+
+  if (team_type_green == TeamType::Computer)
+  {
+    AiPlayer ai_player_green;
+  }
+
+  if (team_type_blue == TeamType::Computer)
+  {
+    AiPlayer ai_player_blue;
+  }
+
+  if (team_type_gray == TeamType::Computer)
+  {
+    AiPlayer ai_player_gray;
+  }
+
+};
+
+SaveFile save @ 0x0;
+
+std::assert($ == std::mem::size(), "Extra data found after parsed data");
+
+
--- a/patterns/midi.hexpat
+++ b/patterns/midi.hexpat
@@ -1,72 +1,278 @@
+#include <std/core.pat>
+
 #pragma MIME audio/midi
+#pragma endian big

-using Delta = u8;
-using NoteValue = u8;
-using Velocity = u8;
-using EOF = u8;
-
-// this is just for debugging midi file generation
-// I'm testing a known good file against a bad one
-// the file is hard coded in file format 0, and if
-// you're expecting meta events anywhere add a specific
-// call for those
+// Only supports format 0
 // https://www.music.mcgill.ca/~ich/classes/mumt306/StandardMIDIfileformat.html

-enum NoteEvent : u8 {
-    NoteOn = 0x90,
-    NoteOff = 0x80
+bool g_has_more_messages = true;
+bool g_has_more_tracks = true;
+
+fn signed14(s16 n) {
+    // Converts to 14-bit in range 0..16383. Note that MIDI data bytes
+    // have their first (most significant) bit clear (0), thus each byte
+    // is in range 0..127
+    n = ((n & 0x7f) << 7) | ((n >> 8) & 0x7f);
+    if (n >= 0) {
+        n -= 0x2000;
+    }
+    return n;
 };

-enum MetaFlag : u16 {
-    Footer = 0xFF2F,
-    KeySigEvent = 0xFF59,
-    TimeSigEvent = 0xFF58,
-    TempoEvent = 0xFF51,
-    TrackNameEvent = 0xFF03
+fn u32ify(u32 vlq) {
+    // Converts from variable-length quantity to u32. These numbers are
+    // represented 7 bits per byte, most significant bits first. All bytes
+    // except the last have bit 7 set, and the last byte has bit 7 clear.
+    // If the number is in range 0..127, it is thus represented exactly
+    // as one byte.
+    u32 n = vlq & 0x7f;
+    if (vlq & 0x8000 == 0x8000) {
+        n += ((vlq & 0x7f00) >> 8) * 0x80;
+    }
+    if (vlq & 0x800000 == 0x800000) {
+        n += ((vlq & 0x7f0000) >> 8 * 2) * 0x80 * 0x80;
+    }
+    if (vlq & 0x80000000 == 0x80000000) {
+        n += ((vlq & 0x7f000000) >> 8 * 3) * 0x80 * 0x80 * 0x80;
+    }
+    return n;
+};
+
+enum Status : u8 {
+    NoteOff = 0x80 ... 0x8F,
+    NoteOn = 0x90 ... 0x9F,
+    PolyphonicAfterTouch = 0xA0 ... 0xAF,
+    ControlChange = 0xB0 ... 0xBF,
+    ProgramChange = 0xC0 ... 0xCF,
+    ChannelAfterTouch = 0xD0 ... 0xDF,
+    PitchWheel = 0xE0 ... 0xEF,
+    SysEx = 0xF0,
+    TimeCodeQtrFrame = 0xF1,
+    SongPositionPointer = 0xF2,
+    SongSelect = 0xF3,
+    Undefined = 0xF4 ... 0xF5,
+    TuneRequest = 0xF6,
+    EndOfSysEx = 0xF7,
+    TimingClock = 0xF8,
+    Undefined = 0xF9,
+    Start = 0xFA,
+    Continue = 0xFB,
+    Stop = 0xFC,
+    Undefined = 0xFD,
+    ActiveSensing = 0xFE,
+    MetaEvent = 0xFF,
+};
+
+Status g_next_status;
+
+enum MetaType : u8 {
+    SequenceNumber = 0x00,
+    Text = 0x01,
+    CopyrightNotice = 0x02,
+    TrackName = 0x03,
+    InstrumentName = 0x04,
+    Lyric = 0x05,
+    Marker = 0x06,
+    CuePoint = 0x07,
+    ChannelPrefix = 0x20,
+    EndOfTrack = 0x2F,
+    SetTempo = 0x51,
+    SMPTEOffset = 0x54,
+    TimeSignature = 0x58,
+    KeySignature = 0x59,
+    SequencerSpecific = 0x7F
+};
+
+enum ControlChangeType : u8 {
+    Bank_Select_MSB = 0,
+    Modulation_Wheel_MSB = 1,
+    Breath_Controller_MSB = 2,
+    Undefined_MSB = 3,
+    Foot_Pedal_MSB = 4,
+    Portamento_Time_MSB = 5,
+    Data_Entry_MSB = 6,
+    Volume_MSB = 7,
+    Balance_MSB = 8,
+    Undefined_MSB = 9,
+    Pan_MSB = 10,
+    Expression_MSB = 11,
+    Effect_Controller_1_MSB = 12,
+    Effect_Controller_2_MSB = 13,
+    Undefined_MSB = 14,
+    Undefined_MSB = 15,
+    General_Purpose_MSB = 16 ... 19,
+    Undefined_MSB = 20 ... 31,
+    Bank_Select_LSB = 32,
+    Modulation_Wheel_LSB = 33,
+    Breath_Controller_LSB = 34,
+    Undefined_LSB = 35,
+    Foot_Pedal_LSB = 36,
+    Portamento_Time_LSB = 37,
+    Data_Entry_LSB = 38,
+    Volume_LSB = 39,
+    Balance_LSB = 40,
+    Undefined_LSB = 41,
+    Pan_LSB = 42,
+    Expression_LSB = 43,
+    Effect_Controller_1_LSB = 44,
+    Effect_Controller_2_LSB = 45,
+    Undefined_LSB = 46,
+    Undefined_LSB = 47,
+    General_Purpose_LSB = 48 ... 51,
+    Undefined_LSB = 52 ... 63,
+    Damper_Pedal = 64,
+    Portamento = 65,
+    Sostenuto_Pedal = 66,
+    Soft_Pedal = 67,
+    Legato_FootSwitch = 68,
+    Hold_2 = 69,
+    Sound_Controller_1 = 70,
+    Sound_Controller_2 = 71,
+    Sound_Controller_3 = 72,
+    Sound_Controller_4 = 73,
+    Sound_Controller_6 = 75,
+    Sound_Controller_7 = 76,
+    Sound_Controller_8 = 77,
+    Sound_Controller_9 = 78,
+    Sound_Controller_10 = 79,
+    General_Purpose_CC_Control = 80 ... 83,
+    Portamento_CC_Control = 84,
+    Undefined = 85 ... 87,
+    High_Resolution_Velocity_Prefix = 88,
+    Effect_2_Depth = 92,
+    Effect_3_Depth = 93,
+    Effect_4_Depth = 94,
+    Effect_5_Depth = 95,
+    Data_Increment = 96,
+    Data_Decrement = 97,
+    Non_Registered_Parameter_Number_LSB = 98,
+    Non_Registered_Parameter_Number_MSB = 99,
+    Registered_Parameter_Number_LSB = 100,
+    Registered_Parameter_Number_MSB = 101,
+    Undefined = 102 ... 119,
+    All_Sound_Off = 120,
+    Reset_All_Controllers = 121,
+    Local_Switch = 122,
+    All_Notes_Off = 123,
+    Omni_Mode_Off = 124,
+    Omni_Mode_On = 125,
+    Mono_Mode = 126,
+    Poly_Mode = 127,
 };

 enum HeaderFlag : u32 {
    MThd = 0x4D546864
 };

-enum TrackChunk : u32 {
+enum TrackFlag : u32 {
    MTrk = 0x4D54726B
 };

-struct TimeSigEvent {
-    Delta delta;
-    MetaFlag flag;
-    u16 numerator;
-    u8 denominator;
-    u8 ticks_per_click; // not used
-    u8 thirty_second_notes_per_crotchet;
+struct VariableLengthQuantity<auto name> {
+    if (std::mem::read_unsigned($, 1) & 0x80 == 0x80) {
+        if (std::mem::read_unsigned($ + 1, 1) & 0x80 == 0x80) {
+            if (std::mem::read_unsigned($ + 2, 1) & 0x80 == 0x80) {
+                u32 value [[format("u32ify"), name(name)]];
+            } else {
+                u24 value [[format("u32ify"), name(name)]];
+            }
+        } else {
+            u16 value [[format("u32ify"), name(name)]];
+        }
+    } else {
+        u8 value [[format("u32ify"), name(name)]];
+    }
 };

-struct KeySigEvent {
-    Delta delta;
-    MetaFlag flag;
-    u16 key;
-    u8 mode;
+struct MessageData {
+    match (u8(g_next_status) & 0xf0) {
+        (Status::NoteOff | Status::NoteOn): {
+            u8 note_number;
+            u8 velocity;
+        }
+        (Status::PolyphonicAfterTouch): {
+            u8 note_number;
+            u8 amount;
+        }
+        (Status::ControlChange): {
+            ControlChangeType cc_number;
+            u8 value;
+        }
+        (Status::ProgramChange): {
+            u8 program_number;
+        }
+        (Status::ChannelAfterTouch): {
+            u8 amount;
+        }
+        (Status::PitchWheel): {
+            s16 value [[format("signed14")]];
+        }
+    }
+    match (g_next_status) {
+        (Status::SysEx | Status::EndOfSysEx): {
+            // "EndOfSysEx" can appear as the last data byte in a
+            // system exclusive message, or as the starting byte in
+            // multi-packet messages
+            VariableLengthQuantity<"sysex_length"> sysex_length [[inline]];
+            u8 sysex_data[sysex_length.value];
+        }
+        (Status::SongPositionPointer): {
+            u8 lsb;
+            u8 msb;
+        }
+        (Status::SongSelect): {
+            u8 song_number;
+        }
+        (Status::MetaEvent): {
+            MetaType meta_type;
+            VariableLengthQuantity<"meta_length"> meta_length [[inline]];
+            match (meta_type) {
+                (MetaType::EndOfTrack): {
+                    g_has_more_messages = false;
+                    g_has_more_tracks = std::mem::read_unsigned($, 4) == le u32(TrackFlag::MTrk);
+                }
+                (MetaType::Text
+                    | MetaType::CopyrightNotice
+                    | MetaType::TrackName
+                    | MetaType::InstrumentName
+                    | MetaType::Lyric
+                    | MetaType::Marker
+                    | MetaType::CuePoint): {
+                    char text[meta_length.value];
+                }
+                (MetaType::TimeSignature): {
+                    u8 numerator;
+                    u8 denominator;
+                    u8 ticks_per_click;
+                    u8 thirty_second_notes_per_crotchet;
+                }
+                (MetaType::KeySignature): {
+                    u8 key;
+                    u8 mode;
+                }
+                (MetaType::SetTempo): {
+                    u24 micro_seconds_per_click; // default 1 million
+                }
+                (_): {
+                    u8 meta_data[meta_length.value];
+                }
+            }
+        }
+    }
 };

-struct TempoEvent {
-    Delta delta;
-    MetaFlag flag;
-    u32 micro_seconds_per_click; // default 1 million
-};
+struct Message {
+    VariableLengthQuantity<"delta"> delta [[inline]];

-struct TrackNameEvent {
-    Delta delta;
-    MetaFlag flag;
-    u8 length;
-    u8 text;
-};
+    // Status bytes of MIDI channel messages may be omitted if the
+    // preceding event is a MIDI channel message with the same status
+    if (std::mem::read_unsigned($, 1) > 0x7f) {
+        Status status;
+        g_next_status = status;
+    }

-struct Note {
-    Delta delta;
-    NoteEvent ne;
-    NoteValue note;
-    Velocity vel;
+    MessageData data [[inline]];
 };

 struct HeaderChunk {
@@ -75,21 +281,18 @@ struct HeaderChunk {
    u16 mode;
    u16 num_tracks;
    u16 ticks_per_quarter;
-    TrackChunk chunk;
-    u32 track_length;
 };

-struct Footer {
-	Delta d;
-	MetaFlag m;
-	EOF eof;
+struct TrackChunk {
+    TrackFlag flag;
+    u32 length;
+    g_has_more_messages = true;
+    Message messages[while(g_has_more_messages)];
 };

 struct MidiFile {
    HeaderChunk header;
-    // whatever meta flags can be in here
-    Note notes[12]; //however many notes you're looking at
-    Footer f;
+    TrackChunk tracks[while(g_has_more_tracks)];
 };

 MidiFile midi_file @ 0x00;
--- a/patterns/minidump.hexpat
+++ b/patterns/minidump.hexpat
@@ -1,423 +1,423 @@
-#pragma MIME application/x-dmp
-
-#include <type/time.pat>
-#include <type/types/win32.pat>
-#include <type/size.pat>
-
-using RVA = ULONG32;
-using RVA64 = ULONG64;
-
-enum MINIDUMP_STREAM_TYPE : ULONG32 {
-    UnusedStream                = 0,
-    ReservedStream0             = 1,
-    ReservedStream1             = 2,
-    ThreadListStream            = 3,
-    ModuleListStream            = 4,
-    MemoryListStream            = 5,
-    ExceptionStream             = 6,
-    SystemInfoStream            = 7,
-    ThreadExListStream          = 8,
-    Memory64ListStream          = 9,
-    CommentStreamA              = 10,
-    CommentStreamW              = 11,
-    HandleDataStream            = 12,
-    FunctionTableStream         = 13,
-    UnloadedModuleListStream    = 14,
-    MiscInfoStream              = 15,
-    MemoryInfoListStream        = 16,
-    ThreadInfoListStream        = 17,
-    HandleOperationListStream   = 18,
-    TokenStream                 = 19,
-    JavaScriptDataStream        = 20,
-    SystemMemoryInfoStream      = 21,
-    ProcessVmCountersStream     = 22,
-    IptTraceStream              = 23,
-    ThreadNamesStream           = 24,
-    ceStreamNull                = 0x8000,
-    ceStreamSystemInfo          = 0x8001,
-    ceStreamException           = 0x8002,
-    ceStreamModuleList          = 0x8003,
-    ceStreamProcessList         = 0x8004,
-    ceStreamThreadList          = 0x8005,
-    ceStreamThreadContextList   = 0x8006,
-    ceStreamThreadCallStackList = 0x8007,
-    ceStreamMemoryVirtualList   = 0x8008,
-    ceStreamMemoryPhysicalList  = 0x8009,
-    ceStreamBucketParameters    = 0x800A,
-    ceStreamProcessModuleMap    = 0x800B,
-    ceStreamDiagnosisList       = 0x800C,
-    LastReservedStream          = 0xFFFF
-};
-
-struct MINIDUMP_LOCATION_DESCRIPTOR {
-    type::Size32 DataSize;
-    RVA Rva;
-};
-
-struct MINIDUMP_MEMORY_DESCRIPTOR {
-    ULONG64 StartOfMemoryRange;
-    MINIDUMP_LOCATION_DESCRIPTOR Memory;
-};
-
-struct MINIDUMP_THREAD {
-    ULONG32 ThreadId;
-    ULONG32 SuspendCount;
-    ULONG32 PriorityClass;
-    ULONG32 Priority;
-    ULONG64 Teb;
-    MINIDUMP_MEMORY_DESCRIPTOR Stack;
-    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
-};
-
-struct MINIDUMP_THREAD_LIST {
-    ULONG32 NumberOfThreads;
-    MINIDUMP_THREAD Threads[NumberOfThreads];
-};
-
-struct VS_FIXEDFILEINFO {
-    DWORD dwSignature;
-    DWORD dwStrucVersion;
-    DWORD dwFileVersionMS;
-    DWORD dwFileVersionLS;
-    DWORD dwProductVersionMS;
-    DWORD dwProductVersionLS;
-    DWORD dwFileFlagsMask;
-    DWORD dwFileFlags;
-    DWORD dwFileOS;
-    DWORD dwFileType;
-    DWORD dwFileSubtype;
-    DWORD dwFileDateMS;
-    DWORD dwFileDateLS;
-};
-
-struct MINIDUMP_MODULE {
-    ULONG64 BaseOfImage;
-    type::Size32 SizeOfImage;
-    ULONG32 CheckSum;
-    type::time32_t TimeDateStamp;
-    RVA ModuleNameRva;
-    VS_FIXEDFILEINFO VersionInfo;
-    MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
-    MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
-    ULONG64 Reserved0;
-    ULONG64 Reserved1;
-
-    char16 ModuleName[] @ ModuleNameRva + 4 [[hidden]];
-} [[format("format_module")]];
-
-fn format_module(ref MINIDUMP_MODULE module) {
-    return module.ModuleName;
-};
-
-struct MINIDUMP_MODULE_LIST {
-    ULONG32 NumberOfModules;
-    MINIDUMP_MODULE Modules[NumberOfModules];
-};
-
-struct MINIDUMP_MEMORY_LIST {
-    ULONG32 NumberOfMemoryRanges;
-    MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[NumberOfMemoryRanges];
-};
-
-struct MINIDUMP_EXCEPTION  {
-    ULONG32 ExceptionCode;
-    ULONG32 ExceptionFlags;
-    ULONG64 ExceptionRecord;
-    ULONG64 ExceptionAddress;
-    ULONG32 NumberParameters;
-    padding[4];
-    ULONG64 ExceptionInformation[15];
-};
-
-struct MINIDUMP_EXCEPTION_STREAM {
-    ULONG32 ThreadId;
-    padding[4];
-    MINIDUMP_EXCEPTION ExceptionRecord;
-    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
-};
-
-struct CPU_INFORMATION {
-    ULONG32 VendorId[3];
-    ULONG32 VersionInformation;
-    ULONG32 FeatureInformation;
-    ULONG32 AMDExtendedCpuFeatures;
-};
-
-struct MINIDUMP_SYSTEM_INFO {
-    USHORT ProcessorArchitecture;
-    USHORT ProcessorLevel;
-    USHORT ProcessorRevision;
-    UCHAR NumberOfProcessors;
-    UCHAR ProductType;
-    ULONG32 MajorVersion;
-    ULONG32 MinorVersion;
-    ULONG32 BuildNumber;
-    ULONG32 PlatformId;
-    RVA CSDVersionRva;
-    USHORT SuiteMask;
-    USHORT Reserved;
-    CPU_INFORMATION Cpu;
-};
-
-struct MINIDUMP_THREAD_EX {
-    ULONG32 ThreadId;
-    ULONG32 SuspendCount;
-    ULONG32 PriorityClass;
-    ULONG32 Priority;
-    ULONG64 Teb;
-    MINIDUMP_MEMORY_DESCRIPTOR Stack;
-    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
-    MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
-};
-
-struct MINIDUMP_THREAD_EX_LIST {
-    ULONG32 NumberOfThreads;
-    MINIDUMP_THREAD_EX Threads[NumberOfThreads];
-};
-
-struct MINIDUMP_MEMORY_DESCRIPTOR64 {
-    ULONG64 StartOfMemoryRange;
-    type::Size64 DataSize;
-};
-
-struct MINIDUMP_MEMORY64_LIST {
-    ULONG64 NumberOfMemoryRanges;
-    RVA64 BaseRva;
-    MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[NumberOfMemoryRanges];
-};
-
-struct MINIDUMP_HANDLE_DESCRIPTOR {
-    ULONG64 Handle;
-    RVA TypeNameRva;
-    RVA ObjectNameRva;
-    ULONG32 Attributes;
-    ULONG32 GrantedAccess;
-    ULONG32 HandleCount;
-    ULONG32 PointerCount;
-};
-
-struct MINIDUMP_HANDLE_DESCRIPTOR_2 {
-    ULONG64 Handle;
-    RVA TypeNameRva;
-    RVA ObjectNameRva;
-    ULONG32 Attributes;
-    ULONG32 GrantedAccess;
-    ULONG32 HandleCount;
-    ULONG32 PointerCount;
-    RVA ObjectInfoRva;
-    ULONG32 Reserved0;
-};
-
-struct MINIDUMP_HANDLE_DATA_STREAM {
-    ULONG32 SizeOfHeader;
-    ULONG32 SizeOfDescriptor;
-    ULONG32 NumberOfDescriptors;
-    ULONG32 Reserved;
-
-    if (SizeOfDescriptor == 32)
-        MINIDUMP_HANDLE_DESCRIPTOR HandleDescriptors[NumberOfDescriptors];
-    else if (SizeOfDescriptor == 40)
-        MINIDUMP_HANDLE_DESCRIPTOR_2 HandleDescriptors[NumberOfDescriptors];
-};
-
-struct MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
-    ULONG64 MinimumAddress;
-    ULONG64 MaximumAddress;
-    ULONG64 BaseAddress;
-    ULONG32 EntryCount;
-    type::Size32 SizeOfAlignPad;
-};
-
-struct MINIDUMP_FUNCTION_TABLE_STREAM {
-    type::Size32 SizeOfHeader;
-    type::Size32 SizeOfDescriptor;
-    type::Size32 SizeOfNativeDescriptor;
-    type::Size32 SizeOfFunctionEntry;
-    ULONG32 NumberOfDescriptors;
-    ULONG32 SizeOfAlignPad;
-
-    MINIDUMP_FUNCTION_TABLE_DESCRIPTOR FunctionDescriptors[NumberOfDescriptors];
-};
-
-struct MINIDUMP_UNLOADED_MODULE {
-    ULONG64 BaseOfImage;
-    type::Size32 SizeOfImage;
-    ULONG32 CheckSum;
-    ULONG32 TimeDateStamp;
-    RVA ModuleNameRva;
-
-    char16 ModuleName[] @ ModuleNameRva + 4 [[hidden]];
-} [[format("format_unloaded_module")]];
-
-fn format_unloaded_module(ref MINIDUMP_UNLOADED_MODULE module) {
-    return module.ModuleName;
-};
-
-struct MINIDUMP_UNLOADED_MODULE_LIST {
-    ULONG32 SizeOfHeader;
-    ULONG32 SizeOfEntry;
-    ULONG32 NumberOfEntries;
-
-    if (SizeOfHeader > 12)
-        padding[header.SizeOfHeader - 12];
-        
-    MINIDUMP_UNLOADED_MODULE Modules[NumberOfEntries];
-};
-
-struct MINIDUMP_MISC_INFO {
-    ULONG32 SizeOfInfo;
-    ULONG32 Flags1;
-    ULONG32 ProcessId;
-    ULONG32 ProcessCreateTime;
-    ULONG32 ProcessUserTime;
-    ULONG32 ProcessKernelTime;
-
-    if (SizeOfInfo > 24) {
-        ULONG32 ProcessorMaxMhz;
-        ULONG32 ProcessorCurrentMhz;
-        ULONG32 ProcessorMhzLimit;
-        ULONG32 ProcessorMaxIdleState;
-        ULONG32 ProcessorCurrentIdleState;
-    }
-};
-
-struct MINIDUMP_MEMORY_INFO {
-    ULONG64 BaseAddress;
-    ULONG64 AllocationBase;
-    ULONG32 AllocationProtect;
-    padding[4];
-    type::Size64 RegionSize;
-    ULONG32 State;
-    ULONG32 Protect;
-    ULONG32 Type;
-    padding[4];
-};
-
-struct MINIDUMP_MEMORY_INFO_LIST {
-    ULONG SizeOfHeader;
-    ULONG SizeOfEntry;
-    ULONG64 NumberOfEntries;
-
-    if (SizeOfHeader > 16)
-        padding[SizeOfHeader - 16];
-        
-    MINIDUMP_MEMORY_INFO Info[NumberOfEntries];
-};
-
-struct MINIDUMP_THREAD_INFO {
-    ULONG32 ThreadId;
-    ULONG32 DumpFlags;
-    ULONG32 DumpError;
-    ULONG32 ExitStatus;
-    ULONG64 CreateTime;
-    ULONG64 ExitTime;
-    ULONG64 KernelTime;
-    ULONG64 UserTime;
-    ULONG64 StartAddress;
-    ULONG64 Affinity;
-};
-
-struct MINIDUMP_THREAD_INFO_LIST {
-    ULONG SizeOfHeader;
-    ULONG SizeOfEntry;
-    ULONG NumberOfEntries;
-
-    if (SizeOfHeader > 12)
-        padding[SizeOfHeader - 12];
-        
-    MINIDUMP_THREAD_INFO Info[NumberOfEntries];
-};
-
-struct MINIDUMP_HANDLE_OPERATION_LIST {
-    ULONG32 SizeOfHeader;
-    ULONG32 SizeOfEntry;
-    ULONG32 NumberOfEntries;
-    ULONG32 Reserved;
-};
-
-struct MINIDUMP_DIRECTORY {
-    MINIDUMP_STREAM_TYPE StreamType;
-    MINIDUMP_LOCATION_DESCRIPTOR Location;
-
-    if (StreamType == MINIDUMP_STREAM_TYPE::ThreadListStream)
-        MINIDUMP_THREAD_LIST ThreadList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::ModuleListStream)
-        MINIDUMP_MODULE_LIST ModuleList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::MemoryListStream)
-        MINIDUMP_MEMORY_LIST MemoryList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::ExceptionStream)
-        MINIDUMP_EXCEPTION_STREAM  ExceptionInfo @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::SystemInfoStream)
-        MINIDUMP_SYSTEM_INFO SystemInfo @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::ThreadExListStream)
-        MINIDUMP_THREAD_EX_LIST ThreadExList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::Memory64ListStream)
-        MINIDUMP_MEMORY64_LIST Mem64List @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::CommentStreamA)
-        char Comment[] @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::CommentStreamW)
-        char16 Comment[] @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::HandleDataStream)
-        MINIDUMP_HANDLE_DATA_STREAM HandleData @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::FunctionTableStream)
-        MINIDUMP_FUNCTION_TABLE_STREAM FunctionTable @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::UnloadedModuleListStream)
-        MINIDUMP_UNLOADED_MODULE_LIST UnloadModuleList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::MiscInfoStream)
-            MINIDUMP_MISC_INFO MiscInfo @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::MemoryInfoListStream)
-            MINIDUMP_MEMORY_INFO_LIST MemInfoList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::ThreadInfoListStream)
-            MINIDUMP_THREAD_INFO_LIST ThreadInfoList @ Location.Rva;
-    else if (StreamType == MINIDUMP_STREAM_TYPE::HandleOperationListStream)
-            MINIDUMP_HANDLE_OPERATION_LIST HandleOperList @ Location.Rva;
-};
-
-bitfield MINIDUMP_TYPE {
-    MiniDumpWithDataSegs                    : 1;
-    MiniDumpWithFullMemory                  : 1;
-    MiniDumpWithHandleData                  : 1;
-    MiniDumpFilterMemory                    : 1;
-    MiniDumpScanMemory                      : 1;
-    MiniDumpWithUnloadedModules             : 1;
-    MiniDumpWithIndirectlyReferencedMemory  : 1;
-    MiniDumpFilterModulePaths               : 1;
-    MiniDumpWithProcessThreadData           : 1;
-    MiniDumpWithPrivateReadWriteMemory      : 1;
-    MiniDumpWithoutOptionalData             : 1;
-    MiniDumpWithFullMemoryInfo              : 1;
-    MiniDumpWithThreadInfo                  : 1;
-    MiniDumpWithCodeSegs                    : 1;
-    MiniDumpWithoutAuxiliaryState           : 1;
-    MiniDumpWithFullAuxiliaryState          : 1;
-    MiniDumpWithPrivateWriteCopyMemory      : 1;
-    MiniDumpIgnoreInaccessibleMemory        : 1;
-    MiniDumpWithTokenInformation            : 1;
-    MiniDumpWithModuleHeaders               : 1;
-    MiniDumpFilterTriage                    : 1;
-    MiniDumpWithAvxXStateContext            : 1;
-    MiniDumpWithIptTrace                    : 1;
-    MiniDumpScanInaccessiblePartialPages    : 1;
-    padding                                 : 40;
-} [[right_to_left]];
-
-struct MINIDUMP_HEADER {
-    char Signature[4];
-    ULONG32 Version;
-    ULONG32 NumberOfStreams;
-    RVA StreamDirectoryRva;
-    ULONG32 Checksum;
-    type::time32_t TimeDateStamp;
-    MINIDUMP_TYPE Flags;
-};
-
-struct MINIDUMP {
-    MINIDUMP_HEADER Header;
-    MINIDUMP_DIRECTORY Streams[Header.NumberOfStreams] [[format_entries("format_stream")]];
-};
-
-fn format_stream(ref MINIDUMP_DIRECTORY stream) {
-    return stream.StreamType;
-};
-
-MINIDUMP MiniDump @ 0x00;
+#pragma MIME application/x-dmp
+
+#include <type/time.pat>
+#include <type/types/win32.pat>
+#include <type/size.pat>
+
+using RVA = ULONG32;
+using RVA64 = ULONG64;
+
+enum MINIDUMP_STREAM_TYPE : ULONG32 {
+    UnusedStream                = 0,
+    ReservedStream0             = 1,
+    ReservedStream1             = 2,
+    ThreadListStream            = 3,
+    ModuleListStream            = 4,
+    MemoryListStream            = 5,
+    ExceptionStream             = 6,
+    SystemInfoStream            = 7,
+    ThreadExListStream          = 8,
+    Memory64ListStream          = 9,
+    CommentStreamA              = 10,
+    CommentStreamW              = 11,
+    HandleDataStream            = 12,
+    FunctionTableStream         = 13,
+    UnloadedModuleListStream    = 14,
+    MiscInfoStream              = 15,
+    MemoryInfoListStream        = 16,
+    ThreadInfoListStream        = 17,
+    HandleOperationListStream   = 18,
+    TokenStream                 = 19,
+    JavaScriptDataStream        = 20,
+    SystemMemoryInfoStream      = 21,
+    ProcessVmCountersStream     = 22,
+    IptTraceStream              = 23,
+    ThreadNamesStream           = 24,
+    ceStreamNull                = 0x8000,
+    ceStreamSystemInfo          = 0x8001,
+    ceStreamException           = 0x8002,
+    ceStreamModuleList          = 0x8003,
+    ceStreamProcessList         = 0x8004,
+    ceStreamThreadList          = 0x8005,
+    ceStreamThreadContextList   = 0x8006,
+    ceStreamThreadCallStackList = 0x8007,
+    ceStreamMemoryVirtualList   = 0x8008,
+    ceStreamMemoryPhysicalList  = 0x8009,
+    ceStreamBucketParameters    = 0x800A,
+    ceStreamProcessModuleMap    = 0x800B,
+    ceStreamDiagnosisList       = 0x800C,
+    LastReservedStream          = 0xFFFF
+};
+
+struct MINIDUMP_LOCATION_DESCRIPTOR {
+    type::Size32 DataSize;
+    RVA Rva;
+};
+
+struct MINIDUMP_MEMORY_DESCRIPTOR {
+    ULONG64 StartOfMemoryRange;
+    MINIDUMP_LOCATION_DESCRIPTOR Memory;
+};
+
+struct MINIDUMP_THREAD {
+    ULONG32 ThreadId;
+    ULONG32 SuspendCount;
+    ULONG32 PriorityClass;
+    ULONG32 Priority;
+    ULONG64 Teb;
+    MINIDUMP_MEMORY_DESCRIPTOR Stack;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+};
+
+struct MINIDUMP_THREAD_LIST {
+    ULONG32 NumberOfThreads;
+    MINIDUMP_THREAD Threads[NumberOfThreads];
+};
+
+struct VS_FIXEDFILEINFO {
+    DWORD dwSignature;
+    DWORD dwStrucVersion;
+    DWORD dwFileVersionMS;
+    DWORD dwFileVersionLS;
+    DWORD dwProductVersionMS;
+    DWORD dwProductVersionLS;
+    DWORD dwFileFlagsMask;
+    DWORD dwFileFlags;
+    DWORD dwFileOS;
+    DWORD dwFileType;
+    DWORD dwFileSubtype;
+    DWORD dwFileDateMS;
+    DWORD dwFileDateLS;
+};
+
+struct MINIDUMP_MODULE {
+    ULONG64 BaseOfImage;
+    type::Size32 SizeOfImage;
+    ULONG32 CheckSum;
+    type::time32_t TimeDateStamp;
+    RVA ModuleNameRva;
+    VS_FIXEDFILEINFO VersionInfo;
+    MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
+    MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
+    ULONG64 Reserved0;
+    ULONG64 Reserved1;
+
+    char16 ModuleName[] @ ModuleNameRva + 4 [[hidden]];
+} [[format("format_module")]];
+
+fn format_module(ref MINIDUMP_MODULE module) {
+    return module.ModuleName;
+};
+
+struct MINIDUMP_MODULE_LIST {
+    ULONG32 NumberOfModules;
+    MINIDUMP_MODULE Modules[NumberOfModules];
+};
+
+struct MINIDUMP_MEMORY_LIST {
+    ULONG32 NumberOfMemoryRanges;
+    MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[NumberOfMemoryRanges];
+};
+
+struct MINIDUMP_EXCEPTION  {
+    ULONG32 ExceptionCode;
+    ULONG32 ExceptionFlags;
+    ULONG64 ExceptionRecord;
+    ULONG64 ExceptionAddress;
+    ULONG32 NumberParameters;
+    padding[4];
+    ULONG64 ExceptionInformation[15];
+};
+
+struct MINIDUMP_EXCEPTION_STREAM {
+    ULONG32 ThreadId;
+    padding[4];
+    MINIDUMP_EXCEPTION ExceptionRecord;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+};
+
+struct CPU_INFORMATION {
+    ULONG32 VendorId[3];
+    ULONG32 VersionInformation;
+    ULONG32 FeatureInformation;
+    ULONG32 AMDExtendedCpuFeatures;
+};
+
+struct MINIDUMP_SYSTEM_INFO {
+    USHORT ProcessorArchitecture;
+    USHORT ProcessorLevel;
+    USHORT ProcessorRevision;
+    UCHAR NumberOfProcessors;
+    UCHAR ProductType;
+    ULONG32 MajorVersion;
+    ULONG32 MinorVersion;
+    ULONG32 BuildNumber;
+    ULONG32 PlatformId;
+    RVA CSDVersionRva;
+    USHORT SuiteMask;
+    USHORT Reserved;
+    CPU_INFORMATION Cpu;
+};
+
+struct MINIDUMP_THREAD_EX {
+    ULONG32 ThreadId;
+    ULONG32 SuspendCount;
+    ULONG32 PriorityClass;
+    ULONG32 Priority;
+    ULONG64 Teb;
+    MINIDUMP_MEMORY_DESCRIPTOR Stack;
+    MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
+    MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
+};
+
+struct MINIDUMP_THREAD_EX_LIST {
+    ULONG32 NumberOfThreads;
+    MINIDUMP_THREAD_EX Threads[NumberOfThreads];
+};
+
+struct MINIDUMP_MEMORY_DESCRIPTOR64 {
+    ULONG64 StartOfMemoryRange;
+    type::Size64 DataSize;
+};
+
+struct MINIDUMP_MEMORY64_LIST {
+    ULONG64 NumberOfMemoryRanges;
+    RVA64 BaseRva;
+    MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[NumberOfMemoryRanges];
+};
+
+struct MINIDUMP_HANDLE_DESCRIPTOR {
+    ULONG64 Handle;
+    RVA TypeNameRva;
+    RVA ObjectNameRva;
+    ULONG32 Attributes;
+    ULONG32 GrantedAccess;
+    ULONG32 HandleCount;
+    ULONG32 PointerCount;
+};
+
+struct MINIDUMP_HANDLE_DESCRIPTOR_2 {
+    ULONG64 Handle;
+    RVA TypeNameRva;
+    RVA ObjectNameRva;
+    ULONG32 Attributes;
+    ULONG32 GrantedAccess;
+    ULONG32 HandleCount;
+    ULONG32 PointerCount;
+    RVA ObjectInfoRva;
+    ULONG32 Reserved0;
+};
+
+struct MINIDUMP_HANDLE_DATA_STREAM {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfDescriptor;
+    ULONG32 NumberOfDescriptors;
+    ULONG32 Reserved;
+
+    if (SizeOfDescriptor == 32)
+        MINIDUMP_HANDLE_DESCRIPTOR HandleDescriptors[NumberOfDescriptors];
+    else if (SizeOfDescriptor == 40)
+        MINIDUMP_HANDLE_DESCRIPTOR_2 HandleDescriptors[NumberOfDescriptors];
+};
+
+struct MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
+    ULONG64 MinimumAddress;
+    ULONG64 MaximumAddress;
+    ULONG64 BaseAddress;
+    ULONG32 EntryCount;
+    type::Size32 SizeOfAlignPad;
+};
+
+struct MINIDUMP_FUNCTION_TABLE_STREAM {
+    type::Size32 SizeOfHeader;
+    type::Size32 SizeOfDescriptor;
+    type::Size32 SizeOfNativeDescriptor;
+    type::Size32 SizeOfFunctionEntry;
+    ULONG32 NumberOfDescriptors;
+    ULONG32 SizeOfAlignPad;
+
+    MINIDUMP_FUNCTION_TABLE_DESCRIPTOR FunctionDescriptors[NumberOfDescriptors];
+};
+
+struct MINIDUMP_UNLOADED_MODULE {
+    ULONG64 BaseOfImage;
+    type::Size32 SizeOfImage;
+    ULONG32 CheckSum;
+    ULONG32 TimeDateStamp;
+    RVA ModuleNameRva;
+
+    char16 ModuleName[] @ ModuleNameRva + 4 [[hidden]];
+} [[format("format_unloaded_module")]];
+
+fn format_unloaded_module(ref MINIDUMP_UNLOADED_MODULE module) {
+    return module.ModuleName;
+};
+
+struct MINIDUMP_UNLOADED_MODULE_LIST {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfEntry;
+    ULONG32 NumberOfEntries;
+
+    if (SizeOfHeader > 12)
+        padding[header.SizeOfHeader - 12];
+        
+    MINIDUMP_UNLOADED_MODULE Modules[NumberOfEntries];
+};
+
+struct MINIDUMP_MISC_INFO {
+    ULONG32 SizeOfInfo;
+    ULONG32 Flags1;
+    ULONG32 ProcessId;
+    ULONG32 ProcessCreateTime;
+    ULONG32 ProcessUserTime;
+    ULONG32 ProcessKernelTime;
+
+    if (SizeOfInfo > 24) {
+        ULONG32 ProcessorMaxMhz;
+        ULONG32 ProcessorCurrentMhz;
+        ULONG32 ProcessorMhzLimit;
+        ULONG32 ProcessorMaxIdleState;
+        ULONG32 ProcessorCurrentIdleState;
+    }
+};
+
+struct MINIDUMP_MEMORY_INFO {
+    ULONG64 BaseAddress;
+    ULONG64 AllocationBase;
+    ULONG32 AllocationProtect;
+    padding[4];
+    type::Size64 RegionSize;
+    ULONG32 State;
+    ULONG32 Protect;
+    ULONG32 Type;
+    padding[4];
+};
+
+struct MINIDUMP_MEMORY_INFO_LIST {
+    ULONG SizeOfHeader;
+    ULONG SizeOfEntry;
+    ULONG64 NumberOfEntries;
+
+    if (SizeOfHeader > 16)
+        padding[SizeOfHeader - 16];
+        
+    MINIDUMP_MEMORY_INFO Info[NumberOfEntries];
+};
+
+struct MINIDUMP_THREAD_INFO {
+    ULONG32 ThreadId;
+    ULONG32 DumpFlags;
+    ULONG32 DumpError;
+    ULONG32 ExitStatus;
+    ULONG64 CreateTime;
+    ULONG64 ExitTime;
+    ULONG64 KernelTime;
+    ULONG64 UserTime;
+    ULONG64 StartAddress;
+    ULONG64 Affinity;
+};
+
+struct MINIDUMP_THREAD_INFO_LIST {
+    ULONG SizeOfHeader;
+    ULONG SizeOfEntry;
+    ULONG NumberOfEntries;
+
+    if (SizeOfHeader > 12)
+        padding[SizeOfHeader - 12];
+        
+    MINIDUMP_THREAD_INFO Info[NumberOfEntries];
+};
+
+struct MINIDUMP_HANDLE_OPERATION_LIST {
+    ULONG32 SizeOfHeader;
+    ULONG32 SizeOfEntry;
+    ULONG32 NumberOfEntries;
+    ULONG32 Reserved;
+};
+
+struct MINIDUMP_DIRECTORY {
+    MINIDUMP_STREAM_TYPE StreamType;
+    MINIDUMP_LOCATION_DESCRIPTOR Location;
+
+    if (StreamType == MINIDUMP_STREAM_TYPE::ThreadListStream)
+        MINIDUMP_THREAD_LIST ThreadList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::ModuleListStream)
+        MINIDUMP_MODULE_LIST ModuleList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::MemoryListStream)
+        MINIDUMP_MEMORY_LIST MemoryList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::ExceptionStream)
+        MINIDUMP_EXCEPTION_STREAM  ExceptionInfo @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::SystemInfoStream)
+        MINIDUMP_SYSTEM_INFO SystemInfo @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::ThreadExListStream)
+        MINIDUMP_THREAD_EX_LIST ThreadExList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::Memory64ListStream)
+        MINIDUMP_MEMORY64_LIST Mem64List @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::CommentStreamA)
+        char Comment[] @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::CommentStreamW)
+        char16 Comment[] @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::HandleDataStream)
+        MINIDUMP_HANDLE_DATA_STREAM HandleData @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::FunctionTableStream)
+        MINIDUMP_FUNCTION_TABLE_STREAM FunctionTable @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::UnloadedModuleListStream)
+        MINIDUMP_UNLOADED_MODULE_LIST UnloadModuleList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::MiscInfoStream)
+            MINIDUMP_MISC_INFO MiscInfo @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::MemoryInfoListStream)
+            MINIDUMP_MEMORY_INFO_LIST MemInfoList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::ThreadInfoListStream)
+            MINIDUMP_THREAD_INFO_LIST ThreadInfoList @ Location.Rva;
+    else if (StreamType == MINIDUMP_STREAM_TYPE::HandleOperationListStream)
+            MINIDUMP_HANDLE_OPERATION_LIST HandleOperList @ Location.Rva;
+};
+
+bitfield MINIDUMP_TYPE {
+    MiniDumpWithDataSegs                    : 1;
+    MiniDumpWithFullMemory                  : 1;
+    MiniDumpWithHandleData                  : 1;
+    MiniDumpFilterMemory                    : 1;
+    MiniDumpScanMemory                      : 1;
+    MiniDumpWithUnloadedModules             : 1;
+    MiniDumpWithIndirectlyReferencedMemory  : 1;
+    MiniDumpFilterModulePaths               : 1;
+    MiniDumpWithProcessThreadData           : 1;
+    MiniDumpWithPrivateReadWriteMemory      : 1;
+    MiniDumpWithoutOptionalData             : 1;
+    MiniDumpWithFullMemoryInfo              : 1;
+    MiniDumpWithThreadInfo                  : 1;
+    MiniDumpWithCodeSegs                    : 1;
+    MiniDumpWithoutAuxiliaryState           : 1;
+    MiniDumpWithFullAuxiliaryState          : 1;
+    MiniDumpWithPrivateWriteCopyMemory      : 1;
+    MiniDumpIgnoreInaccessibleMemory        : 1;
+    MiniDumpWithTokenInformation            : 1;
+    MiniDumpWithModuleHeaders               : 1;
+    MiniDumpFilterTriage                    : 1;
+    MiniDumpWithAvxXStateContext            : 1;
+    MiniDumpWithIptTrace                    : 1;
+    MiniDumpScanInaccessiblePartialPages    : 1;
+    padding                                 : 40;
+};
+
+struct MINIDUMP_HEADER {
+    char Signature[4];
+    ULONG32 Version;
+    ULONG32 NumberOfStreams;
+    RVA StreamDirectoryRva;
+    ULONG32 Checksum;
+    type::time32_t TimeDateStamp;
+    MINIDUMP_TYPE Flags;
+};
+
+struct MINIDUMP {
+    MINIDUMP_HEADER Header;
+    MINIDUMP_DIRECTORY Streams[Header.NumberOfStreams] [[format_entries("format_stream")]];
+};
+
+fn format_stream(ref MINIDUMP_DIRECTORY stream) {
+    return stream.StreamType;
+};
+
+MINIDUMP MiniDump @ 0x00;
--- a/patterns/mp4.hexpat
+++ b/patterns/mp4.hexpat
@@ -0,0 +1,286 @@
+#pragma endian big
+
+#pragma MIME audio/mp4
+#pragma MIME video/mp4
+#pragma MIME application/mp4
+
+#include <std/io.pat>
+#include <std/mem.pat>
+#include <std/string.pat>
+
+fn to_string(auto var) {
+    return str(var);
+};
+
+fn format_string(auto string) {
+    return string.value;
+}; 
+
+struct string {
+    char value[std::mem::find_sequence_in_range(0, $, std::mem::size(), 0x00) - $];
+} [[sealed, format("format_string")]];
+
+struct BaseBox {
+    u64 boxSize = 0;
+    u64 startOffset = $;
+    u64 endOffset = 0;
+
+    u32 size;
+    char type[4];
+
+    // Calculate the size of the current box
+    // 1. If the size is equal to 1 -> the box size is equal to 'largeSize' attribute.
+    // 2. If the size is equal to 0 -> The box extends to the end of the file.
+    // 3. Otherwise, size is equaly to the 'size' attribute.
+    if (this.size == 1) {
+        u64 largeSize;
+        boxSize = largeSize;
+        endOffset = startOffset + boxSize;
+    } else if (this.size == 0) { 
+        boxSize = std::mem::size() - startOffset;
+        endOffset = std::mem::size();
+    } else {
+        boxSize = size;
+        endOffset = startOffset + boxSize;
+    }
+
+    if (this.type == "uuid") {
+        char usertype[16];
+    }
+};
+
+struct FullBox : BaseBox {
+    u8 version;
+    u24 flags;
+};
+
+struct UnknownBox : BaseBox {
+    u8 unk[while($ != endOffset)];
+};
+
+using brand = u32 [[format("to_string")]];
+struct FileTypeBox : BaseBox {
+    brand major_brand;
+    u32 minor_version;
+    brand compatible_brands[(endOffset - $) / sizeof(brand)];
+};
+
+struct MovieHeaderBox : FullBox {
+    if (this.version == 1) {
+        u64 creation_time;
+        u64 modification_time;
+        u32 timescale;
+        u64 duration;
+    } else {  // version == 0
+        u32 creation_time;
+        u32 modification_time;
+        u32 timescale;
+        u32 duration;
+    }
+    u32 rate [[comment("Fixed point number 16.16")]];
+    u16 volume [[comment("Fixed point number 8.8")]];
+    u8 reserved[10] [[sealed]];
+    u32 matrix[9];
+    u32 preview_time;
+    u32 preview_duration;
+    u32 poster_time;
+    u32 selection_time;
+    u32 selection_duration;
+    u32 current_time;
+    u32 next_track_id;
+};
+
+struct TrackHeaderBox : FullBox {
+    if (this.version == 1) {
+        u64 creation_time;
+        u64 modification_time;
+        u32 track_id;
+        u32 reserved;
+        u64 duration;
+    } else {  // version == 0
+        u32 creation_time;
+        u32 modification_time;
+        u32 track_id;
+        u32 reserved;
+        u32 duration;
+    }
+    u32 reserved_2[2] [[sealed]];
+    s16 layer;
+    s16 alternate_group;
+    s16 volume;
+    u16 reserved_3;
+    s32 matrix[9];
+    u32 width;
+    u32 height;
+};
+
+struct DataEntryBox : FullBox {
+    if (std::string::contains(this.type, "url")) {
+        string location;
+    } else if (std::string::contains(this.type, "urn")) {
+        string name;
+        string location;
+    } else {
+        std::error("Invalid DataEntryBox");
+    }
+};
+
+struct DataReferenceBox : FullBox {
+    u32 entry_count;
+    DataEntryBox data_entries[this.entry_count];
+};
+
+struct SubDataInformationBox {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("dref"): DataReferenceBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+    }
+} [[name(std::format("DataInformationBox({})", box.type))]];
+
+struct DataInformationBox : BaseBox {
+    SubDataInformationBox box[while($ < endOffset)] [[inline]];
+};
+
+struct HandlerBox : FullBox {
+    u32 component_type;
+    u32 handler_type;
+    u32 reserved[3];
+    char name[endOffset - $];
+};
+
+struct VideoMediaHeaderBox : FullBox {
+    u16 graphicsmode;
+    u16 opcolor[3];
+};
+
+struct SubMediaInformationBox {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("vmhd"): VideoMediaHeaderBox box [[inline]];
+        ("hdlr"): HandlerBox box [[inline]];
+        ("dinf"): DataInformationBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+        // TODO: Add stbl
+    }
+} [[name(std::format("MediaInformationBox({})", box.type))]];
+
+struct MediaInformationBox : BaseBox {
+    SubMediaInformationBox box[while($ < endOffset)] [[inline]];
+};
+
+struct MediaHeaderBox : FullBox {
+    if (this.version == 1) {
+        u64 creation_time;
+        u64 modification_time;
+        u32 timescale;
+        u64 duration;
+    } else { // version==0
+        u32 creation_time;
+        u32 modification_time;
+        u32 timescale;
+        u32 duration;
+    }
+    u16 language [[comment("ISO-639-2/T language code")]];
+    u16 quality;
+};
+
+struct SubMediaBox {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("mdhd"): MediaHeaderBox box [[inline]];
+        ("hdlr"): HandlerBox box [[inline]];
+        ("minf"): MediaInformationBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+    }
+} [[name(std::format("MediaBox({})", box.type))]];
+
+struct MediaBox : BaseBox {
+    SubMediaBox box[while($ < endOffset)] [[inline]];
+};
+
+struct EditListEntry64 {
+    u64 segment_duration;
+    s64 media_time;
+    s16 media_rate_integer;
+    s16 media_rate_fraction;
+};
+
+struct EditListEntry32 {
+    u32 segment_duration;
+    s32 media_time;
+    s16 media_rate_integer;
+    s16 media_rate_fraction;
+};
+
+struct EditListBox : FullBox {
+    u32 entry_count;
+    if (this.version == 1) {
+        EditListEntry64 entry_list[this.entry_count];
+    } else {  // version 0
+        EditListEntry32 entry_list[this.entry_count];
+    }
+};
+
+struct SubEditBox {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("elst"): EditListBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+    }
+} [[name(std::format("EditBox({})", box.type))]];
+
+struct EditBox : BaseBox {
+    SubEditBox box[while($ < endOffset)] [[inline]];
+};
+
+struct SubTrackBox {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("mdia"): MediaBox box [[inline]];
+        ("edts"): EditBox box [[inline]];
+        ("tkhd"): TrackHeaderBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+    }
+} [[name(std::format("TrackBox({})", box.type))]];
+
+struct TrackBox : BaseBox {
+    SubTrackBox box[while($ < endOffset)] [[inline]];
+};
+
+struct SubMovieBox {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("mvhd"): MovieHeaderBox box [[inline]];
+        ("trak"): TrackBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+        // TODO: Add "iods" box
+    }
+} [[name(std::format("MovieBox({})", box.type))]];
+
+struct MovieBox : BaseBox {
+    SubMovieBox box[while($ < endOffset)] [[inline]];
+};
+
+struct MediaDataBox : BaseBox {
+    u8 data[while($ < endOffset)] [[sealed]];
+};
+
+struct Box {
+    u32 type = std::mem::read_unsigned($ + 4, 4, std::mem::Endian::Big);
+
+    match (str(type)) {
+        ("ftyp"): FileTypeBox box [[inline]];
+        ("moov"): MovieBox box [[inline]];
+        ("mdat"): MediaDataBox box [[inline]];
+        (_): UnknownBox box [[inline]];
+    }
+} [[name(std::format("Box({})", box.type))]];
+
+Box mp4[while(!std::mem::eof())] @ 0x0;
--- a/patterns/nbt.hexpat
+++ b/patterns/nbt.hexpat
@@ -45,6 +45,12 @@ struct Value {
        Value values[listLength] [[static]];
    } else if (parent.tag == Tag::Compound) {       
        Element values[while(true)];
+    } else if (parent.tag == Tag::IntArray){
+        s32 arrayLength;
+        s32 value[arrayLength] [[sealed]];
+    } else if (parent.tag == Tag::LongArray) {
+        s32 arrayLength;
+        s64 value[arrayLength] [[sealed]];
    } else {
        std::error(std::format("Invalid tag {:02X}", TypeTag));
    }
@@ -67,4 +73,4 @@ struct NBT {
    Element element[while(true)] [[inline]];
 };

-NBT nbt @ 0x00;
+NBT nbt @ 0x00;
--- a/patterns/ne.hexpat
+++ b/patterns/ne.hexpat
@@ -1,7 +1,5 @@
 #include <std/mem.pat>

-#pragma bitfield_order right_to_left
-
 struct DOSHeader {
    char signature[2];
    u16 lastPageSize;
@@ -186,7 +184,7 @@ bitfield SegmentTableFlags {
 	containsRelocationInfo : 1;
 	padding : 1;
 	discardPriority : 4;
-} [[right_to_left]];
+};

 struct SegmentTable {
 	u16 segmentDataPointer;
--- a/patterns/ntag.hexpat
+++ b/patterns/ntag.hexpat
@@ -1,161 +1,165 @@
-bitfield AccessCapability {
-	Read : 4;
-	Write : 4;
-} [[left_to_right]];
-
-struct CapabilityContainer {
-	u8 magic;
-	u8 version;
-	u8 memorySize;
-	AccessCapability accessCapability;
-};
-
-bitfield NDEFFlags {
-	MB	: 1;
-	ME	: 1;
-	CF	: 1;
-	SR	: 1;
-	IL	: 1;
-	TNF	: 3;
-} [[left_to_right]];
-
-enum TNFType : u8 {
-	Empty 					= 0x00,
-	NFCForumWellKnownType 	= 0x01,
-	MediaType				= 0x02,
-	AbsoluteURI				= 0x03,
-	NFCForumExternalType 	= 0x04,
-	Unknown 				= 0x05,
-	Unchanged 				= 0x06,
-	Reserved 				= 0x07
-};
-
-struct NDEF {
-	NDEFFlags flags;
-	u8 typeLength;
-	
-	if (flags.SR)
-		u8 payloadLength;
-	else
-		u32 payloadLength;
-		
-	if (flags.IL)
-		u8 idLength;
-		
-	char type[typeLength];
-	
-	if (flags.IL)
-		u8 id[idLength];
-	
-	u8 payload[payloadLength];
-		
-	if (flags.ME)
-		break;
-};
-
-struct LockControl {
-	u8 dynamicLockByteOffset;
-	u8 numBits;
-	u8 pageControlInfo;
-};
-
-struct MemoryControl {
-	u8 reservedBytesOffset;
-	u8 numBytes;
-	u8 pageSize;
-};
-
-struct Length {
-	u8 byte [[hidden, no_unique_address]];
-	if (byte == 0xFF)
-		u24 length;
-	else
-		u8 length;
-} [[sealed, transform("transform_length"), format("transform_length")]];
-
-fn transform_length(Length length) {
-	return length.length;
-};
-
-enum Tag : u8 {
-	NULL 			= 0x00,
-	LockControl 	= 0x01,
-	MemoryControl 	= 0x02,
-	NDEFMessage 	= 0x03,
-	Proprietary 	= 0xFD,
-	TerminatorTLV 	= 0xFE
-};
-
-struct TLV {
-	Tag tag;
-	if (tag == Tag::TerminatorTLV) {
-		break;
-	} else if (tag == Tag::NULL) {
-		// Empty
-	} else {
-		Length length;
-		
-		if (length > 0) {
-			if (tag == Tag::LockControl) {
-				LockControl lockControl;
-			} else if (tag == Tag::MemoryControl) {
-				LockControl lockControl;
-			} else if (tag == Tag::NDEFMessage) {
-				NDEF ndef[while(true)];
-			} else {
-				u8 value[length];
-			}
-		}
-	}
-};
-
-struct ManufacturerData {
-	u8 serial1[3];
-	u8 checkByte0;
-	u8 serial2[4];
-	u8 checkByte1;
-	u8 internal;
-	u16 lockBytes;
-};
-
-struct DynamicLockBytes {
-	u8 bytes[3];
-	padding[1];
-};
-
-bitfield MIRROR {
-	MIRROR_CONF	: 2;
-	MIRROR_BYTE	: 2;
-	padding     : 1;
-	STRG_MOD_EN	: 1;
-	padding     : 2;
-} [[left_to_right]];
-
-bitfield ACCESS {
-	PROT				: 1;
-	CFGLCK				: 1;
-	padding             : 1;
-	NFC_CNT_EN			: 1;
-	NFC_CNT_PWD_PROT	: 1;
-	AUTHLIM				: 3;
-};
-
-struct Config {
-	MIRROR MIRROR;
-	u8 MIRROR_PAGE;
-	u8 AUTH0;
-	ACCESS ACCESS;
-	u32 PWD;
-	u16 PACK;
-};
-
-struct NTAG {
-	ManufacturerData manufacturerData;
-	CapabilityContainer cc;
-	TLV tlv[while(true)];
-	padding[addressof(tlv) + cc.memorySize * 8 - sizeof(tlv)];
-	DynamicLockBytes dynamicLockBytes;
-	Config config;
-};
-
-NTAG ntag @ 0x00;
+#include <std/core.pat>
+
+using BitfieldOrder = std::core::BitfieldOrder;
+
+bitfield AccessCapability {
+	Read : 4;
+	Write : 4;
+} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 8)]];
+
+struct CapabilityContainer {
+	u8 magic;
+	u8 version;
+	u8 memorySize;
+	be AccessCapability accessCapability;
+};
+
+bitfield NDEFFlags {
+	MB	: 1;
+	ME	: 1;
+	CF	: 1;
+	SR	: 1;
+	IL	: 1;
+	TNF	: 3;
+} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 8)]];
+
+enum TNFType : u8 {
+	Empty 					= 0x00,
+	NFCForumWellKnownType 	= 0x01,
+	MediaType				= 0x02,
+	AbsoluteURI				= 0x03,
+	NFCForumExternalType 	= 0x04,
+	Unknown 				= 0x05,
+	Unchanged 				= 0x06,
+	Reserved 				= 0x07
+};
+
+struct NDEF {
+	NDEFFlags flags;
+	u8 typeLength;
+	
+	if (flags.SR)
+		u8 payloadLength;
+	else
+		u32 payloadLength;
+		
+	if (flags.IL)
+		u8 idLength;
+		
+	char type[typeLength];
+	
+	if (flags.IL)
+		u8 id[idLength];
+	
+	u8 payload[payloadLength];
+		
+	if (flags.ME)
+		break;
+};
+
+struct LockControl {
+	u8 dynamicLockByteOffset;
+	u8 numBits;
+	u8 pageControlInfo;
+};
+
+struct MemoryControl {
+	u8 reservedBytesOffset;
+	u8 numBytes;
+	u8 pageSize;
+};
+
+struct Length {
+	u8 byte [[hidden, no_unique_address]];
+	if (byte == 0xFF)
+		u24 length;
+	else
+		u8 length;
+} [[sealed, transform("transform_length"), format("transform_length")]];
+
+fn transform_length(ref auto length) {
+	return length.length;
+};
+
+enum Tag : u8 {
+	NULL 			= 0x00,
+	LockControl 	= 0x01,
+	MemoryControl 	= 0x02,
+	NDEFMessage 	= 0x03,
+	Proprietary 	= 0xFD,
+	TerminatorTLV 	= 0xFE
+};
+
+struct TLV {
+	Tag tag;
+	if (tag == Tag::TerminatorTLV) {
+		break;
+	} else if (tag == Tag::NULL) {
+		// Empty
+	} else {
+		Length length;
+		
+		if (length > 0) {
+			if (tag == Tag::LockControl) {
+				LockControl lockControl;
+			} else if (tag == Tag::MemoryControl) {
+				LockControl lockControl;
+			} else if (tag == Tag::NDEFMessage) {
+				NDEF ndef[while(true)];
+			} else {
+				u8 value[length];
+			}
+		}
+	}
+};
+
+struct ManufacturerData {
+	u8 serial1[3];
+	u8 checkByte0;
+	u8 serial2[4];
+	u8 checkByte1;
+	u8 internal;
+	u16 lockBytes;
+};
+
+struct DynamicLockBytes {
+	u8 bytes[3];
+	padding[1];
+};
+
+bitfield MIRROR {
+	MIRROR_CONF	: 2;
+	MIRROR_BYTE	: 2;
+	padding     : 1;
+	STRG_MOD_EN	: 1;
+	padding     : 2;
+} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 8)]];
+
+bitfield ACCESS {
+	PROT				: 1;
+	CFGLCK				: 1;
+	padding             : 1;
+	NFC_CNT_EN			: 1;
+	NFC_CNT_PWD_PROT	: 1;
+	AUTHLIM				: 3;
+};
+
+struct Config {
+	MIRROR MIRROR;
+	u8 MIRROR_PAGE;
+	u8 AUTH0;
+	ACCESS ACCESS;
+	u32 PWD;
+	u16 PACK;
+};
+
+struct NTAG {
+	ManufacturerData manufacturerData;
+	CapabilityContainer cc;
+	TLV tlv[while(true)];
+	padding[addressof(tlv) + cc.memorySize * 8 - sizeof(tlv)];
+	DynamicLockBytes dynamicLockBytes;
+	Config config;
+};
+
+NTAG ntag @ 0x00;
--- a/patterns/pbz.hexpat
+++ b/patterns/pbz.hexpat
@@ -0,0 +1,40 @@
+// Apple pbz compressed file
+// Used by Apple on .xip files and OTA updates,
+// and can be created with macOS compression_tool.
+//
+// Copyright (c) 2023 Nicolás Alvarez <nicolas.alvarez@gmail.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <std/mem.pat>
+#include <type/magic.pat>
+
+#pragma endian big
+
+#define SHOW_DATA 0
+
+enum CompressionType: char {
+    ZLIB  = 'z',
+    LZMA  = 'x',
+    LZ4   = '4',
+    LZFSE = 'e'
+};
+
+struct Chunk {
+    u64 uncompressed_size;
+    u64 compressed_size;
+    if (SHOW_DATA) {
+        u8 data[compressed_size] [[sealed]];
+    } else {
+        padding[compressed_size];
+    }
+};
+
+struct PBZ {
+    type::Magic<"pbz"> magic;
+    CompressionType compression;
+    u64 chunk_size;
+    Chunk chunks[while(!std::mem::eof())];
+};
+
+PBZ pbz @ 0;
--- a/patterns/pbzx.hexpat
+++ b/patterns/pbzx.hexpat
@@ -1,30 +0,0 @@
-// pbzx compression stream
-// Used by Apple on .xip files and OTA updates.
-//
-// Copyright (c) 2022 Nicolás Alvarez <nicolas.alvarez@gmail.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <std/mem.pat>
-
-#pragma endian big
-
-#define SHOW_DATA 0
-
-struct Chunk {
-    u64 uncompressed_size;
-    u64 compressed_size;
-    if (SHOW_DATA) {
-        u8 data[compressed_size] [[sealed]];
-    } else {
-        padding[compressed_size];
-    }
-};
-
-struct PBZX {
-    char magic[4];
-    u64 chunk_size;
-    Chunk chunks[while(!std::mem::eof())];
-};
-
-PBZX pbzx @ 0;
--- a/patterns/pcap.hexpat
+++ b/patterns/pcap.hexpat
@@ -1,140 +1,155 @@
+#include <std/mem.pat>
 #pragma MIME application/vnd.tcpdump.pcap
-#pragma endian little

 enum network_type : u32 {
-	LINKTYPE_NULL = 0,
-	LINKTYPE_ETHERNET = 1,
-	LINKTYPE_AX25 = 3,
-	LINKTYPE_IEEE802_5 = 6,
-	LINKTYPE_ARCNET_BSD = 7,
-	LINKTYPE_SLIP = 8,
-	LINKTYPE_PPP = 9,
-	LINKTYPE_FDDI = 10,
-	LINKTYPE_PPP_HDLC = 50,
-	LINKTYPE_PPP_ETHER = 51,
-	LINKTYPE_ATM_RFC1483 = 100,
-	LINKTYPE_RAW = 101,
-	LINKTYPE_C_HDLC = 104,
-	LINKTYPE_IEEE802_11 = 105,
-	LINKTYPE_FRELAY = 107,
-	LINKTYPE_LOOP = 108,
-	LINKTYPE_LINUX_SLL = 113,
-	LINKTYPE_LTALK = 114,
-	LINKTYPE_PFLOG = 117,
-	LINKTYPE_IEEE802_11_PRISM = 119,
-	LINKTYPE_IP_OVER_FC = 122,
-	LINKTYPE_SUNATM = 123,
-	LINKTYPE_IEEE802_11_RADIOTAP = 127,
-	LINKTYPE_ARCNET_LINUX = 129,
-	LINKTYPE_APPLE_IP_OVER_IEEE1394 = 138,
-	LINKTYPE_MTP2_WITH_PHDR = 139,
-	LINKTYPE_MTP2 = 140,
-	LINKTYPE_MTP3 = 141,
-	LINKTYPE_SCCP = 142,
-	LINKTYPE_DOCSIS = 143,
-	LINKTYPE_LINUX_IRDA = 144,
-	LINKTYPE_IEEE802_11_AVS = 163,
-	LINKTYPE_BACNET_MS_TP = 165,
-	LINKTYPE_PPP_PPPD = 166,
-	LINKTYPE_GPRS_LLC = 169,
-	LINKTYPE_GPF_T = 170,
-	LINKTYPE_GPF_F = 171,
-	LINKTYPE_LINUX_LAPD = 177,
-	LINKTYPE_MFR = 182,
-	LINKTYPE_BLUETOOTH_HCI_H4 = 187,
-	LINKTYPE_USB_LINUX = 189,
-	LINKTYPE_PPI = 192,
-	LINKTYPE_IEEE802_15_4_WITHFCS = 195,
-	LINKTYPE_SITA = 196,
-	LINKTYPE_ERF = 197,
-	LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR = 201,
-	LINKTYPE_AX25_KISS = 202,
-	LINKTYPE_LAPD = 203,
-	LINKTYPE_PPP_WITH_DIR = 204,
-	LINKTYPE_C_HDLC_WITH_DIR = 205,
-	LINKTYPE_FRELAY_WITH_DIR = 206,
-	LINKTYPE_LAPB_WITH_DIR = 207,
-	LINKTYPE_IPMB_LINUX = 209,
-	LINKTYPE_FLEXRAY = 210,
-	LINKTYPE_IEEE802_15_4_NONASK_PHY = 215,
-	LINKTYPE_USB_LINUX_MMAPPED = 220,
-	LINKTYPE_FC_2 = 224,
-	LINKTYPE_FC_2_WITH_FRAME_DELIMS = 225,
-	LINKTYPE_IPNET = 226,
-	LINKTYPE_CAN_SOCKETCAN = 227,
-	LINKTYPE_IPV4 = 228,
-	LINKTYPE_IPV6 = 229,
-	LINKTYPE_IEEE802_15_4_NOFCS = 230,
-	LINKTYPE_DBUS = 231,
-	LINKTYPE_DVB_CI = 235,
-	LINKTYPE_MUX27010 = 236,
-	LINKTYPE_STANAG_5066_D_PDU = 237,
-	LINKTYPE_NFLOG = 239,
-	LINKTYPE_NETANALYZER = 240,
-	LINKTYPE_NETANALYZER_TRANSPARENT = 241,
-	LINKTYPE_IPOIB = 242,
-	LINKTYPE_MPEG_2_TS = 243,
-	LINKTYPE_NG40 = 244,
-	LINKTYPE_NFC_LLCP = 245,
-	LINKTYPE_INFINIBAND = 247,
-	LINKTYPE_SCTP = 248,
-	LINKTYPE_USBPCAP = 249,
-	LINKTYPE_RTAC_SERIAL = 250,
-	LINKTYPE_BLUETOOTH_LE_LL = 251,
-	LINKTYPE_NETLINK = 253,
-	LINKTYPE_BLUETOOTH_LINUX_MONITOR = 254,
-	LINKTYPE_BLUETOOTH_BREDR_BB = 255,
-	LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR = 256,
-	LINKTYPE_PROFIBUS_DL = 257,
-	LINKTYPE_PKTAP = 258,
-	LINKTYPE_EPON = 259,
-	LINKTYPE_IPMI_HPM_2 = 260,
-	LINKTYPE_ZWAVE_R1_R2 = 261,
-	LINKTYPE_ZWAVE_R3 = 262,
-	LINKTYPE_WATTSTOPPER_DLM = 263,
-	LINKTYPE_ISO_14443 = 264,
-	LINKTYPE_RDS = 265,
-	LINKTYPE_USB_DARWIN = 266,
-	LINKTYPE_SDLC = 268,
-	LINKTYPE_LORATAP = 270,
-	LINKTYPE_VSOCK = 271,
-	LINKTYPE_NORDIC_BLE = 272,
-	LINKTYPE_DOCSIS31_XRA31 = 273,
-	LINKTYPE_ETHERNET_MPACKET = 274,
-	LINKTYPE_DISPLAYPORT_AUX = 275,
-	LINKTYPE_LINUX_SLL2 = 276,
-	LINKTYPE_OPENVIZSLA = 278,
-	LINKTYPE_EBHSCR = 279,
-	LINKTYPE_VPP_DISPATCH = 280,
-	LINKTYPE_DSA_TAG_BRCM = 281,
-	LINKTYPE_DSA_TAG_BRCM_PREPEND = 282,
-	LINKTYPE_IEEE802_15_4_TAP = 283,
-	LINKTYPE_DSA_TAG_DSA = 284,
-	LINKTYPE_DSA_TAG_EDSA = 285,
-	LINKTYPE_ELEE = 286,
-	LINKTYPE_Z_WAVE_SERIAL = 287,
-	LINKTYPE_USB_2_0 = 288,
-	LINKTYPE_ATSC_ALP = 289,
-	LINKTYPE_ETW = 290	
+    LINKTYPE_NULL = 0,
+    LINKTYPE_ETHERNET = 1,
+    LINKTYPE_AX25 = 3,
+    LINKTYPE_IEEE802_5 = 6,
+    LINKTYPE_ARCNET_BSD = 7,
+    LINKTYPE_SLIP = 8,
+    LINKTYPE_PPP = 9,
+    LINKTYPE_FDDI = 10,
+    LINKTYPE_PPP_HDLC = 50,
+    LINKTYPE_PPP_ETHER = 51,
+    LINKTYPE_ATM_RFC1483 = 100,
+    LINKTYPE_RAW = 101,
+    LINKTYPE_C_HDLC = 104,
+    LINKTYPE_IEEE802_11 = 105,
+    LINKTYPE_FRELAY = 107,
+    LINKTYPE_LOOP = 108,
+    LINKTYPE_LINUX_SLL = 113,
+    LINKTYPE_LTALK = 114,
+    LINKTYPE_PFLOG = 117,
+    LINKTYPE_IEEE802_11_PRISM = 119,
+    LINKTYPE_IP_OVER_FC = 122,
+    LINKTYPE_SUNATM = 123,
+    LINKTYPE_IEEE802_11_RADIOTAP = 127,
+    LINKTYPE_ARCNET_LINUX = 129,
+    LINKTYPE_APPLE_IP_OVER_IEEE1394 = 138,
+    LINKTYPE_MTP2_WITH_PHDR = 139,
+    LINKTYPE_MTP2 = 140,
+    LINKTYPE_MTP3 = 141,
+    LINKTYPE_SCCP = 142,
+    LINKTYPE_DOCSIS = 143,
+    LINKTYPE_LINUX_IRDA = 144,
+    LINKTYPE_IEEE802_11_AVS = 163,
+    LINKTYPE_BACNET_MS_TP = 165,
+    LINKTYPE_PPP_PPPD = 166,
+    LINKTYPE_GPRS_LLC = 169,
+    LINKTYPE_GPF_T = 170,
+    LINKTYPE_GPF_F = 171,
+    LINKTYPE_LINUX_LAPD = 177,
+    LINKTYPE_MFR = 182,
+    LINKTYPE_BLUETOOTH_HCI_H4 = 187,
+    LINKTYPE_USB_LINUX = 189,
+    LINKTYPE_PPI = 192,
+    LINKTYPE_IEEE802_15_4_WITHFCS = 195,
+    LINKTYPE_SITA = 196,
+    LINKTYPE_ERF = 197,
+    LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR = 201,
+    LINKTYPE_AX25_KISS = 202,
+    LINKTYPE_LAPD = 203,
+    LINKTYPE_PPP_WITH_DIR = 204,
+    LINKTYPE_C_HDLC_WITH_DIR = 205,
+    LINKTYPE_FRELAY_WITH_DIR = 206,
+    LINKTYPE_LAPB_WITH_DIR = 207,
+    LINKTYPE_IPMB_LINUX = 209,
+    LINKTYPE_FLEXRAY = 210,
+    LINKTYPE_IEEE802_15_4_NONASK_PHY = 215,
+    LINKTYPE_USB_LINUX_MMAPPED = 220,
+    LINKTYPE_FC_2 = 224,
+    LINKTYPE_FC_2_WITH_FRAME_DELIMS = 225,
+    LINKTYPE_IPNET = 226,
+    LINKTYPE_CAN_SOCKETCAN = 227,
+    LINKTYPE_IPV4 = 228,
+    LINKTYPE_IPV6 = 229,
+    LINKTYPE_IEEE802_15_4_NOFCS = 230,
+    LINKTYPE_DBUS = 231,
+    LINKTYPE_DVB_CI = 235,
+    LINKTYPE_MUX27010 = 236,
+    LINKTYPE_STANAG_5066_D_PDU = 237,
+    LINKTYPE_NFLOG = 239,
+    LINKTYPE_NETANALYZER = 240,
+    LINKTYPE_NETANALYZER_TRANSPARENT = 241,
+    LINKTYPE_IPOIB = 242,
+    LINKTYPE_MPEG_2_TS = 243,
+    LINKTYPE_NG40 = 244,
+    LINKTYPE_NFC_LLCP = 245,
+    LINKTYPE_INFINIBAND = 247,
+    LINKTYPE_SCTP = 248,
+    LINKTYPE_USBPCAP = 249,
+    LINKTYPE_RTAC_SERIAL = 250,
+    LINKTYPE_BLUETOOTH_LE_LL = 251,
+    LINKTYPE_NETLINK = 253,
+    LINKTYPE_BLUETOOTH_LINUX_MONITOR = 254,
+    LINKTYPE_BLUETOOTH_BREDR_BB = 255,
+    LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR = 256,
+    LINKTYPE_PROFIBUS_DL = 257,
+    LINKTYPE_PKTAP = 258,
+    LINKTYPE_EPON = 259,
+    LINKTYPE_IPMI_HPM_2 = 260,
+    LINKTYPE_ZWAVE_R1_R2 = 261,
+    LINKTYPE_ZWAVE_R3 = 262,
+    LINKTYPE_WATTSTOPPER_DLM = 263,
+    LINKTYPE_ISO_14443 = 264,
+    LINKTYPE_RDS = 265,
+    LINKTYPE_USB_DARWIN = 266,
+    LINKTYPE_SDLC = 268,
+    LINKTYPE_LORATAP = 270,
+    LINKTYPE_VSOCK = 271,
+    LINKTYPE_NORDIC_BLE = 272,
+    LINKTYPE_DOCSIS31_XRA31 = 273,
+    LINKTYPE_ETHERNET_MPACKET = 274,
+    LINKTYPE_DISPLAYPORT_AUX = 275,
+    LINKTYPE_LINUX_SLL2 = 276,
+    LINKTYPE_OPENVIZSLA = 278,
+    LINKTYPE_EBHSCR = 279,
+    LINKTYPE_VPP_DISPATCH = 280,
+    LINKTYPE_DSA_TAG_BRCM = 281,
+    LINKTYPE_DSA_TAG_BRCM_PREPEND = 282,
+    LINKTYPE_IEEE802_15_4_TAP = 283,
+    LINKTYPE_DSA_TAG_DSA = 284,
+    LINKTYPE_DSA_TAG_EDSA = 285,
+    LINKTYPE_ELEE = 286,
+    LINKTYPE_Z_WAVE_SERIAL = 287,
+    LINKTYPE_USB_2_0 = 288,
+    LINKTYPE_ATSC_ALP = 289,
+    LINKTYPE_ETW = 290
 };

-struct pcaprec_hdr_t {
-        u32 ts_sec;         /* timestamp seconds */
-        u32 ts_usec;        /* timestamp microseconds */
-        u32 incl_len;       /* number of octets of packet saved in file */
-        u32 orig_len;       /* actual length of packet */
-        u8  data[incl_len];
+enum magic : u32 {
+	BE = 0xA1B2C3D4,
+	LE = 0xD4C3B2A1
 };

-struct pcap_hdr_t {
-        u32 magic_number;   /* magic number */
-        u16 version_major;  /* major version number */
-        u16 version_minor;  /* minor version number */
-        s32  thiszone;       /* GMT to local correction */
-        u32 sigfigs;        /* accuracy of timestamps */
-        u32 snaplen;        /* max length of captured packets, in octets */
-        network_type network;        /* data link type */
-        pcaprec_hdr_t packet[1000];
+
+struct pcap_record_t {
+    u32 ts_sec;         /* timestamp seconds */
+    u32 ts_usec;        /* timestamp microseconds */
+    u32 incl_len;       /* number of octets of packet saved in file */
+    u32 orig_len;       /* actual length of packet */
+    u8  data[incl_len];
 };

-pcap_hdr_t pcap @ 0x00;
+struct pcap_header_t {
+    u16 version_major;    /* major version number */
+    u16 version_minor;    /* minor version number */
+    s32 thiszone;         /* GMT to local correction */
+    u32 sigfigs;          /* accuracy of timestamps */
+    u32 snaplen;          /* max length of captured packets, in octets */
+    network_type network; /* data link type */
+};
+
+struct pcap {
+    be magic magic_number;
+    if (magic_number == magic::BE) {
+        be pcap_header_t header;
+        be pcap_record_t packet[while(!std::mem::eof())];
+    } else {
+        le pcap_header_t header;
+        le pcap_record_t packet[while(!std::mem::eof())];
+    }
+};
+
+pcap pcap @ 0x00;
--- a/patterns/pe.hexpat
+++ b/patterns/pe.hexpat
--- a/patterns/pif.hexpat
+++ b/patterns/pif.hexpat
@@ -0,0 +1,76 @@
+/* PIF - Portable Image Format
+ *
+ * Basic decoder for the PIF file structure
+ * https://github.com/gfcwfzkm/PIF-Image-Format
+ */
+
+#pragma MIME image/pif
+#pragma endian little
+
+enum imageType_t : u16 {
+	RGB888 = 0x433C,
+	RGB565 = 0xE5C5,
+	RGB332 = 0x1E53,
+	RGB16C = 0xB895,
+	BLWH   = 0x7DAA,
+	IND24  = 0x4952,
+	IND16  = 0x4947,
+	IND8   = 0x4942
+};
+
+enum compression_t : u16 {
+	NO_COMPRESSION  = 0,
+	RLE_COMPRESSION = 0x7DDE
+};
+
+struct PIFFileHeader {
+	char  Signature[4];
+	u32 FileSize;
+	u32 ImageOffset;
+};
+
+struct PIFInfoHeader {
+	imageType_t ImageType;
+	u16 BitsPerPixel;
+	u16 ImageWidth;
+	u16 ImageHeight;
+	u32 ImageSize;
+	u16 ColorTableSize;
+	compression_t Compression;
+};
+
+struct PIF {
+	PIFFileHeader PIF_FileHeader;
+	PIFInfoHeader PIF_ImageHeader;
+	
+	if (PIF_ImageHeader.ImageType == imageType_t::IND24)
+	{
+		u24 ColorTable[PIF_ImageHeader.ColorTableSize/3];
+	}
+	else if (PIF_ImageHeader.ImageType == imageType_t::IND16)
+	{
+		u16 ColorTable[PIF_ImageHeader.ColorTableSize/2];
+	}
+	else if (PIF_ImageHeader.ImageType == imageType_t::IND8)
+	{
+		u8 ColorTable[PIF_ImageHeader.ColorTableSize];
+	}
+	
+	if ((PIF_ImageHeader.ImageType == imageType_t::RGB888) ||
+		(PIF_ImageHeader.ImageType == imageType_t::IND24))
+	{
+		u24 ImageData[(PIF_FileHeader.FileSize - PIF_FileHeader.ImageOffset)/3];
+	}
+	else if ((PIF_ImageHeader.ImageType == imageType_t::RGB565) ||
+			 (PIF_ImageHeader.ImageType == imageType_t::IND16))
+	{
+		u16 ImageData[(PIF_FileHeader.FileSize - PIF_FileHeader.ImageOffset)/2];
+	}
+	else if ((PIF_ImageHeader.ImageType == imageType_t::RGB332) ||
+			 (PIF_ImageHeader.ImageType == imageType_t::IND8))
+	{
+		u8 ImageData[(PIF_FileHeader.FileSize - PIF_FileHeader.ImageOffset)/1];
+	}
+};
+
+PIF pif @ 0x00;
--- a/patterns/png.hexpat
+++ b/patterns/png.hexpat
@@ -1,6 +1,8 @@
 #pragma MIME image/png
 #pragma endian big

+#include <std/mem.pat>
+
 struct header_t {
    u8 highBitByte;
    char signature[3];
@@ -178,6 +180,7 @@ struct chunk_set {
    chunk_t chunks[while(builtin::std::mem::read_string($ + 4, 4) != "IEND")] [[inline]];
 } [[inline]];

+u8 visualizer[std::mem::size()] @ 0x00 [[sealed, hex::visualize("image", this)]];
 header_t header @ 0x00 [[comment("PNG file signature"), name("Signature")]];
 chunk_t ihdr_chunk @ 0x08 [[comment("PNG Header chunk"), name("IHDR")]];
 chunk_set set @ $ [[comment("PNG Chunks"), name("Chunks"), inline]];
--- a/patterns/protobuf.hexpat
+++ b/patterns/protobuf.hexpat
@@ -1,66 +1,67 @@
-#include <std/mem.pat>
-
-#include <type/leb128.pat>
-
-struct ZigZag32 {
-	u32 value;
-} [[sealed, format("format_zigzag32")]];
-
-fn format_zigzag32(ZigZag32 zigzag) {
-	return s32((s32(zigzag.value) << 1) ^ (s32(zigzag.value) >> 31));
-};
-
-struct ZigZag64 {
-	u64 value;
-} [[sealed, format("format_zigzag64")]];
-
-fn format_zigzag64(ZigZag64 zigzag) {
-	return s64((s64(zigzag.value) << 1) ^ (s64(zigzag.value) >> 63));
-};
-
-enum WireType : u8 {
-	Varint 			= 0,
-	_64Bit 			= 1,
-	LengthDelimited = 2,
-	StartGroup 		= 3,
-	EndGroup 		= 4,
-	_32Bit 			= 5
-};
-
-bitfield Key {
-	field_number : 5;
-	wire_type    : 3;
-} [[left_to_right]];
-
-union _64Bit {
-	u64 fixed64;
-	ZigZag64 sfixed64;
-	double dbl;
-};
-
-union _32Bit {
-	u32 fixed32;
-	ZigZag32 sfixed32;
-	float flt;
-};
-
-struct LengthDelimited {
-	type::LEB128 length;
-	char data[length];
-};
-
-
-struct Entry {
-	Key key;
-	
-	if (key.wire_type == WireType::Varint)
-		type::LEB128 value;
-	else if (key.wire_type == WireType::_64Bit)
-		_64Bit value;
-	else if (key.wire_type == WireType::LengthDelimited)
-		LengthDelimited value;
-	else if (key.wire_type == WireType::_32Bit)
-		_32Bit value;
-};
-
-Entry entries[while(!std::mem::eof())] @ 0x00;
+#include <std/core.pat>
+#include <std/mem.pat>
+
+#include <type/leb128.pat>
+
+struct ZigZag32 {
+	u32 value;
+} [[sealed, format("format_zigzag32")]];
+
+fn format_zigzag32(ZigZag32 zigzag) {
+	return s32((s32(zigzag.value) << 1) ^ (s32(zigzag.value) >> 31));
+};
+
+struct ZigZag64 {
+	u64 value;
+} [[sealed, format("format_zigzag64")]];
+
+fn format_zigzag64(ZigZag64 zigzag) {
+	return s64((s64(zigzag.value) << 1) ^ (s64(zigzag.value) >> 63));
+};
+
+enum WireType : u8 {
+	Varint 			= 0,
+	_64Bit 			= 1,
+	LengthDelimited = 2,
+	StartGroup 		= 3,
+	EndGroup 		= 4,
+	_32Bit 			= 5
+};
+
+bitfield Key {
+	field_number : 5;
+	wire_type    : 3;
+} [[bitfield_order(std::core::BitfieldOrder::MostToLeastSignificant, 8)]];
+
+union _64Bit {
+	u64 fixed64;
+	ZigZag64 sfixed64;
+	double dbl;
+};
+
+union _32Bit {
+	u32 fixed32;
+	ZigZag32 sfixed32;
+	float flt;
+};
+
+struct LengthDelimited {
+	type::LEB128 length;
+	char data[length];
+};
+
+
+struct Entry {
+	Key key;
+	
+	if (key.wire_type == WireType::Varint)
+		type::LEB128 value;
+	else if (key.wire_type == WireType::_64Bit)
+		_64Bit value;
+	else if (key.wire_type == WireType::LengthDelimited)
+		LengthDelimited value;
+	else if (key.wire_type == WireType::_32Bit)
+		_32Bit value;
+};
+
+Entry entries[while(!std::mem::eof())] @ 0x00;
--- a/patterns/qbcl.hexpat
+++ b/patterns/qbcl.hexpat
@@ -0,0 +1,80 @@
+// Qubicle QBCL format
+
+struct String {
+	u32 len;
+	char string[len];
+};
+
+struct Matrix {
+	u32 sizex;
+	u32 sizey;
+	u32 sizez;
+	s32 tx;
+	s32 ty;
+	s32 tz;
+	float pivotx;
+	float pivoty;
+	float pivotz;
+	u32 compressedDataSize;
+	u8 zip[compressedDataSize];
+};
+
+// Rotation matrix according to wikipedia
+// https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
+struct Matrices {
+	float row1[3];
+	float row2[3];
+	float row3[3];
+};
+
+using Node;
+
+struct Model {
+	Matrices rotation;
+	u32 childCount;
+	Node nodes[childCount];
+};
+
+struct Compound {
+	Matrix matrix;
+	u32 childCount;
+	Node nodes[childCount];
+};
+
+struct Node {
+	u32 type;
+	u32 unknown;
+	String name;
+	u8 visible;
+	u8 unknown2;
+	u8 locked;
+	if (type == 0) {
+		Matrix matrix;
+	} else if (type == 1) {
+		Model model;
+	} else if (type == 2) {
+		Compound compound;
+	}
+};
+
+struct Header {
+	u32 magic;
+	u32 version;
+	u32 fileversion;
+	u32 thumbwidth;
+	u32 thumbheight;
+	char bgra[thumbwidth * thumbheight * 4];
+	String title;
+	String desc;
+	String metadata;
+	String author;
+	String company;
+	String website;
+	String copyright;
+	// Maybe change and creation time?
+	double time1;
+	double time2;
+	Node node;
+};
+
+Header hdr @0x00;
--- a/patterns/qoi.hexpat
+++ b/patterns/qoi.hexpat
@@ -0,0 +1,98 @@
+#pragma MIME image/qoi
+#pragma endian big
+
+#include <std/mem.pat>
+
+namespace qoi {
+
+enum channels_t : u8 {
+    RGB = 3,
+    RGBA = 4
+};
+
+enum color_space_t : u8 {
+    sRGB = 0,
+    linear = 1
+};
+
+struct header_t {
+    char magic[4];
+    u32 width;
+    u32 height;
+    channels_t channels;
+    color_space_t color_space;
+};
+
+enum tags_t : u8 {
+    index = 0b00000000 ... 0b00111111,
+    diff  = 0b01000000 ... 0b01111111,
+    luma  = 0b10000000 ... 0b10111111,
+    run   = 0b11000000 ... 0b11111101,
+    rgb   = 0b11111110,
+    rgba  = 0b11111111,
+};
+
+bitfield op_index {
+    tag: 2;
+    index: 6;
+} [[color("0000FF")]];
+
+bitfield op_diff {
+    tag: 2;
+    dr: 2;
+    dg: 2;
+    db: 2;
+} [[color("FFFFFF")]];
+
+bitfield op_luma {
+    tag: 2;
+    diff_green: 6;
+    dr_dg: 4;
+    db_dg: 4;
+} [[color("FFFF00")]];
+
+bitfield op_run {
+    tag: 2;
+    run_length: 6;
+} [[color("00FF00")]];
+
+struct op_rgb {
+    u8 tag;
+    u8 red;
+    u8 green;
+    u8 blue;
+} [[color("FF7700")]];
+
+struct op_rgba {
+    u8 tag;
+    u8 red;
+    u8 green;
+    u8 blue;
+    u8 alpha;
+} [[color("FF0000")]];
+
+u8 op_type;
+fn get_op_type() {
+    op_type = std::mem::read_unsigned($, 1);
+    if (op_type < tags_t::rgb)
+        op_type &= 0b11000000;
+};
+
+struct op_t {
+    qoi::get_op_type();
+    if      (op_type == tags_t::index) op_index;
+    else if (op_type == tags_t::diff)  op_diff;
+    else if (op_type == tags_t::luma)  op_luma;
+    else if (op_type == tags_t::run)   op_run;
+    else if (op_type == tags_t::rgb)   op_rgb;
+    else if (op_type == tags_t::rgba)  op_rgba;
+};
+
+struct file_t {
+    header_t header;
+    op_t data[while(!std::mem::eof())];
+};
+
+} // namespace qoi
+
+qoi::file_t qoi_picture @ 0x0;
--- a/patterns/sit5.hexpat
+++ b/patterns/sit5.hexpat
@@ -13,13 +13,13 @@ namespace v5 {
        folder : 1;
        encrypted : 1;
        padding : 5;
-    } [[left_to_right]];
+    };
    
    bitfield Flags2 {
        padding : 7;
        resource_fork : 1;
        padding : 8;
-    } [[left_to_right]];
+    };
    
    using MacOSHFSPlusDate = u32 [[format("v5::format_macos_date")]];
    
--- a/patterns/spirv.hexpat
+++ b/patterns/spirv.hexpat
@@ -1,3 +1,5 @@
+#include <std/mem.pat>
+
 enum GeneratorID : u16 {
    Khronos = 0,
    LunarG = 1,
@@ -642,4 +644,4 @@ struct Instruction {
 Header header @ 0x00;

 // SPIR-V does not have any footer, increase number of instructions manually if you encounter a bigger shader
-Instruction instructions[1024] @ 0x14;
+Instruction instructions[while (!std::mem::eof())] @ 0x14;
--- a/patterns/stl.hexpat
+++ b/patterns/stl.hexpat
@@ -5,34 +5,47 @@

 #include <std/sys.pat>
 #include <std/mem.pat>
+#include <std/core.pat>

 struct Vector3f {
-	float x, y, z;
+    float x, y, z;
 } [[static, format("format_vector3f")]];

 fn format_vector3f(Vector3f vec) {
-	return std::format("[ {}, {}, {} ]", vec.x, vec.y, vec.z);
+    return std::format("[ {}, {}, {} ]", vec.x, vec.y, vec.z);
 };

 struct Triangle {
-	Vector3f normal;
-	Vector3f points[3];
-	u16 flags;
+    Vector3f normal;
+    Vector3f points[3];
+    u16 flags;
 } [[static]];

 struct BinarySTLHeader {
-	char caption[];
-	padding[80 - sizeof(caption)];
-	u32 triangleCount;
+    char caption[while($[$] != 0x00 && $ - addressof(this) < 80)];
+    padding[80 - sizeof(caption)];
+    u32 triangleCount;
 };

-struct STL {	
-	if (std::mem::read_string(0, 6) == "solid ")
-		std::warning("ASCII STL file!");
-	else {
-		BinarySTLHeader header;
-		Triangle triangles[header.triangleCount];
-	}
+struct STL {    
+    if (std::mem::read_string(0, 6) == "solid ")
+        std::warning("ASCII STL file!");
+    else {
+        BinarySTLHeader header;
+        Triangle triangles[header.triangleCount];
+    }
 };

-STL stl @ 0x00;
+STL stl @ 0x00;
+
+/* Visualize the 3D Model */
+
+struct Vertex {
+    Vector3f points[3] @ addressof(stl.triangles[std::core::array_index()].points);
+};
+
+struct Model {
+    Vertex vertices[stl.header.triangleCount];
+} [[highlight_hidden, sealed, hex::visualize("3d", vertices, null)]];
+
+Model model @ 0x00;
--- a/patterns/tar.hexpat
+++ b/patterns/tar.hexpat
@@ -9,7 +9,8 @@
 #include <std/sys.pat>


-#define HEADER "ustar "
+#define GNU_HEADER "ustar "
+#define PAX_HEADER "ustar\x00"
 #define NULL "\x00"

 fn octal_to_decimal(str value) {
@@ -83,6 +84,6 @@ struct tar {
 };

 char magic[6] @ 0x00000101 [[hidden]];
-std::assert(magic == HEADER, "Magic bytes are not correct! Perhaps wrong file?");
+std::assert(magic == PAX_HEADER || magic == GNU_HEADER, "Magic bytes are not correct! Perhaps wrong file?");

 tar tar[while(!std::mem::eof())] @ 0x000;
--- a/patterns/tga.hexpat
+++ b/patterns/tga.hexpat
@@ -72,8 +72,9 @@ struct Footer {
  u32 developerDirectoryOffset;
  char signature[0x10];
  char dot;
-  char null;
+  char zero;
 };

+u8 visualizer[std::mem::size()] @ 0x00 [[sealed, hex::visualize("image", this)]];
 Header header @ 0x0;
 Footer footer @ std::mem::size() - 0x1A;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nik	1a2d785093	patterns/java_class: Added MIME type	2023-06-24 11:05:10 +02:00
Nik	addec74d91	type/leb128: Fixed type always displaying 0	2023-06-22 17:35:59 +02:00
jfsbrito	ce83eedf02	patterns/7z: Added CompressData length and other improvements (#134 ) * Update 7z.hexpat - v1.01 v1.01 --Minor changes. --CompressData lenght added --Output optimization * Update 7z.hexpat v1.02 -Minor Changes -Added Bzip2 verification	2023-06-22 07:27:31 +02:00
Doriel Rivalet	463ddcc62e	themes: Add Catppuccin themes (#132 ) * docs(README): add catppuccin theme * themes: add catppuccin flavors * chore: rename catppuccin files * docs(README): update catppuccin file names	2023-06-19 23:09:16 +02:00
jfsbrito	13b97fc976	patterns/7z: Added 7Zip pattern (#128 ) * 7z.hexpat This repository contains a custom pattern for the ImHex tool that enables the analysis of 7zip files. The pattern allows for a structured view of 7zip files within ImHex, providing insights into various aspects of the file structure. - Identification of 7zip files: The custom pattern detects and identifies 7zip file types based on their signature. - Extraction of key information: The pattern extracts important details from the 7zip file, such as the format version, CRC values, relative offset of the end header, and file size. - Differentiation of compression methods: The pattern distinguishes between LZMA and LZMA2 compression methods used within the 7zip file. - Visualization of start and end headers: The pattern helps in visualizing the start and end headers of the 7zip file, making it easier to navigate through its structure. To use the custom pattern for analyzing 7zip files in ImHex, follow these steps: 1. Install ImHex: Ensure that you have ImHex installed on your system. 2. Open a 7zip file: Launch ImHex and open the 7zip file you want to analyze. 3. Apply the custom pattern: In the "Pattern" menu, select the custom pattern for 7zip file analysis and apply it. 4. Explore the file structure: ImHex will display the matched patterns, allowing you to explore the structure of the 7zip file with the extracted information. Please note that this custom pattern is designed specifically for 7zip files and may not be suitable for other file formats. Contributions to this custom pattern for 7zip file analysis are welcome. If you have any improvements, bug fixes, or suggestions, feel free to submit a pull request. This custom pattern for ImHex is licensed under the [MIT License](LICENSE.md). You are free to modify and distribute this pattern as per the terms of the license. We would like to acknowledge the developers of ImHex for providing an excellent tool for binary file analysis. The custom pattern for 7zip file analysis in this repository builds upon the capabilities of ImHex to enhance the understanding of 7zip file structures. --- We hope you find this custom pattern useful for analyzing 7zip files using ImHex. If you encounter any issues or have any questions, please feel free to raise them in the "Issues" section of this repository. Thanks! * Added test file ---------	2023-06-19 23:08:42 +02:00
luisfilipe23lol	55e4283432	patterns/cda: Added CDA pattern (#133 ) * Create cda.hexpat pattern language created for .cda files * added test file for cda pattern * Delete cda.hexpat.cda.cda * Add test file cda test file for cda pattern * Update README.md Add cda file in read.me	2023-06-19 14:22:17 +02:00
Nik	ea225edf12	git: Disable coverage information for now	2023-06-17 15:20:01 +02:00
blondecake433	bb19cb43ee	patterns:/mp4: Added mp4 pattern (#129 )	2023-06-17 15:07:08 +02:00
Nik	8f8ad0e2d5	git: Try fix Coveralls heap out of memory	2023-06-17 15:02:53 +02:00
Nik	3ad1f3969f	includes/std: Fixed documentation of copy_value_to_section function	2023-06-15 22:58:44 +02:00
cryptax	5451d45158	patterns/dex: Fix pattern to see data section of DEX files + Link_data (#127 )	2023-06-15 18:48:47 +02:00
Nik	e6a731fa1d	includes/type: Added Base64 type	2023-06-15 17:34:20 +02:00
Jackson Barreto	8a62001705	patterns: Added TIFF pattern (#126 ) * Create tiff.hexpat * Update README.md Update readme to include tiff hexpat * added file to test the pattern --------- Co-authored-by: joelalves <joel.17.alves@gmail.com>	2023-06-15 08:08:39 +02:00
Nik	1f8710b586	patterns/ntag: Fixed Length type transform function	2023-06-13 13:36:53 +02:00
Nik	acd2d4abb8	includes/std: Fixed description of array library (#125 )	2023-06-12 08:10:48 +02:00
qufb	032f3c7c01	pattern/midi: Support multiple tracks (#124 ) * pattern/midi: Support multiple tracks * pattern/midi: Replace custom type used to index array	2023-06-11 13:09:23 +02:00
无以铭川	3841ff51ef	pattern/java_class: Format byte code instruction (#123 )	2023-06-08 23:39:39 +02:00
Nik	622721403f	patterns/flac: Fixed typo	2023-06-06 08:26:01 +02:00
Nik	11291d1ebb	tests: Added JPG test file	2023-06-05 10:59:12 +02:00
Nik	92e61ccf5d	tests: Fixed build with new pattern language changes	2023-06-05 10:03:55 +02:00
Nik	062edfe527	includes/std: Fixed `std::fxpt::to_fixed` conversion issue	2023-06-05 09:48:33 +02:00
paxcut	5b32941801	patterns: Added visualizers to image patterns (#117 ) * Added image visualizers to image patterns that were supported * missing include files * Small style fixes --------- Co-authored-by: Nik <werwolv98@gmail.com>	2023-06-04 22:38:25 +02:00
Nik	e99ab5b59b	patterns/java_class: Fixed duplicate variables	2023-06-02 10:54:09 +02:00
Feitong Chen	775c836766	patterns/macho: Fix macho CpuType error and add CpuType::ARM64 and CpuType::ARM64_32 (#115 )	2023-06-01 16:38:34 +02:00
blondecake433	43058b4c45	pattern/gif: Improved GIF pattern (#114 )	2023-05-26 09:28:18 +02:00
Justus Garbe	0128ea87db	patterns/java_class: Added Java SE 20 Attributes, added value displaying (#113 ) greatly enchanced the java pattern	2023-05-19 17:59:15 +02:00
WerWolv	fe231436d9	patterns/gb: Added Gameboy ROM pattern (#89 ) * Added gameboy format * Add mime type * Add test * Avoid DMCA :sweating:	2023-05-19 16:09:14 +02:00
gmestanley	7a9ac44577	patterns/pe: Improved PE pattern (#112 ) New improvement	2023-05-16 11:03:07 +02:00
Nick Bitounis	74e9d8f2e7	patterns: Added pattern file for M.A.X. v1.04 game files. (#111 ) * Added pattern file for M.A.X. v1.04 game files. * * Added MAX pattern in list of patterns. * Added MAX sample game save file. * Reordered the list of patterns to ascending name. --------- Co-authored-by: n.bitounis <n.bitounis@xe.gr>	2023-05-08 16:17:19 +02:00
Nik	2f39a62d85	includes/std: Added support for writing patterns to files	2023-05-02 20:38:21 +02:00
AdventureT	e21063d58b	patterns: Added Crash Bandicoot - Back in time level format (#110 ) * Added Crash Bandicoot - Back in time level format * Update README.md * Fix README.md	2023-04-25 21:44:02 +02:00
paxcut	8f1a6bdd75	includes/std: Added std::math::exp(), fixed std::math::ln comment (#106 ) Removed extraneous argument base to ln function and added the necessary definition in include file to access previously builtin function exp.	2023-04-17 22:19:47 +02:00
Nik	b9af43e08b	patterns: Fixed WAV MIME type in readme	2023-04-16 21:37:40 +02:00
Nik	2ffa4e0161	patterns/wav: Fixed MIME type	2023-04-06 12:33:46 +02:00
Zaggy1024	1cd7f92a5d	patterns/includes: Update standard library and patterns to support the new bitfields (#102 ) * Add `current_bit_offset()` and `read_bits(...)` to `std::mem` * Replace deprecated BitfieldOrder enum values with new clearer names This adds new options named `MostToLeastSignificant` and `LeastToMostSignificant` to replace the old `LeftToRight` and `RightToLeft` names. These names should be much clearer about what they affect and how. * Throw errors when `std::core::(get\|set)_bitfield_order()` are called * Update all patterns to work with the new bitfield behaviors	2023-04-01 11:16:54 +02:00
Nik	d42b87d9e6	git: Added CONTRIBUTING.md	2023-03-29 08:10:58 +02:00
Nik	035de359d7	git: Updated readme information	2023-03-29 08:03:40 +02:00
Nik	fe59788783	includes/type: Fixed IP library top level comment	2023-03-28 18:39:46 +02:00
Nik	ef198cf24f	includes/type: Fixed Path formatter	2023-03-28 15:53:19 +02:00
Nik	b73b69a8cc	includes: Added documentations for all remaining types and functions	2023-03-28 15:28:44 +02:00
Nik	5d72494019	includes/hex: Added ImHex check to provider library	2023-03-28 10:21:03 +02:00
Nik	afbce642fb	includes/hex: Added provider functions	2023-03-28 09:49:12 +02:00
Nik	a72058eb65	includes/std: Added std::random functions	2023-03-28 09:28:28 +02:00
Chris Bailey	ab2ed98dab	includes/std: Added nullable pointers to std/ptr (#97 )	2023-03-27 10:05:12 +02:00
WerWolv	3edc6ea172	includes: Added documentation for a few more files	2023-03-26 16:58:39 +02:00
WerWolv	a9a7f0b186	includes: Added documentation to the rest of the std and hex library	2023-03-26 16:34:06 +02:00
Nik	5f352e26d1	patterns/elf: Make displaying section names optional	2023-03-26 11:34:52 +02:00
Nik	3e2a6aabaa	patterns/evtx: Fixed type name typo	2023-03-26 11:22:15 +02:00
Nik	56d6f0187f	patterns/zstd: Fixed block_header_t bitfield	2023-03-26 11:09:26 +02:00
Vladimir	adf7256c39	patterns/bsp: Added GoldSrc engine maps file format (#101 ) Co-authored-by: Nik <werwolv98@gmail.com>	2023-03-26 10:36:03 +02:00
dora	a25a8a3615	patterns/evtx: Added evtx pattern (#100 ) * add evtx pattern * fix Readme * fix coding style * space adjustment * space adjustment	2023-03-26 10:34:45 +02:00
WerWolv	6ae8b30488	git: Allow documentation to be regenerated when PatternLanguage changes were made	2023-03-26 10:26:40 +02:00
Nik	125ba38d72	plugins/extra-hashes: Fixed ImHex version	2023-03-25 15:33:55 +01:00
Nik	ba55feb200	plugins: Added Extra Hashes plugin to database	2023-03-25 14:47:09 +01:00
Nik	a301a4bfeb	themes: Added Solarized Dark theme	2023-03-23 17:20:05 +01:00
Nik	531be04739	themes/vs_dark: Fixed window title alignment	2023-03-23 14:38:39 +01:00
Nik	87e05bec48	git: Fixed uefi pattern link in readme	2023-03-23 11:59:38 +01:00
Morten Linderud	a31d290005	patterns/uefi: Added UEFI pattern (#8 ) Added UEFI structs Signed-off-by: Morten Linderud <morten@linderud.pw> Co-authored-by: Nik <werwolv98@gmail.com>	2023-03-23 11:52:50 +01:00
Andrei Makeev	f3de35a320	patterns/elf: Make hex view less ambiguous (#92 ) * ELF: make section/segment data arrays sealed * ELF: set display names for section/segment data * Added new functions to library * Updated ELF pattern --------- Co-authored-by: Nik <werwolv98@gmail.com>	2023-03-23 11:51:01 +01:00
Oded Shapira	d9de2f7058	patterns/lua54: Added new Lua 5.4 bytecode pattern (#80 ) * Lua 5.4 pattern * Fixed formatting, added file to readme --------- Co-authored-by: Nik <werwolv98@gmail.com>	2023-03-23 09:06:24 +01:00
Jozef Izso	790f837e4f	patterns/dsstore: Added `.DS_Store` pattern (#90 ) * Initial format for Buddy Allocator structures in `.DS_Store` files * Add list of entries for files in `.DS_Store` * Add root block, offsets, toc and free lists structures * Add parsing of block data * Document `.DS_Store` pattern and add test file	2023-03-23 08:59:59 +01:00
Josh	d8a291977a	encodings: Added Pokemon gen 3 character encoding (#96 ) * added Pokemon Emerald character encoding * update readme.md for generic gen 3 table * Update and rename pokeEmerald_en.tbl to pokegen3_en.tbl	2023-03-23 08:58:44 +01:00
Nicolás Alvarez	62a83b53aa	patterns/pbz: Modernize code, renamed pattern to pbz (#98 ) * Update pbz pattern - Rename pbzx to pbz; turns out the 'x' is the compression type. - Use type::Magic for the "pbz" magic number. - Decode compression type as an enum. - Mention compression_tool in the header comment. * Rename pbzx.hexpat to pbz.hexpat	2023-03-23 08:57:33 +01:00
Takumi Sueda	53ea45ffa6	patterns/PCAP: Fixed formatting and added endianess support (#99 ) * patterns/pcap: reformat * patterns/pcap: endianness-aware parse / parse packets until EOF	2023-03-23 08:56:20 +01:00
WerWolv	c0a1bbd218	includes/std: Fixed stray " in bit library	2023-03-19 16:30:54 +01:00
WerWolv	27f4e20638	git: Fixed documentation dispatch	2023-03-19 16:26:21 +01:00
WerWolv	bbb2107d5f	git: Always execute dispatch	2023-03-19 16:21:46 +01:00
WerWolv	8601a6665e	includes/std: Added first set of documentation to the std library	2023-03-19 16:17:04 +01:00
WerWolv	c6f2b57384	git: Fixed workflow name	2023-03-19 11:23:43 +01:00
WerWolv	dd190f7c8a	git: Added documentation dispatch workflow	2023-03-19 11:22:55 +01:00
Nik	55e3fec3bc	includes/std: Added std::math::accumulate, corrected std::hash::crc32	2023-03-14 14:40:58 +01:00
WerWolv	8e78f371f5	encodings/utf8: Corrected UTF-8 encoding file	2023-03-14 09:36:59 +01:00
Ahmet Bilal Can	2758ec8d36	patterns/dex: Added more information to display (#95 ) Added string representations for: - string ids - field ids - method ids - class ids - proto ids	2023-03-13 11:43:43 +01:00
WerWolv	82ca79c166	patterns/usb: Fixed duplicate variable declaration	2023-03-13 11:35:09 +01:00
WerWolv	146273b1b3	tests: Fixed compilation with latest libpl	2023-03-13 11:19:20 +01:00
Andrei Makeev	ab4bff9f42	patterns/elf: Treat SHT_SYMTAB as symbol tables (#91 ) ELF files: support static symbol tables	2023-03-10 11:03:36 +01:00
cryptax	000f0eb730	patterns/dex: Adding Dalvik Executable pattern (#94 ) * adding DEX file format * adding map list	2023-03-10 11:03:07 +01:00
qux-bbb	2d45d5d086	patterns/pe: Removed unnecessary offset (#87 ) Remove unnecessary offsets	2023-02-22 21:05:13 +01:00
Nik	2d4b4add82	includes/std: Added Bytes type	2023-02-22 18:31:52 +01:00
Nik	e635c3a5bf	patterns/stl: Added 3D model visualization	2023-02-20 11:35:15 +01:00
Chris	15234a284d	includes/type: Add signed LEB128 type support (#86 )	2023-02-17 20:35:27 +01:00
Nik	0673673b99	themes/vs_dark: Added new Visual Studio Dark theme	2023-02-16 18:11:05 +01:00
Justus Garbe	3786f7e265	patterns/gif: Improved gif format using more explicit formating styles (#84 ) * Improved gif format using more explicit formating styles * Set mime type * Move content type formatting to struct value	2023-02-15 09:40:09 +01:00
Kuruyia	ea4dda001a	includes/type: Fix the IPv6 type (#83 ) includes/type: fix the IPv6 type	2023-02-13 08:49:29 +01:00
Nik	324b0894d3	git: Fixed typos	2023-02-10 11:47:36 +01:00
Nik	e89e85e10c	nodes: Added Caecar and XOR cipher nodes	2023-02-10 11:25:56 +01:00
Nik	b93e957e46	patterns/jpeg: Removed hex::visualize attribute until it's supported by ImHex	2023-02-09 11:49:43 +01:00
Camas	e7eba44ae0	git: Fix broken ID3 link in README.md (#81 ) Fix broken ID3 link	2023-02-06 07:12:30 +01:00
Lenni0451	41d801a114	patterns/nbt: Added missing int array and long array tag (#79 )	2023-02-03 21:55:52 +01:00
Nik	25f73ca721	patterns/afe2: Fixed missing include	2023-01-30 16:37:55 +01:00
Nik	facbe59163	patterns/jpeg: Added JPEG pattern	2023-01-29 00:15:56 +01:00
Nik	55023ce4ea	patterns/tga: Make pattern compatible with new version	2023-01-22 12:24:14 +01:00
Hank Donnay	32158edb3a	patterns/tar: Support PAX archives (#77 ) There are two common magic values for archives: the [GNU one](https://git.savannah.gnu.org/cgit/tar.git/tree/src/tar.h#n160) (8 bytes) and the [ustar one](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_06) (6 bytes). This change has the pattern support both.	2023-01-17 22:51:11 +01:00
WerWolv	862d4d1c28	includes/std: Added missing std::file::seek function	2023-01-16 14:23:29 +01:00
Pascal	d4045b76c3	patterns/pif: Add PIF image pattern (#76 ) * Added PIF pattern * tests/patterns: Added test file for pif pattern * Added pif pattern to list * Delete pif.hexpat.pif * patterns: Added pif image format pattern	2023-01-16 12:07:11 +01:00
Martin Gerhardy	8ab2ff4ab1	patterns: Added a few voxel model patterns (#74 ) * patterns: added a few voxel model patterns * patterns: updated qbcl according to https://gist.github.com/tostc/7f049207a2e5a7ccb714499702b5e2fd * readme: added new voxel format petterns to the readme * tests: added vxl test file * ccvxl: updated two fields	2023-01-13 20:19:06 +01:00
Nik	5ea7141cb7	patterns: Added Xbox executable (XBEH) pattern	2023-01-12 11:35:47 +01:00
Berylskid	9b13113682	encodings: Update shiftjis.tbl and create ms932.tbl (#73 ) * Duplicate current shiftjis.tbl as ms932.tbl * Correct some wrong characters in shiftjis.tbl * Remove bunch of non-shift-jis characters from shiftjis.tbl * Add a missing character (819F=◆)	2023-01-12 11:33:34 +01:00
Max1Truc	0748fa135e	patterns/qoi: Fixed bitfields order being wrong (#72 )	2023-01-10 09:15:08 +01:00
Max1Truc	a4a14309be	patterns/qoi: Added QOI pattern (#71 ) For more information on QOI: https://qoiformat.org/	2023-01-09 07:29:33 +01:00
Nik	7c179b3b41	git: Added note for `application/octet-stream` MIME type to PR template	2023-01-08 16:19:38 +01:00
Daniel Stinson-Diess	c204696209	patterns/dmg: Added DMG pattern (#70 )	2023-01-08 16:11:57 +01:00