includes/std: Added hex::dec::lz4_decompress()

git: Fix hinf_tag and hinf_module links in readme (#268 )
patterns/hinf_*: Add Halo Infinite tag and module file patterns (#267 )
2026-03-31 05:15:54 -05:00 · 2024-07-07 15:51:40 +02:00 · 2024-07-07 13:44:04 +02:00 · 2024-07-06 17:33:03 +02:00 · 2024-07-04 20:47:39 +02:00 · 2024-07-04 17:58:12 +02:00
188 changed files with 32132 additions and 2485 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,2 +1,4 @@
 *.pat               linguist-language=Rust
 *.hexpat            linguist-language=Rust
+
+tests/patterns/test_data/**  binary
--- a/.github/PULL_REQUEST_TEMPLATE/pattern_template.md
+++ b/.github/PULL_REQUEST_TEMPLATE/pattern_template.md
@@ -5,6 +5,7 @@
 ## Checklist
 - [ ] 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 new pattern has a description pragma (`#pragma description My pattern Description here`)
 - [ ] 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)
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -28,6 +28,7 @@ jobs:
        sudo apt update
        sudo apt install -y       \
            build-essential       \
+            ccache                \
            gcc-12                \
            g++-12                \
            lld                   \
@@ -41,12 +42,21 @@ jobs:
        
        sudo pip install jsonschema

+    - name: 📜 Setup ccache
+      uses: hendrikmuhs/ccache-action@v1
+      with:
+        key: ${{ runner.os }}-ccache-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-ccache
+        max-size: 1G
+
    - name: 🛠️ Build
      run: |
        cd tests
        mkdir -p build
        cd build
        CC=gcc-12 CXX=g++-12 cmake                        \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache              \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache            \
          -DCMAKE_C_FLAGS="-fuse-ld=lld --coverage"       \
          -DCMAKE_CXX_FLAGS="-fuse-ld=lld --coverage"     \
          -DLIBPL_ENABLE_TESTS=OFF                        \
@@ -57,20 +67,7 @@ jobs:
    - name: 🧪 Perform Unit Tests
      run: |
        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: ⬆️ 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
+        ctest --output-on-failure -j 4

    - name: 📎 Validate JSON Files
      run: |
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@

-tests/cmake-build-debug/
+tests/cmake*/
+tests/build*/

 .idea/
 .DS_Store
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +1,10 @@
 [submodule "rules"]
 	path = yara/official_rules
 	url = https://github.com/Yara-Rules/rules
-	branch = master
+	branch = master
+[submodule "patterns/ffx"]
+	path = patterns/ffx
+	url = https://gitlab.com/EvelynTSMG/imhex-ffx-pats.git
+[submodule "patterns/bastion"]
+	path = patterns/bastion
+	url = https://gitlab.com/EvelynTSMG/imhex-bastion-pats.git
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # ImHex Database

 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
@@ -25,12 +26,16 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | 3DS | | [`patterns/3ds.hexpat`](patterns/3ds.hexpat) | Autodesk 3DS Max Model file |
 | 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 |
+| ANI | `application/x-navi-animation` | [`patterns/ani.hexpat`](patterns/ani.hexpat) | Windows Animated Cursor file |
 | AR | `application/x-archive` | [`patterns/ar.hexpat`](patterns/ar.hexpat) | Static library archive files |
+| ARIA2 | | [`patterns/aria2.hexpat`](patterns/aria2.hexpat) | ARIA2 Download Manager Control files |
 | ARM VTOR | | [`patterns/arm_cm_vtor.hexpat`](patterns/arm_cm_vtor.hexpat) | ARM Cortex M Vector Table Layout |
+| Bastion | | [`patterns/bastion/*`](https://gitlab.com/EvelynTSMG/imhex-bastion-pats) | Various [Bastion](https://en.wikipedia.org/wiki/Bastion_(video_game)) files |
 | Bencode | `application/x-bittorrent` | [`patterns/bencode.hexpat`](patterns/bencode.hexpat) | Bencode encoding, used by Torrent files |
 | BMP  | `image/bmp` | [`patterns/bmp.hexpat`](patterns/bmp.hexpat) | OS2/Windows Bitmap files |
 | BIN  | | [`patterns/selinux.hexpat`](patterns/selinux.pat) | SE Linux modules |
 | BSON | `application/bson` | [`patterns/bson.hexpat`](patterns/bson.hexpat) | BSON (Binary JSON) format |
+| bplist | | [`patterns/bplist.hexpat`](patterns/bplist.hexpat) | Apple's binary property list format (bplist) |
 | 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 |
@@ -39,20 +44,27 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | 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 |
+| CrashLvl | | [`patterns/Crashlvl.hexpat`](patterns/Crashlvl.hexpat) | Crash Bandicoot - Back in Time (fan game) User created 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 |
+| DS_Store | | [`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 |
+| DTED | | [`patterns/dted.hexpat`](patterns/dted.hexpat) | Digital Terrain Elevation Data (DTED) |
 | 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 |
+| FAS | | [`patterns/fas_oskasoftware.hexpat`](patterns/fas_oskasoftware.hexpat) [`patterns/fas_oskasoftware_old.hexpat`](patterns/fas_oskasoftware_old.hexpat) (Old versions of Oska DeskMate) | Oska Software DeskMates FAS (Frames and Sequences) file |
 | FDT | | [`patterns/fdt.hexpat`](patterns/fdt.hexpat) | Flat Linux Device Tree blob |
+| FFX | | [`patterns/ffx/*`](https://gitlab.com/EvelynTSMG/imhex-ffx-pats) | Various Final Fantasy X files |
 | 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 |
+| GGUF | | [`patterns/gguf.hexpat`](patterns/gguf.hexpat) | GGML Inference Models |
 | 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 |
+| Halo Tag || [`patterns/hinf_tag.hexpat`](patterns/hinf_tag.hexpat) | Halo Infinite Tag Files |
+| Halo Module || [`patterns/hinf_module.hexpat`](patterns/hinf_module.hexpat) | Halo Infinite Module Archive Files |
+| Halo HavokScript || [`patterns/hinf_luas.hexpat`](patterns/hinf_luas.hexpat) | Halo Infinite HavokScript 5.1 Bytecode |
 | 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") |
@@ -71,39 +83,52 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | NBT | | [`patterns/nbt.hexpat`](patterns/nbt.hexpat) | Minecraft NBT format |
 | NE   | | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
 | nes   | | [`patterns/nes.hexpat`](patterns/nes.hexpat) | .nes file format |
+| NotepadWindowState | | [`patterns/notepad-windowstate.hexpat`](patterns/notepad-windowstate.hexpat) | Windows 11 Notepad - Window State .bin file |
 | 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 |
+| PAK | | [`patterns/xgspak.hexpat`](patterns/xgspak.hexpat) | Exient XGS Engine Pak files |
 | 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 |
-| PP   | [`patterns/selinuxpp.hexpat`](patterns/selinuxpp.pat) | SE Linux package |
+| PE   | `application/x-dosexec` `application/x-msdownload` | [`patterns/pe.hexpat`](patterns/pe.hexpat) | PE header, COFF header, Standard COFF fields and Windows Specific fields |
+| PP   | | [`patterns/selinuxpp.hexpat`](patterns/selinuxpp.pat) | SE Linux package |
 | 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 | 
-| PyInstaller | | [`patterns/pyinstaller.hexpat`](patterns/pyinstaller.hexpat) | PyInstaller binray files | 
+| 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 |
+| psafe3 | | [`patterns/psafe3.hexpat`](patterns/psafe3.hexpat`) | Password Safe V3 |
+| PyInstaller | | [`patterns/pyinstaller.hexpat`](patterns/pyinstaller.hexpat) | PyInstaller binray files |
 | PYC | | [`patterns/pyc.hexpat`](patterns/pyc.hexpat) | Python bytecode files |
 | QBCL | | [`patterns/qbcl.hexpat`](patterns/qbcl.hexpat) | Qubicle voxel scene project file |
 | QOI  | `image/qoi` | [`patterns/qoi.hexpat`](patterns/qoi.hexpat) | QOI image files |
+| RAS  | `image/x-sun-raster` | [`patterns/ras.hexpat`](patterns/ras.hexpat) | RAS image files |
+| ReFS | | [`patterns/refs.hexpat`](patterns/refs.hexpat) | Microsoft Resilient File System |
 | Shell Link | `application/x-ms-shortcut` | [`patterns/lnk.hexpat`](patterns/lnk.hexpat) | Windows Shell Link file format |
+| shp | | [`patterns/shp.hexpat`](patterns/shp.hexpat) | ESRI shape file |
+| shx | | [`patterns/shx.hexpat`](patterns/shx.hexpat) | ESRI index file |
 | 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 |
+| SWF | |[`patterns/swf.hexpat`](patterns/swf.hexpat) | Shockwave Flash file format |
 | 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 |
+| TTF | `font/ttf`, `font/otf` | [`patterns/ttf.hexpat`](patterns/ttf.hexpat) | TrueType and OpenType font format |
 | Ubiquiti | | [`patterns/ubiquiti.hexpat`](patterns/ubiquiti.hexpat) | Ubiquiti Firmware (update) 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) |
+| VBMeta | | [`patterns/vbmeta.hexpat`](patterns/vbmeta.hexpat) | Android VBMeta image |
 | 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 |
+| WAS | | [`patterns\was_oskasoftware.hexpat`](patterns\was_oskasoftware.hexpat) | Oska Software DeskMates WAS/WA3 (WAVE/MP3 Set) file
 | 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 |
+| XCI | | [`patterns/xci.hexpat`](patterns/xci.hexpat) | Nintendo Switch XCI cartridge ROM |
+| XGT | | [`patterns/xgt.hexpat`](patterns/xgstexture.hexpat) | Exient XGS Engine Texture |
 | Xilinx BIT | | [`patterns/xilinx_bit.hexpat`](patterns/xilinx_bit.hexpat) | Xilinx FPGA Bitstreams |
+| Xilinx Bootgen | | [`patterns/xilinx_bootgen.hexpat`](patterns/xilinx_bootgen.hexpat) | Xilinx ZynqMP Boot Images |
 | ZIP  | `application/zip` | [`patterns/zip.hexpat`](patterns/zip.hexpat) | End of Central Directory Header, Central Directory File Headers |
 | ZLIB | `application/zlib` | [`patterns/zlib.hexpat`](patterns/zlib.hexpat) | ZLIB compressed data format |
 | ZSTD | `application/zstd` | [`patterns/zstd.hexpat`](patterns/zstd.hexpat) | Zstandard compressed data format |
@@ -119,9 +144,9 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi

 | Name | Path | Description |
 |------|------|-------------|
-| libstd | [`includes/std/*`](includes/std) | Pattern Language Standard Libaray |
-| libtype | [`includes/type/*`](includes/type) | Various custom types with special formatters |
 | libhex | [`includes/hex/*`](includes/hex) | Functions to interact with ImHex |
+| libstd | [`includes/std/*`](includes/std) | Pattern Language Standard Library |
+| libtype | [`includes/type/*`](includes/type) | Various custom types with special formatters |

 ### Yara rules

@@ -156,6 +181,7 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | ASCII+OEM | [`encodings/ascii_oem.tbl`](encodings/ascii_oem.tbl) | ASCII encoding with Windows OEM characters |
 | Baltic ISO | [`encodings/baltic_iso.tbl`](encodings/baltic_iso.tbl) | Baltic ISO encoding |
 | Baltic Windows | [`encodings/baltic_windows.tbl`](encodings/baltic_windows.tbl) | Baltic Windows encoding |
+| Big5 (Traditional Chinese) | [`encodings/big5.tbl`](encodings/big5.tbl) | Big5 encoding for Traditional Chinese |
 | Cyrillic ISO | [`encodings/cyrillic_iso.tbl`](encodings/cyrillic_iso.tbl) | Cyrillic ISO encoding |
 | Cyrillic Windows | [`encodings/cyrillic_windows.tbl`](encodings/cyrillic_windows.tbl) | Cyrillic Windows encoding |
 | Cyrillic KOI8-R | [`encodings/cyrillic_koi8_r.tbl`](encodings/cyrillic_koi8_r.tbl) | Cyrillic KOI8-R encoding (Russian Characters) |
@@ -183,14 +209,17 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | Turkish Windows | [`encodings/turkish_windows.tbl`](encodings/turkish_windows.tbl) | Turkish Windows encoding |
 | UTF-8 | [`encodings/utf8.tbl`](encodings/utf8.tbl) | UTF-8 encoding |
 | Vietnamese | [`encodings/vietnamese.tbl`](encodings/vietnamese.tbl) | Vietnamese character encoding |
+> import custom encoding from File -> Import... -> Custome Encoding File

 ### 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 |

 ### Themes
+
 | Name | Path | Description |
 |------|------|-------------|
 | Visual Studio Dark | [`themes/vs_dark.json`](themes/vs_dark.json) | Theme similar to Visual Studio's Dark theme |
--- a/encodings/big5.tbl
+++ b/encodings/big5.tbl
--- a/includes/hex/core.pat
+++ b/includes/hex/core.pat
@@ -1,12 +1,12 @@
 #pragma once

-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;

 /*!
    Core intrinsic functions to interact with the ImHex Hex Editor
 */

-namespace hex::core {
+namespace auto hex::core {

    /**
        A type representing a selection in the hex editor
@@ -21,20 +21,30 @@ namespace hex::core {
        @return The current selection
    */
    fn get_selection() {
-        u128 result = builtin::hex::core::get_selection();
+        u128 selection = builtin::hex::core::get_selection();

        Selection result;
-        if (result == u128(-1)) {
+        if (selection == u128(-1)) {
            result.valid    = false;
            result.address  = 0x00;
            result.size     = 0x00;
        } else {
            result.valid    = true;
-            result.address  = result >> 64;
-            result.size     = result & u64(-1);
+            result.address  = selection >> 64;
+            result.size     = selection & u64(-1);
        }

        return result;
    };

-}
+    /**
+        Add a file to the Virtual Filesystem
+        @param path The name of the file
+        @param pattern The pattern associated with the file
+    */
+    fn add_virtual_file(str path, auto pattern)
+    {
+        builtin::hex::core::add_virtual_file(path, pattern);
+    };
+
+}
--- a/includes/hex/dec.pat
+++ b/includes/hex/dec.pat
@@ -1,12 +1,14 @@
 #pragma once

-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
+
+import std.mem;

 /*!
    Library to allow decoding of more complex values
 */

-namespace hex::dec {
+namespace auto hex::dec {

    /**
        Demangles a mangled name into a human readable name
@@ -17,4 +19,57 @@ namespace hex::dec {
        return builtin::hex::dec::demangle(mangled_name);
    };

+
+    /**
+        Decompresses the bytes of a pattern into a section using the zlib algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @param window_size The window size passed to zlib
+        @return true if successful, false otherwise
+    */
+    fn zlib_decompress(ref auto pattern, std::mem::Section section, u64 window_size = 0) {
+        return builtin::hex::dec::zlib_decompress(pattern, section, window_size);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the bzip algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @return true if successful, false otherwise
+    */
+    fn bzip_decompress(ref auto pattern, std::mem::Section section) {
+        return builtin::hex::dec::bzip_decompress(pattern, section);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the LZMA algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @return true if successful, false otherwise
+    */
+    fn lzma_decompress(ref auto pattern, std::mem::Section section) {
+        return builtin::hex::dec::lzma_decompress(pattern, section);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the zstd algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @return true if successful, false otherwise
+    */
+    fn zstd_decompress(ref auto pattern, std::mem::Section section) {
+        return builtin::hex::dec::zstd_decompress(pattern, section);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the lz4 algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @param frame Whether the data is framed or not
+        @return true if successful, false otherwise
+    */
+    fn lz4_decompress(ref auto pattern, std::mem::Section section, bool frame = true) {
+        return builtin::hex::dec::lz4_decompress(pattern, section, frame);
+    };
+    
 }
--- a/includes/hex/http.pat
+++ b/includes/hex/http.pat
@@ -1,12 +1,12 @@
 #pragma once

-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;

 /*!
    Library to do HTTP requests
 */

-namespace hex::http {
+namespace auto hex::http {

    /**
        Performs a HTTP GET request to the given URL and returns the response body
--- a/includes/hex/provider.pat
+++ b/includes/hex/provider.pat
@@ -1,12 +1,12 @@
 #pragma once

-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;

 /*!
    Library to interact with the currently loaded provider.
 */

-namespace hex::prv {
+namespace auto hex::prv {
    
    
    /**
--- a/includes/hex/type/mangled.pat
+++ b/includes/hex/type/mangled.pat
@@ -1,30 +1,30 @@
 #pragma once

-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;

-#include <hex/impl/imhex_check.pat>
-#include <hex/dec.pat>
+import hex.impl.imhex_check;
+import hex.dec;

 /*!
    Types to automatically decode mangled names
 */

-namespace hex::type {
-	
+namespace auto hex::type {
+    
    /**
        A mangled name string that gets demangled when displayed
    */
    struct MangledName {
        char value[];
    } [[sealed, format("hex::type::impl::format_mangled_name")]];
-	
+    
    namespace impl {

        fn format_mangled_name(ref MangledName name) {
            return hex::dec::demangle(name.value);
        };
    }
-	
+    
 }

--- a/includes/std/array.pat
+++ b/includes/std/array.pat
@@ -1,13 +1,14 @@
 #pragma once

-#include <std/sys.pat>
+import std.sys;
+import std.core;

 /*!
    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 {
+namespace auto std {

    /**
        Simple one dimensional array wrapper
@@ -30,6 +31,16 @@ namespace std {
        std::assert($ - startAddress == NumBytes, "Not enough bytes available to fit a whole number of types");
    } [[format("std::impl::format_array")]];

+
+    /**
+        An interface type for getting the index of the currently processed element in an array. This is a nice wrapper around `std::core::array_index()`
+
+        To use it, inherit from it and use the `this.index` field to get the index of the current element
+    */
+    struct IIndexed {
+        const u64 index = std::core::array_index();
+    };
+
    namespace impl {

        fn format_array(ref auto array) {
--- a/includes/std/bit.pat
+++ b/includes/std/bit.pat
@@ -1,63 +1,67 @@
 #pragma once

-#include <std/limits.pat>
+import std.limits;

 /*!
-	This library contains various helper functions for common bit operations.
+    This library contains various helper functions for common bit operations.
 */

-namespace std::bit {
+namespace auto 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));
-		x = (x & (std::limits::u128_max() / 17)) + ((x >> 4) & (std::limits::u128_max() / 17));
-		
-		return x % 0xFF;
-	};
+    /**
+        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) {
+        const u128 a = 0x55555555555555555555555555555555;
+        const u128 b = 0x33333333333333333333333333333333;
+        const u128 c = 0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F;

-	/**
-		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;
-		
-		u8 i;
-		while ((1 << i) < x)
-			i = i + 1;
-		
-		return 1 << i;
-	};
+        x = (x & a) + ((x >> 1) & a);
+        x = (x & b) + ((x >> 2) & b);
+        x = (x & c) + ((x >> 4) & c);
+        
+        return x % 0xFF;
+    };

-	/**
-		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;
-		
-		u8 i;
-		while ((x >> i) > 0)
-			i = i + 1;
-		
-		return 1 << (i - 1);
-	};
+    /**
+        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;
+        
+        u8 i;
+        while ((1 << i) < x)
+            i = i + 1;
+        
+        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;
+        
+        u8 i;
+        while ((x >> i) > 0)
+            i = i + 1;
+        
+        return 1 << (i - 1);
+    };

 }
--- a/includes/std/core.pat
+++ b/includes/std/core.pat
@@ -1,13 +1,13 @@
 #pragma once

-#include <std/mem.pat>
+import std.mem;

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

-namespace std::core {
+namespace auto std::core {

    /**
        The layout order of each field after byte-endianness has been handled.
@@ -38,12 +38,20 @@ namespace std::core {
    };

    /**
-        Returns the first parameter of the attribute of a pattern if it has one
+        Returns the nth 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
+        @param [index] The parameter index of the attribute to return. Defaults to 0
+    */
+    fn get_attribute_argument(ref auto pattern, str attribute, u32 index = 0) {
+        return builtin::std::core::get_attribute_argument(pattern, attribute, index);
+    };
+
+    /**
+        @warning Removed in 1.27.0
    */
    fn get_attribute_value(ref auto pattern, str attribute) {
-        return builtin::std::core::get_attribute_value(pattern, attribute);
+        builtin::std::error("`std::core::get_attribute_value(pattern, attribute)` has been removed.\nUse `std::core::get_attribute_argument(pattern, attribute, [index])` instead.");
    };


@@ -146,4 +154,23 @@ namespace std::core {
    fn set_display_name(ref auto pattern, str name) {
        builtin::std::core::set_display_name(pattern, name);
    }; 
+
+
+    /**
+        Changes the comment attached to a pattern
+        @param pattern The pattern to modify
+        @param name The new comment of the pattern
+    */
+    fn set_pattern_comment(ref auto pattern, str comment) {
+        builtin::std::core::set_pattern_comment(pattern, name);
+    }; 
+
+    /**
+        Executes the function with the given name, passing in all given arguments
+        @param function_name The namespace-prefixed name of the function
+        @param args Arguments to pass to the function
+    */
+    fn execute_function(str function_name, auto ... args) {
+        builtin::std::core::execute_function(function_name, args);
+    };
 }
--- a/includes/std/ctype.pat
+++ b/includes/std/ctype.pat
@@ -5,7 +5,7 @@
    of ASCII characters.
 */

-namespace std::ctype {
+namespace auto std::ctype {

    /**
        Checks if the given character `c` is a digit between '0' and '9'
--- a/includes/std/file.pat
+++ b/includes/std/file.pat
@@ -1,112 +1,120 @@
 #pragma once

 /*!
-	The File library allows reading and writing from/to external files using 
-	a C-like File IO API.
+    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**
+    **These functions are considered dangerous and require the user to manually permit them**
 */

-namespace std::file {
+namespace auto std::file {

-	/**
+    /**
        A handle representing a file that has been opened
    */
-	using Handle = s32;
-	
-	/**
+    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
+        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,
-		Create = 3
-	};
+    enum Mode : u8 {
+        Read = 1,
+        Write = 2,
+        Create = 3
+    };


-	/**
+    /**
        Opens a file
-		@param path The path to the file to open
-		@param mode File open mode
-		@return Handle to the newly opened 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));
-	};
+    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
+        @param handle The handle to close
    */
-	fn close(Handle handle) {
-		builtin::std::file::close(handle);
-	};
+    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
+        @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 read(Handle handle, u64 size) {
+        return builtin::std::file::read(handle, size);
+    };

-	/**
+    /**
        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
+        @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);
-	};
+    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
+        @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);
-	};
+    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);
-	};
+    /**
+        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);
-	};
+    /**
+        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);
-	};
+    /** 
+        Flushes changes made to a file to disk
+        @param handle The handle of the file to flush
+    */
+    fn flush(Handle handle) {
+        builtin::std::file::flush(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);
-	};
+    /**
+        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);
+    };
+
+    /**
+        Create all directories for the provided path
+        @param path The path for which all directories should be created
+    */
+    fn create_directories(str path) {
+        builtin::std::file::create_directories(path);
+    };

 }
--- a/includes/std/fxpt.pat
+++ b/includes/std/fxpt.pat
@@ -1,89 +1,89 @@
 #pragma once

 /*!
-	Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
+    Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
 */

-namespace std::fxpt {
+namespace auto std::fxpt {

-	/**
-		A fixed point value
-	*/
-	using fixed = s128;
+    /**
+        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 s128((flt * (1 << precision)));
-	};
+    /**
+        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 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;
-	};
+    /**
+        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
@@ -4,11 +4,39 @@
    The hash library contains various data hash functions
 */

-namespace std::hash {
+namespace auto std::hash {
+
+    /**
+        Calculates the CRC8 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the CRC8 hash of
+        @param init The CRC8 init value
+        @param poly The CRC8 polynomial
+        @param xorout The CRC8 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 CRC8 hash 
+    */
+    fn crc8(ref auto pattern, u8 init, u8 poly, u8 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc8(pattern, init, poly, xorout, reflect_in, reflect_out);
+    };
+
+    /**
+        Calculates the CRC16 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the CRC16 hash of
+        @param init The CRC16 init value
+        @param poly The CRC16 polynomial
+        @param xorout The CRC16 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 CRC16 hash 
+    */
+    fn crc16(ref auto pattern, u16 init, u16 poly, u16 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc16(pattern, init, poly, xorout, reflect_in, reflect_out);
+    };

    /**
        Calculates the CRC32 hash of the bytes inside of a given pattern
-        @param pattern The pattern to calculate the crc32 hash of
+        @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
@@ -20,4 +48,18 @@ namespace std::hash {
        return builtin::std::hash::crc32(pattern, init, poly, xorout, reflect_in, reflect_out);
    };

+    /**
+        Calculates the CRC64 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the CRC64 hash of
+        @param init The CRC64 init value
+        @param poly The CRC64 polynomial
+        @param xorout The CRC64 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 CRC64 hash 
+    */
+    fn crc64(ref auto pattern, u64 init, u64 poly, u64 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc64(pattern, init, poly, xorout, reflect_in, reflect_out);
+    };
+
 }
--- a/includes/std/io.pat
+++ b/includes/std/io.pat
@@ -4,7 +4,7 @@
    The IO library allows formatting strings and outputting text to the console
 */

-namespace std {
+namespace auto std {

    /**
        Formats the given arguments using the format string and prints the result to the console
--- a/includes/std/limits.pat
+++ b/includes/std/limits.pat
@@ -1,169 +1,169 @@
 #pragma once

 /*!
-	Library to calculate the minimum and maximum values that fit into a given data type
+    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);
-	};
+namespace auto 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
-	*/
+    /**
+        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));
-	};
+        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));
-	};
-	
+    /**
+        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,339 +1,340 @@
 #pragma once

-#include <std/mem.pat>
+import std.mem;

 /*!
-	Library containing more advanced mathematical operations.
+    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;
-		else
-			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;
-		else
-			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;
-		else if (x > max)
-			return max;
-		else
-			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;
-		else 
-			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;
-		else if (x < 0)
-			return -1;
-		else
-			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);
-		else
-			return -std::math::abs(x);
-	};
-
-	/**
-		Calculates the factorial of `x`.
-		@param x Value
-		@return Factorial of `x`
-	*/
-	fn factorial(u128 x) {
-		u128 result;
-		
-		result = x;
-		while (x > 1) {
-			x = x - 1;
-			result = result * x;
-		}
-		
-		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;
-		else
-			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;
-		else
-			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); };
+namespace auto std::math {

    /**
-		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`
-	*/
+        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;
+        else
+            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;
+        else
+            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;
+        else if (x > max)
+            return max;
+        else
+            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;
+        else 
+            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;
+        else if (x < 0)
+            return -1;
+        else
+            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);
+        else
+            return -std::math::abs(x);
+    };
+
+    /**
+        Calculates the factorial of `x`.
+        @param x Value
+        @return Factorial of `x`
+    */
+    fn factorial(u128 x) {
+        u128 result;
+        
+        result = x;
+        while (x > 1) {
+            x = x - 1;
+            result = result * x;
+        }
+        
+        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;
+        else
+            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;
+        else
+            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 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 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 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 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 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 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 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/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 arc tangent of `value`.
+        @param y Value representing the proportion of the y-coordinate
+        @param x Value representing the proportion of the x-coordinate.
+        @return Arc tangent of `value` in radians between `-pi` and `pi`
+    */
+    fn atan2(auto y, auto x) { return builtin::std::math::atan2(y, x); };

-	/**
-		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 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 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 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 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 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); };
+    /**
+        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
-	};
+    /**
+        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));
-	};
-	
+    /**
+        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. Defaults to addition
+        @param [endian] Endianness to use. Defaults to native
+        @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
@@ -4,23 +4,20 @@
    Library for doing raw memory accesses and other low-level operations.
 */

-namespace std::mem {
+namespace auto std::mem {

    namespace impl {

        struct MagicSearchImpl<auto Magic, T> {
-            if ($ < (std::mem::base_address() + std::mem::size() - std::string::length(Magic) - 1)) {
-                char __potentialMagic__[std::string::length(Magic)] [[hidden, no_unique_address]];
-                
-                if (__potentialMagic__ == Magic) {
-                    T data [[inline]];
-                } else {
-                    padding[1];
-                    continue;
-                }
-            } else {
-                padding[1];
-                continue;
+            s128 address = builtin::std::mem::find_string_in_range(0, $, builtin::std::mem::size(), Magic);
+            if (address < 0)
+                break;
+
+            $ = address;
+            try {
+                T data [[inline]];
+            } catch {
+                T data;
            }
        };

@@ -63,7 +60,7 @@ namespace std::mem {
  

    /**
-        Gets the base address of the memory
+        Gets the base address of the data
        @return The base address of the memory
     */
    fn base_address() {
@@ -71,7 +68,7 @@ namespace std::mem {
    };

    /**
-        Gets the size of the memory
+        Gets the size of the data
        @return The size of the memory
     */
    fn size() {
@@ -79,17 +76,18 @@ namespace std::mem {
    };

    /**
-        Finds a sequence of bytes in the memory
+        Finds a sequence of bytes in the data
        @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);
+        const u128 address = builtin::std::mem::base_address();
+        return builtin::std::mem::find_sequence_in_range(occurrence_index, address, address + builtin::std::mem::size(), bytes);
    };

    /**
-        Finds a sequence of bytes in a specific region of the memory
+        Finds a sequence of bytes in a specific region of the data
        @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
@@ -100,11 +98,35 @@ namespace std::mem {
        return builtin::std::mem::find_sequence_in_range(occurrence_index, offsetFrom, offsetTo, bytes);
    };

+
+    /**
+        Finds a string in the data
+        @param occurrence_index The index of the occurrence to find
+        @param string The string to find
+        @return The address of the sequence
+    */
+    fn find_string(u128 occurrence_index, str string) {
+        const u128 address = builtin::std::mem::base_address();
+        return builtin::std::mem::find_string_in_range(occurrence_index, address, address + builtin::std::mem::size(), string);
+    };
+
+    /**
+        Finds a string in a specific region of the data
+        @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 string The string to find
+        @return The address of the sequence
+    */
+    fn find_string_in_range(u128 occurrence_index, u128 offsetFrom, u128 offsetTo, str string) {
+        return builtin::std::mem::find_string_in_range(occurrence_index, offsetFrom, offsetTo, string);
+    };
+
    /**
        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
+        @param [endian] The endianess of the value to read. Defaults to native
        @return The value read
    */
    fn read_unsigned(u128 address, u8 size, Endian endian = Endian::Native) {
@@ -115,7 +137,7 @@ namespace std::mem {
        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
+        @param [endian] The endianess of the value to read. Defaults to native
        @return The value read
    */
    fn read_signed(u128 address, u8 size, Endian endian = Endian::Native) {
@@ -128,18 +150,10 @@ namespace std::mem {
        @param size The size of the value to read
        @return The value read
    */
-    fn read_string(u128 address, u8 size) {
+    fn read_string(u128 address, u128 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
@@ -180,6 +194,15 @@ namespace std::mem {
        return builtin::std::mem::get_section_size(section);
    };

+    /**
+        Changes the size of a custom section
+        @param section The handle to the section
+        @param size The new size of the section
+    */
+    fn set_section_size(Section section, u128 size) {
+        builtin::std::mem::set_section_size(section, size);
+    };
+
    /**
        Copies a range of bytes from one section into another
        @param from_section The section to copy from
@@ -202,6 +225,14 @@ namespace std::mem {
        builtin::std::mem::copy_value_to_section(value, to_section, to_address);
    };

+    /**
+        Returns the current bit offset when inside of a bitfield.
+        @return The current bit offset between 0 and 7
+    */
+    fn current_bit_offset() {
+        return builtin::std::mem::current_bit_offset();
+    };
+

    /**
        Searches for a sequence of bytes and places the given type at that address
--- a/includes/std/ptr.pat
+++ b/includes/std/ptr.pat
@@ -1,13 +1,13 @@
 #pragma once

-#include <std/mem.pat>
+import std.mem;

 /*!
    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 {
+namespace auto std::ptr {

    /**
        Use the offset of the current pointer as start address
--- a/includes/std/random.pat
+++ b/includes/std/random.pat
@@ -1,12 +1,12 @@
 #pragma once

-#include <std/limits.pat>
+import std.limits;

 /*!
  Library to generate random numbers. Supports various different distribution types.
 */

-namespace std::random {
+namespace auto std::random {
  
    /**
        Represents the type of distribution to use to generate a random number
@@ -61,8 +61,8 @@ namespace std::random {
        > - `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.
+        @param [param1] This parameter depends on the type of distribution used. Defaults to 0
+        @param [param2] This parameter depends on the type of distribution used. Defaults to 0
    */
    fn generate_using(Distribution distribution, auto param1 = 0, auto param2 = 0) {
        return builtin::std::random::generate(u32(distribution), param1, param2);
@@ -71,8 +71,8 @@ namespace std::random {
    
    /**
        Generates a uniformly distributed random number between `min` and `max`
-        @param min Minimum number
-        @param max Maximum number
+        @param [min] Minimum number. Defaults to 0
+        @param [max] Maximum number. Defaults to `u64_max`
    */
    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
@@ -1,129 +1,149 @@
 #pragma once

-#include <std/io.pat>
+import std.io;
+import std.mem;

 /*!
-	Libray to interact with strings.
+    Libray to interact with strings.
 */

-namespace std::string {
+namespace auto 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")]];
+    /**
+        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_string"), transform("std::string::impl::format_string")]];

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

-	namespace impl {
+    /**
+        Base type for null-terminated strings. Represents a string with its size determined by the first 0x00 byte found.
+        @tparam DataType The type of the characters.
+    */
+    struct NullStringBase<DataType> {
+        DataType string[while(std::mem::read_unsigned($, sizeof(DataType)) != 0x00)];
+        DataType null_terminator;
+    } [[sealed, format("std::string::impl::format_string"), transform("std::string::impl::format_string")]];

-		fn format_sized_string(ref auto string) {
-			return string.data;
-		};
+    /**
+        A null-terminated ASCII string.
+    */
+    using NullString = NullStringBase<char>;

-	}
+    /**
+        A null-terminated UTF-16 string.
+    */
+    using NullString16 = NullStringBase<char16>;

-	/**
-		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);
-	};
+    namespace impl {

-	/**
-		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);
-	};
+        fn format_string(ref auto string) {
+            return string.data;
+        };

-	/**
-		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);
-	};
+    }
+
+    /**
+        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 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 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.
-	*/
+    /**
+        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.
-	*/
+    /**
+        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.
-	*/
+    /**
+        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;
    };

-	/**
-		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.
-	*/
+    /**
+        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);
@@ -136,12 +156,12 @@ namespace std::string {
        return false;
    };

-	/**
-		Reverses a string.
-		@param string The string to reverse.
-		@return The reversed string.
-	*/
-    fn reverse(str string) {	
+    /**
+        Reverses a string.
+        @param string The string to reverse.
+        @return The reversed string.
+    */
+    fn reverse(str string) {    
        str result;
        
        s32 i;
@@ -154,86 +174,82 @@ namespace std::string {
        return result;
    };

-	/**
-		Converts a string to upper case.
-		@param string The string to convert.
-		@return The converted string.
-	*/
+    /**
+        Converts a string to upper case.
+        @param string The string to convert.
+        @return The converted string.
+    */
    fn to_upper(str string) {
-		str result;
-		
-		u32 i;
-		char c;
-		while (i < std::string::length(string)) {
-			c = std::string::at(string, i);
-			
-			if (c >= 'a' && c <= 'z')
-				result = result + char(c - 0x20);
-			else
-				result = result + c;
-			
-			i = i + 1;
-		}
-		
-		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;
-		
-		u32 i;
-		char c;
-		while (i < std::string::length(string)) {
-			c = std::string::at(string, i);
-			
-			if (c >= 'A' && c <= 'Z')
-				result = result + char(c + 0x20);
-			else
-				result = result + c;
-			
-			i = i + 1;
-		}
-		
-		return result;
-	};
+        str result;
+        
+        u32 i;
+        char c;
+        while (i < std::string::length(string)) {
+            c = std::string::at(string, i);
+            
+            if (c >= 'a' && c <= 'z')
+                result = result + char(c - 0x20);
+            else
+                result = result + c;
+            
+            i = i + 1;
+        }
+        
+        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;
+        
+        u32 i;
+        char c;
+        while (i < std::string::length(string)) {
+            c = std::string::at(string, i);
+            
+            if (c >= 'A' && c <= 'Z')
+                result = result + char(c + 0x20);
+            else
+                result = result + c;
+            
+            i = i + 1;
+        }
+        
+        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.
-	*/
+    /**
+        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);
-		pattern_len = std::string::length(pattern);
-		replace_len = std::string::length(replace);
-		
-		if (pattern_len > string_len)
-			return string;
-			
-		str result;
-		u32 i;
-		while (i <= (string_len - pattern_len)) {
-			
-			if (std::string::substr(string, i, pattern_len) == pattern) {
-				result = result + replace;
-				i = i + pattern_len;
-			} else {
-				result = result + std::string::at(string, i);
-				i = i + 1;
-			}
-		}
-		result = result + std::string::substr(string,string_len-pattern_len+1,pattern_len);
-		
-		return result;
-	};
+        s32 string_len  = std::string::length(string);
+        s32 pattern_len = std::string::length(pattern);

+        if (pattern_len > string_len || pattern_len * string_len == 0 )
+             return string;

+        str result;
+        s32 string_index;
+        s32 remaining_len = string_len;
+        while (pattern_len <= remaining_len) {
+            if (std::string::substr(string, string_index, pattern_len) == pattern) {
+                 result += replace;
+                string_index += pattern_len;
+             } else {
+                result += std::string::at(string, string_index);
+                  string_index += 1;
+            }
+            remaining_len = string_len - string_index;
+        }
+        result += std::string::substr(string, string_index, remaining_len );
+        return result;
+    };
 }
--- a/includes/std/sys.pat
+++ b/includes/std/sys.pat
@@ -1,16 +1,16 @@
 #pragma once

-#include <std/io.pat>
+import std.io;

 /*!
    Basic helper functions
 */

-namespace std {
+namespace auto 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 condition 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) {
@@ -21,7 +21,7 @@ namespace std {

    /**
        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 condition 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) {
@@ -49,4 +49,11 @@ namespace std {
        return builtin::std::sizeof_pack(pack);
    };

+    /**
+        Throws an error notifying the developer that the current codepath is not implemented currently.
+    */
+    fn unimplemented() {
+        std::error("Unimplemented code path reached!");
+    };
+
 }
--- a/includes/std/time.pat
+++ b/includes/std/time.pat
@@ -1,191 +1,200 @@
 #pragma once

-#include <std/io.pat>
+import std.io;

 /*!
-	Library to handle time and date related operations.
+    Library to handle time and date related operations.
 */

-namespace std::time {
+namespace auto std::time {

-	/**
-		A structured representation of a time and date.
-	*/
-	struct Time {
-		u8 sec;
-		u8 min;
-		u8 hour;
-		u8 mday;
-		u8 mon;
-		u16 year;
-		u8 wday;
-		u16 yday;
-		bool isdst;
-	} [[sealed]];
+    /**
+        A structured representation of a time and date.
+    */
+    struct Time {
+        u8 sec;
+        u8 min;
+        u8 hour;
+        u8 mday;
+        u8 mon;
+        u16 year;
+        u8 wday;
+        u16 yday;
+        bool isdst;
+    } [[sealed]];

-	/**
-		A helper type to convert between Time and u128.
-	*/
-	union TimeConverter {
-		Time time;
-		u128 value;
-	};
+    /**
+        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 in seconds since the epoch.
+    */
+    using EpochTime = u32;

-	/**
-		A type to represent a time zone.
-	*/
-	enum TimeZone : u8 {
-		Local,
-		UTC
-	};
+    /**
+        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 date.
+    */
+    bitfield DOSDate {
+        day: 5;
+        month: 4;
+        year: 7;
+    } [[sealed]];

-	/**
-		A type to represent a DOS time.
-	*/
-	bitfield DOSTime {
-		seconds: 5;
-		minutes: 6;
-		hours: 5;
-	} [[sealed]];
+    /**
+        A type to represent a DOS time.
+    */
+    bitfield DOSTime {
+        seconds: 5;
+        minutes: 6;
+        hours: 5;
+    } [[sealed]];

-	namespace impl {
+    namespace impl {

-		union DOSDateConverter {
-			DOSDate date;
-			u16 value;
-		};
+        union DOSDateConverter {
+            DOSDate date;
+            u16 value;
+        };

-		union DOSTimeConverter {
-			DOSTime time;
-			u16 value;
-		};
+        union DOSTimeConverter {
+            DOSTime time;
+            u16 value;
+        };

-	}
+    }


-	/**
-		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();
-	};
+    /**
+        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;
+    /**
+        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) {
+        le TimeConverter converter;

-		converter.value = builtin::std::time::to_local(epoch_time);
+        converter.value = builtin::std::time::to_local(epoch_time);

-		return converter.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;
+    /**
+        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) {
+        le TimeConverter converter;

-		converter.value = builtin::std::time::to_utc(epoch_time);
+        converter.value = builtin::std::time::to_utc(epoch_time);

-		return converter.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;
+    /**
+        Queries the current time in the specified time zone.
+        @param [time_zone] The time zone to query. Defaults to local.
+        @return The current time in the specified time zone.
+    */
+    fn now(TimeZone time_zone = TimeZone::Local) {
+        le TimeConverter converter;

-		if (time_zone == TimeZone::Local)
-			converter.value = builtin::std::time::to_local(std::time::epoch());
-		else if (time_zone == TimeZone::UTC)
-			converter.value = builtin::std::time::to_utc(std::time::epoch());
-		else
-			converter.value = 0x00;
+        if (time_zone == TimeZone::Local)
+            converter.value = builtin::std::time::to_local(std::time::epoch());
+        else if (time_zone == TimeZone::UTC)
+            converter.value = builtin::std::time::to_utc(std::time::epoch());
+        else
+            converter.value = 0x00;

-		return converter.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;
+    /**
+        Converts a value to a DOS date.
+        @param value The value to convert.
+        @return The DOS date.
+    */
+    fn to_dos_date(u16 value) {
+        le impl::DOSDateConverter converter;

-		converter.value = value;
+        converter.value = value;

-		return converter.date;
-	};
+        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;
+    /**
+        Converts a value to a DOS time.
+        @param value The value to convert.
+        @return The DOS time.
+    */
+    fn to_dos_time(u16 value) {
+        le impl::DOSTimeConverter converter;

-		converter.value = value;
+        converter.value = value;

-		return converter.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;
+    /**
+        Converts a FILETIME to unix time.
+        @param value The value to convert.
+        @return Timestamp formatted as unix time.
+    */
+    fn filetime_to_unix(u64 value) {
+        return value / 10000000 - 11644473600;
+    };

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

-	/**
-		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);
-	};
+        return builtin::std::time::format(format_string, converter.value);
+    };

-	/**
-		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);
-	};
+    /**
+        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. Defaults to "{}/{}/{}".
+        @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. Defaults to "{:02}:{:02}:{:02}".
+        @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
@@ -1,14 +1,14 @@
 #pragma once

-#include <std/io.pat>
-#include <std/math.pat>
+import std.io;
+import std.math;

 /*!
    Types used to change the base of the displayed integer value.
    Used like `type::Hex<u32> hexNumber;`, `type::Oct<u16> octalNumber;`
 */

-namespace type {
+namespace auto type {
    
    /**
        Integer type representing a Hexadecimal value. Displays its value in hexadecimal format.
@@ -34,7 +34,7 @@ namespace type {
    */
    using Bin<T> = T [[format("type::impl::format_bin")]];

-	namespace impl {
+    namespace impl {

            fn format_number(auto value, str fmt) {
                bool negative = value < 0;
@@ -50,6 +50,6 @@ namespace type {
            fn format_dec(auto value) { return type::impl::format_number(value, "{}"); };
            fn format_bin(auto value) { return type::impl::format_number(value, "0b{:08b}"); };

-	}
+    }

 }
--- a/includes/type/base64.pat
+++ b/includes/type/base64.pat
@@ -1,12 +1,12 @@
-#include <std/io.pat>
-#include <std/string.pat>
-#include <std/mem.pat>
+import std.io;
+import std.string;
+import std.mem;

 /*!
    Type representing a Base64 encoded string
 */

-namespace type {
+namespace auto type {

    /**
        Type representing a Base64 encoded string
--- a/includes/type/bcd.pat
+++ b/includes/type/bcd.pat
@@ -1,12 +1,12 @@
 #pragma once

-#include <std/io.pat>
+import std.io;

 /*!
    Type to decode a BCD (Binary Coded Decimal) number
 */

-namespace type {
+namespace auto type {

    /**
        Decodes a BCD value where one byte represents a single digit
--- a/includes/type/byte.pat
+++ b/includes/type/byte.pat
@@ -1,12 +1,13 @@
 #pragma once

-#include <std/io.pat>
+import std.io;
+import std.core;

 /*!
    Types to display single bytes using various different representations
 */

-namespace type {
+namespace auto type {
    
    /**
        Type visualizing the value of each individual bit
@@ -20,7 +21,7 @@ namespace type {
        bit5 : 1;
        bit6 : 1;
        bit7 : 1;
-    } [[format("type::impl::format_bits"), right_to_left]];
+    } [[format("type::impl::format_bits"), bitfield_order(std::core::BitfieldOrder::LeastToMostSignificant, 8)]];
    
    /**
        Type visualizing the value of the two nibbles
@@ -40,7 +41,7 @@ namespace type {
    } [[format("type::impl::format_byte"), single_color]];


-	namespace impl {
+    namespace impl {

        fn format_byte(Byte byte) {
            return std::format("0x{0:02X} (0b{1:08b}) LSB:{2}, MSB:{3}",
@@ -66,6 +67,6 @@ namespace type {
            return std::format("{{ {0:0X}, {1:0X} }}", nibbles.high, nibbles.low);
        };

-	}
+    }

 }
--- a/includes/type/color.pat
+++ b/includes/type/color.pat
@@ -1,13 +1,13 @@
 #pragma once

-#include <std/io.pat>
-#include <std/core.pat>
+import std.io;
+import std.core;

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

-namespace type {
+namespace auto type {

    /**
        Type representing a generic RGBA color with a variable number of bits for each color
--- a/includes/type/float16.pat
+++ b/includes/type/float16.pat
@@ -1,14 +1,14 @@
 #pragma once

-#include <std/io.pat>
-#include <std/math.pat>
-#include <std/mem.pat>
+import std.io;
+import std.math;
+import std.mem;

 /*!
    Type representing a 16 bit half precision floating point number
 */

-namespace type {
+namespace auto type {
    
    /**
        Type representing a 16 bit half precision floating point number
@@ -22,7 +22,7 @@ namespace type {
            float floatValue;
        };

-        fn format_float16(float16 value) {	
+        fn format_float16(float16 value) {
            u32 sign = value >> 15;
            u32 exponent = (value >> 10) & 0x1F;
            u32 mantissa = value & 0x3FF;
--- a/includes/type/fmt.pat
+++ b/includes/type/fmt.pat
@@ -0,0 +1,42 @@
+#pragma once
+
+import std.io;
+
+/*!
+    Type that allows specifying its format value using a format string.
+    ## Usage
+
+    The following code reads a u32 from the data and formats it as an upper case hexadecimal value with
+    a minimum of 8 digits which is prefixed by 0x.
+
+    The format string is the same as passed to `std::format()` and follows the libfmt specification.
+
+    ```rust
+        type::Formatted<u32, "0x{:08X}"> hex_formatted_integer @ 0x00;
+    ```
+*/
+
+namespace auto type {
+
+    /**
+        Arbitrarily formatted type
+        @tparam T Type to format
+        @tparam FormatString libfmt format string to format the value
+    */
+    struct Formatted<T, auto FormatString> {
+        T value;
+    } [[sealed, format("type::impl::format_formatted"), transform("type::impl::transform_formatted")]];
+
+    namespace impl {
+
+        fn format_formatted(ref auto formatted) {
+            return std::format(std::format("{{0:{}}}", formatted.FormatString), formatted.value);
+        };
+
+        fn transform_formatted(ref auto formatted) {
+            return formatted.value;
+        };
+
+    }
+
+}
--- a/includes/type/guid.pat
+++ b/includes/type/guid.pat
@@ -1,17 +1,17 @@
 #pragma once

-#include <std/io.pat>
+import std.io;

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

-namespace type {
+namespace auto type {

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

-	/**
-		Alias name for GUID
-	*/
-	using UUID = GUID;
+    /**
+        Alias name for GUID
+    */
+    using UUID = GUID;

-	namespace impl {
+    namespace impl {

-		fn format_guid(GUID guid) {
-	        bool valid = ((le u16(guid.time_high_and_version) >> 12) <= 5) && (((guid.clock_seq_and_reserved >> 4) >= 8) || ((guid.clock_seq_and_reserved >> 4) == 0));
-	
-	        return std::format("{}{{{:08X}-{:04X}-{:04X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}",
-	            valid ? "" : "Invalid ",
-	            le u32(guid.time_low),
-	            le u16(guid.time_mid),
-	            le u16(guid.time_high_and_version),
-	            guid.clock_seq_and_reserved,
-	            guid.clock_seq_low,
-	            guid.node[0],
-	            guid.node[1],
-	            guid.node[2],
-	            guid.node[3],
-	            guid.node[4],
-	            guid.node[5]);
-	    };
+        fn format_guid(GUID guid) {
+            bool valid = ((le u16(guid.time_high_and_version) >> 12) <= 5) && (((guid.clock_seq_and_reserved >> 4) >= 8) || ((guid.clock_seq_and_reserved >> 4) == 0));
+    
+            return std::format("{}{{{:08X}-{:04X}-{:04X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}",
+                valid ? "" : "Invalid ",
+                le u32(guid.time_low),
+                le u16(guid.time_mid),
+                le u16(guid.time_high_and_version),
+                guid.clock_seq_and_reserved,
+                guid.clock_seq_low,
+                guid.node[0],
+                guid.node[1],
+                guid.node[2],
+                guid.node[3],
+                guid.node[4],
+                guid.node[5]);
+        };

-	}
+    }

 }
--- a/includes/type/ip.pat
+++ b/includes/type/ip.pat
@@ -1,13 +1,13 @@
 #pragma once

-#include <std/io.pat>
-#include <std/string.pat>
+import std.io;
+import std.string;

 /*!
    Types used to decode IP addresses
 */

-namespace type {
+namespace auto type {

    /**
        A 4 byte IPv4 Address as described in RFC 791
--- a/includes/type/leb128.pat
+++ b/includes/type/leb128.pat
@@ -1,72 +1,72 @@
 #pragma once

-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;

 /*!
-	Types used to decode Little Endian Base 128 numbers used to store large numbers as space efficiently as possible
+    Types used to decode Little Endian Base 128 numbers used to store large numbers as space efficiently as possible
 */

-namespace type {
-	
-	/**
-		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]];
+namespace auto type {
+    
+    /**
+        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]];

-	/**
-		A unsigned variant of a LEB128 number
-	*/
-	using uLEB128 = LEB128Base [[format("type::impl::format_uleb128"), transform("type::impl::transform_uleb128")]];
+    /**
+        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")]];
+    /**
+        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_uleb128_array(ref auto array) {
-			u128 res = array[0] & 0x7f;
-			for(u8 i = 1, array[i-1] & 0x80 != 0, i+=1) {
-				res |= u128(array[i] & 0x7f) << 7 * i;
-			}
-			return res;
-		};
+    /**
+        Legacy alias for uLEB128
+    */
+    using LEB128 = uLEB128;
+    
+    namespace impl {
+    
+        fn transform_uleb128_array(ref auto array) {
+            u128 res = array[0] & 0x7f;
+            for(u8 i = 1, array[i-1] & 0x80 != 0, i+=1) {
+                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_uleb128(ref auto leb128) {
-			u128 res = type::impl::transform_uleb128_array(leb128.array);
-			return std::format("{} ({:#x})", res, res);
-		};
-	
-		fn transform_uleb128(ref auto leb128) {
-			return type::impl::transform_uleb128_array(leb128.array);
-		};
+        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_uleb128(ref auto leb128) {
+            u128 res = type::impl::transform_uleb128_array(leb128.array);
+            return std::format("{} ({:#x})", res, res);
+        };
+    
+        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);
-		};
+        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
@@ -1,32 +1,32 @@
 #pragma once

-#include <std/io.pat>
+import std.io;

 /*!
-	Types used to decode MAC Addresses
+    Types used to decode MAC Addresses
 */

-namespace type {
+namespace auto type {

-	/**
-		A MAC Address as used in the Internet Protocol
-	*/
-	struct MACAddress {
-		u8 bytes[6];
-	} [[sealed, format("type::impl::format_mac_address")]];
+    /**
+        A MAC Address as used in the Internet Protocol
+    */
+    struct MACAddress {
+        u8 bytes[6];
+    } [[sealed, format("type::impl::format_mac_address")]];

-	namespace impl {
+    namespace impl {

        fn format_mac_address(MACAddress address) {
-			return std::format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
-				address.bytes[0],
-				address.bytes[1],
-				address.bytes[2],
-				address.bytes[3],
-				address.bytes[4],
-				address.bytes[5]);
-		};
+            return std::format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
+                address.bytes[0],
+                address.bytes[1],
+                address.bytes[2],
+                address.bytes[3],
+                address.bytes[4],
+                address.bytes[5]);
+        };

-	}
+    }

 }
--- a/includes/type/magic.pat
+++ b/includes/type/magic.pat
@@ -1,38 +1,43 @@
-#include <std/string.pat>
-#include <std/sys.pat>
-#include <std/io.pat>
-#include <std/ctype.pat>
+import std.string;
+import std.sys;
+import std.io;
+import std.ctype;

 /*!
    Types used to parse and enforce specific magic numbers
 */

-namespace type {
+namespace auto type
+{
+    fn fm(ref auto value)
+    {
+        str result;
+        for (u32 i = 0, i < sizeof(value), i += 1)
+        {
+            char c = value[i];
+
+            if (std::ctype::isprint(c))
+                result += c;
+            else
+                result += std::format("\\x{:02X}", u8(c));
+        }
+        return std::format("\"{}\"", result);
+    };

    /**
        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> {
+    struct Magic<auto ExpectedValue>
+    {
        char value[std::string::length(ExpectedValue)];
-        std::assert(value == ExpectedValue, std::format("Invalid magic value! Expected \"{}\", got \"{}\".", ExpectedValue, value));
+        std::assert_warn(value == ExpectedValue, std::format("Invalid magic value! Expected {}, got {} at position 0x{:X}", type::fm(ExpectedValue), type::fm(value), $ - std::string::length(ExpectedValue)));
    } [[sealed, format("type::impl::format_magic")]];
-    
-    namespace impl {
-    
-        fn format_magic(ref auto magic) {
-            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);
+    namespace impl
+    {
+        fn format_magic(ref auto magic)
+        {
+            return type::fm(magic.value);
        };
-        
    }
-
 }
--- a/includes/type/path.pat
+++ b/includes/type/path.pat
@@ -1,53 +1,53 @@
-#include <std/mem.pat>
+import std.mem;

 /*!
-	Types dealing with various kinds of resource paths
+    Types dealing with various kinds of resource paths
 */

-namespace type {
+namespace auto type {

-	/**
-		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_path_segment")]];
-	
-	/**
-		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<"/">;
+    /**
+        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_path_segment")]];
+    
+    /**
+        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_path_segment(ref auto segment) {
-			return segment.string;
-		};
-	
-		fn format_path(ref auto path) {
-			return std::mem::read_string($, sizeof(path));
-		};
-	
-	}
+    /**
+        A type representing a DOS path using a '\\' backslash as delimeter
+    */
+    using DOSPath = Path<"\\">;
+
+    namespace impl {
+
+        fn format_path_segment(ref auto segment) {
+            return segment.string;
+        };
+    
+        fn format_path(ref auto path) {
+            return std::mem::read_string($, sizeof(path));
+        };
+    
+    }

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

 /*!
    Types used to pretty print size values
 */

-namespace type {
+namespace auto type {

    /**
        A generic size type which displays its value in Bytes (or kiB, MiB, GiB, TiB, PiB, EiB if larger)
--- a/includes/type/time.pat
+++ b/includes/type/time.pat
@@ -1,13 +1,13 @@
 #pragma once

-#include <std/io.pat>
-#include <std/time.pat>
+import std.io;
+import std.time;

 /*!
    Types used to decode various different time formats
 */

-namespace type {
+namespace auto type {

    /**
        A 32 bit Unix time value
@@ -34,6 +34,11 @@ namespace type {
    */
    using DOSTime = u16 [[format("type::impl::format_dostime")]];

+    /**
+        A 64bit FILETIME value
+    */
+    using FILETIME = u64 [[format("type::impl::format_filetime_as_unix")]];
+
    namespace impl {

        fn format_time_t(u128 value) {
@@ -48,6 +53,10 @@ namespace type {
            return std::time::format_dos_time(std::time::to_dos_time(value));
        };

+        fn format_filetime_as_unix(u64 value) {
+            return std::time::filetime_to_unix(value);
+        };
+
    }

 }
--- a/includes/type/types/010.pat
+++ b/includes/type/types/010.pat
@@ -5,7 +5,7 @@
 */

 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {

    // using char   = s8;
    using byte      = s8;
--- a/includes/type/types/c.pat
+++ b/includes/type/types/c.pat
@@ -5,7 +5,7 @@
 */

 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {

    using uint8_t       = u8;
    using uint16_t      = u16;
--- a/includes/type/types/linux.pat
+++ b/includes/type/types/linux.pat
@@ -5,7 +5,7 @@
 */

 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {

    using le16  = le u16;
    using be16  = be u16;
--- a/includes/type/types/rust.pat
+++ b/includes/type/types/rust.pat
@@ -5,7 +5,7 @@
 */

 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {

    // using u8        = u8;
    // using u16       = u16;
--- a/includes/type/types/win32.pat
+++ b/includes/type/types/win32.pat
@@ -5,7 +5,7 @@
 */

 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {

    using BYTE      = u8;
    using WORD      = u16;
--- a/patterns/3ds.hexpat
+++ b/patterns/3ds.hexpat
@@ -1,8 +1,8 @@
 #pragma author WerWolv
 #pragma description Autodesk 3DS Max Model file

-#include <std/io.pat>
-#include <type/base.pat>
+import std.io;
+import type.base;

 #pragma MIME image/x-3ds

--- a/patterns/7z.hexpat
+++ b/patterns/7z.hexpat
@@ -1,8 +1,9 @@
 #pragma description 7z File Format
+#pragma MIME application/x-7z-compressed

-#include <std/io.pat> 
-#include <std/mem.pat> 
-#include <std/math.pat> 
+import std.io; 
+import std.mem; 
+import std.math; 


 enum Type:u8{ 
--- a/patterns/Crashlvl.hexpat
+++ b/patterns/Crashlvl.hexpat
@@ -1,20 +1,27 @@
-#pragma description Crash Bandicoot - Back in Time (fan game) User created flashback tapes level format
+#pragma author AdventureT
+#pragma description Crash Bandicoot - Back in Time (fan game) User created level format
+#pragma history
+#pragma   0.3  2024-05-15 Added support for version 0.95
+#pragma   0.2  2023-10-29 Added support for version 0.94c
+#pragma   0.1  2023-04-25 Initial support
+// Supports all versions till 0.95, newer versions might be compatible!

-#include <type/magic.pat>
-#include <std/string.pat>
-#include <std/array.pat>
-
-// Crash Bandicoot - Back in Time (fan game) user created tapes
-// author AdventureT
+import type.magic;
+import std.string;
+import std.array;

 struct Header {
    type::Magic<"CRASHLVL"> magic;
    u8 version;
+    if (version >= 4) {
+        std::string::SizedString<u8> gameVersion;
+    }
    std::string::SizedString<u8> levelName;
    std::string::SizedString<u8> author;
 };

-enum Music : u32 {
+// Background Music
+enum BGM : u32 {
    None,
    BonusBGM,
    CrashCreatorBGM,
@@ -30,39 +37,327 @@ enum Music : u32 {
    NBrioBGM
 };

+enum BGMV2 : u32 {
+    None,
+    N_TropyBGM,
+    CrashCreatorBGM,
+    MainMenuBGM,
+    WarpRoomBGM,
+    Jungle01BGM,
+    SnowBGM,
+    RiverBGM,
+    FutureBGM,
+    LabBGM,
+    SewerBGM,
+    EgyptBGM,
+    NBrioBGM,
+    AdventureBGM,
+    SpyBGM,
+    ChaseBGM,
+    TrialsBGM,
+    SpaceBGM,
+    Jungle02BGM,
+    RipperBGM,
+    TheGreatWallBGM,
+    RoadToSomewhereBGM,
+    LavaKoalaBGM,
+    CortexBGM,
+    CyberCortexBGM,
+    ArabicBGM,
+    N_Tropy2BGM,
+    JazzBGM,
+    Space2BGM,
+    TawnaBonusBGM,
+    CortexPowerBGM,
+    ArabicBonusBGM,
+    EgyptBonusBGM,
+    FutureBonusBGM,
+    LostCityBGM,
+    PolarBGM,
+    RiverBonusBGM,
+    RuinsBonusBGM,
+    SewerBonusBGM,
+    SnowBonusBGM,
+    RoadToRuinBGM,
+    NGinBGM,
+    Arabia01BGM,
+    Arabia02BGM,
+    BashBGM,
+    Cortex02BGM
+};
+
+// v0.95
+enum BGMV3 : BGMV2 {
+    None,
+    N_TropyBGM,
+    CrashCreatorBGM,
+    MainMenuBGM,
+    WarpRoomBGM,
+    Jungle01BGM,
+    SnowBGM,
+    RiverBGM,
+    FutureBGM,
+    LabBGM,
+    SewerBGM,
+    EgyptBGM,
+    NBrioBGM,
+    AdventureBGM,
+    SpyBGM,
+    ChaseBGM,
+    TrialsBGM,
+    SpaceBGM,
+    Jungle02BGM,
+    RipperBGM,
+    TheGreatWallBGM,
+    RoadToSomewhereBGM,
+    LavaKoalaBGM,
+    CortexBGM,
+    CyberCortexBGM,
+    ArabicBGM,
+    N_Tropy2BGM,
+    JazzBGM,
+    Space2BGM,
+    TawnaBonusBGM,
+    CortexPowerBGM,
+    ArabicBonusBGM,
+    EgyptBonusBGM,
+    FutureBonusBGM,
+    LostCityBGM,
+    PolarBGM,
+    RiverBonusBGM,
+    RuinsBonusBGM,
+    SewerBonusBGM,
+    SnowBonusBGM,
+    RoadToRuinBGM,
+    NGinBGM,
+    Arabia01BGM,
+    Arabia02BGM,
+    BashBGM,
+    Cortex02BGM,
+    MedievalBGM,
+    PreHistoricBGM,
+    UnderWaterBGM,
+    BrioRevisitedBGM,
+    EgyptChaseBGM,
+    RuinsLoopBGM,
+    DingoSynthBGM
+};
+
 enum Type : u32 {
    Unset,
    Flashback,
    Trial
 };

-enum Time : u32 {
+enum TypeV2 : u32 {
+    Practice,
+    Flashback,
+    Trial,
+    Adventure
+};
+
+enum Skybox : u32 {
    Night,
    Day,
    Storm,
    Dawn
 };

-enum Terrain : u32 {
+enum SkyboxV2 : u32 {
+    Default = 1,
+    Briolab,
+    Fort,
+    Moon,
+    Toxic,
+    AboutRight,
+    Crash1Island,
+    Arabia,
+    RoadToRuin,
+    Black
+};
+
+// 0.95
+enum SkyboxV3 : u32 {
+    Default = 1,
+    Briolab,
+    Fort,
+    Moon,
+    Toxic,
+    AboutRight,
+    Crash1Island,
+    Arabia,
+    RoadToRuin,
+    MotorcycleDay,
+    MotorcycleNoon,
+    MotorcycleMoon,
+    MotorcycleNight,
+    Black
+};
+
+enum Scenery : u32 {
    None,
-    Machines,
-    Trees,
+    FutureTense,
+    Forest,
+    Waterfall,
+    Snow,
+    Fortress
+};
+
+enum SceneryV2 : u32 {
+    None,
+    FutureTense,
+    Forest,
+    Waterfall,
+    None2,
+    Fortress,
+    None3,
+    Lava,
+    TheGreatGate,
+    Mountain,
+    KoalaKong,
+    SunsetVista,
+    HangemHigh,
+    Sphynxinator,
+    Tunnel,
+    Pipes
+};
+
+enum SceneryV4 : u32 {
+    None,
+    FutureTense,
+    Forest,
    Waterfall,
    Snow,
    Fortress,
+    None2,
+    Lava,
+    TheGreatGate,
+    Mountain,
+    KoalaKong,
+    SunsetVista,
+    HangemHigh,
+    Sphynxinator,
+    Tunnel,
+    Pipes
 };

+// 0.95
+enum SceneryV5 : u32 {
+    None,
+    FutureTense,
+    Forest,
+    Waterfall,
+    Snow,
+    Fortress,
+    None2,
+    Lava,
+    TheGreatGate,
+    Mountain,
+    KoalaKong,
+    SunsetVista,
+    HangemHigh,
+    Sphynxinator,
+    Tunnel,
+    Pipes,
+    Medieval,
+    FutureCity,
+    TinyArena,
+    HeavyMachinery,
+    CrystalCave,
+    MedievalWithHouses,
+    CortexBonusChamber
+};
+
+enum Weather : u32 {
+    Default,
+    Snow,
+    Rain
+};
+
+// 0.95
+enum WeatherV2 : u32 {
+    Default,
+    Snow,
+    Rain,
+    Night,
+    UnderWater
+};
+
+
 struct Options {
-    Type type;
-    Time time;
-    Terrain terrain;
-    Music music;
+    // Type
+    if (header.version > 1) {
+        TypeV2 type;
+    }
+    else {
+        Type type;
+    }
+    // Skybox
+    if (header.version > 1) {
+        if (header.gameVersion == "0.95") {
+            SkyboxV3 skybox;
+        }
+        else {
+            SkyboxV2 skybox;
+        }
+    }
+    else {
+        Skybox skybox;
+    }
+    // Scenery
+    if (header.version == 1) {
+        Scenery scenery;
+    }
+    else if (header.version > 1 && header.version < 4) {
+        SceneryV2 scenery;
+    }
+    else {
+        if (header.gameVersion == "0.95") {
+            SceneryV5 skybox;
+        }
+        else {
+            SceneryV4 skybox;
+        }
+    }
+    // Weather
+    if (header.version > 2) {
+        if (header.gameVersion == "0.95") {
+            WeatherV2 weather;
+        }
+        else {
+            Weather weather;
+        }
+    }
+    // Background music
+    if (header.version > 1) {
+        BGMV2 bgm;
+    }
+    else {
+        BGM bgm;
+    }
+    // Time Trial
+    if (type == Type::Trial) {
+        u32 timeTrialTicksBronze;
+        u32 timeTrialTicksSilver;
+        u32 timeTrialTicksGold;
+    }
 };

 struct Object {
    std::string::SizedString<u8> objName;
-    u32 x;
-    u32 y;
+    if (header.version > 1) {
+        u16 x;
+        u16 y;
+        bool hasMetafields;
+        if (hasMetafields) {
+            u16 numOfMetafields;
+            u8 metafields[numOfMetafields];
+        }
+    } 
+    else {
+        u32 x;
+        u32 y;
+    }
 };

 struct Objects{
@@ -70,6 +365,6 @@ struct Objects{
    std::Array<Object, objCount> objArray;
 };

-Header header @ 0x0;
+Header header   @ $;
 Options options @ $;
 Objects objects @ $;
--- a/patterns/adts.hexpat
+++ b/patterns/adts.hexpat
@@ -0,0 +1,198 @@
+#pragma authors: zhoubo
+#pragma version: 0.4
+#pragma description: Parse AAC's ADTS(Audio Data Transport Stream) audio files.
+#pragma category: Audio
+#pragma filemask: *.aac
+#pragma IDBytes: FF F //ADTS Syncword
+#pragma history:
+#pragma   0.4  2024-02-12 zhoubo: Porting from 010 Editor Templates.
+#pragma   0.3  2024-02-09 zhoubo: use BitfieldDisablePadding(Unpadded Bitfields) for odd header bytes(7,9 bytes) color, and remove FSeek.
+#pragma   0.2  2024-02-05 zhoubo: fix some comment & color.
+#pragma   0.1  2022-06-13 zhoubo: Init release. only ADTS, not support ADIF,LATM.
+
+// More information available at:
+//  1. https://wiki.multimedia.cx/index.php?title=ADTS
+//  2. https://en.wikipedia.org/wiki/Advanced_Audio_Coding
+//  3. https://en.wikipedia.org/wiki/AAC
+//  4. https://juejin.cn/post/7032170229732442148
+
+#pragma endian big
+
+#include <std/sys.pat>
+#include <std/core.pat>
+
+fn GetMPEGVersionComment(auto MPEG_Version)
+{
+    str comment = "";
+    match (MPEG_Version)
+    {
+    (0):          comment = "MPEG-4";
+    (1):          comment = "MPEG-2";
+    }
+    return comment;
+};
+
+fn GetProtectionAbsentComment(auto Protection_absence)
+{
+    str comment = "";
+    match (Protection_absence)
+    {
+    (0):          comment = "ADTS has 9 bytes with CRC";
+    (1):          comment = "ADTS has 7 bytes without CRC";
+    }
+    return comment;
+};
+
+fn GetProfileComment(auto Profile)
+{
+    str comment = "";
+    match (Profile)
+    {
+    (0x00):       comment = "AAC Main";
+    (0x01):       comment = "AAC LC (Low Complexity)";
+    (0x10):       comment = "AAC SSR (Scalable Sample Rate)";
+    (0x11):       comment = "AAC LTP (Long Term Prediction)";
+    }
+    return comment;
+};
+
+fn GetSamplingFrequencyIndexComment(auto Sampling_frequency_index)
+{
+    str comment = "";
+    match (Sampling_frequency_index)
+    {
+    (0x0):        comment = "96000Hz";
+    (0x1):        comment = "88200Hz";
+    (0x2):        comment = "64000Hz";
+    (0x3):        comment = "48000Hz";
+    (0x4):        comment = "44100Hz";
+    (0x5):        comment = "32000Hz";
+    (0x6):        comment = "24000Hz";
+    (0x7):        comment = "22050Hz";
+    (0x8):        comment = "16000Hz";
+    (0x9):        comment = "12000Hz";
+    (0xa):        comment = "11025Hz";
+    (0xb):        comment = "8000Hz";
+    (0xc):        comment = "7350Hz";
+    (0xd):        comment = "Reserved";
+    (0xe):        comment = "Reserved";
+    (0xf):        comment = "FORBIDDEN (malformed)";
+    }
+    return comment;
+};
+
+fn GetChannelConfigurationComment(auto Channel_configuration)
+{
+    str comment = "";
+    match (Channel_configuration)
+    {
+    (0):          comment = "Defined in AOT Specifc Config";
+    (1):          comment = "1 channel: front-center";
+    (2):          comment = "2 channels: front-left, front-right";
+    (3):          comment = "3 channels: front-center, front-left, front-right";
+    (4):          comment = "4 channels: front-center, front-left, front-right, back-center";
+    (5):          comment = "5 channels: front-center, front-left, front-right, back-left, back-right";
+    (6):          comment = "6 channels: front-center, front-left, front-right, back-left, back-right, LFE-channel";
+    (7):          comment = "8 channels: front-center, front-left, front-right, side-left, side-right, back-left, back-right, LFE-channel";
+    }
+    return comment;
+};
+
+fn GetBufferFullnessComment(auto ADTS_buffer_fullness)
+{
+    str comment = "";
+    match (ADTS_buffer_fullness)
+    {
+    (0x7FF):      comment = "VBR (most software ignore this field)";
+    (_):          comment = "rate..?? (most software ignore this field)";
+    }
+    return comment;
+};
+
+fn GetRawDataBlockComment(auto Number_of_AAC_frames_minus_1)
+{
+    str comment = "";
+    match (Number_of_AAC_frames_minus_1)
+    {
+    (0x0):        comment = "has 1 AAC data block";
+    (_):          comment = "data block number + 1";
+    }
+    return comment;
+};
+
+
+//-----------------------------------
+// Define structures used in AAC files
+//
+// [1.adts_fixed_header information]
+// Syncword:                     12bits, sync header, always 0xFFF。
+// MPEG_Version:                 1bit,   0 means MPGE-4, 1 means MPGE-2
+// Layer:                        2bits,  alwayas ”00”
+// Protection_absence:           1bit,   0 means ADTS Header 9 bytes; 1 means ADTS Header 7 bytes
+// Profile:                      2bit,   AAC level : Main,LC,SSR,LTP
+// Sampling_frequency_index:     4bits,  Sampling Frequencies
+// Private_bit:                  1bit
+// Channel_configuration:        3bits,  channel number...
+// Originality:                  1bit
+// Home:                         1bit
+//
+// [2.adts_variable_header information]
+// Copyright_id_bit:             1bit
+// Copyright_id_start:           1bit
+// AAC_frame_length:             13bits, AAC frame length : ADTS Header(7 or 9 bytes) + sizeof(AAC Frame)
+// ADTS_buffer_fullness:         11bits, 0x7FF means VBR
+// Number_of_AAC_frames_minus_1: 2bits,  ADTS Frame numbers : Number_of_AAC_frames_minus_1 + 1
+//
+// [3.CRC information]
+// CRC16:                        16bits, when Protection_absence=0
+
+bitfield ADTS_HEADER
+{
+    // ADTS_FIXED_HEADER
+    Syncword : 12                     [[color("00FF00"), comment("always 0xFFF")]];
+    MPEG_Version : 1                  [[color("00FF00"), comment(GetMPEGVersionComment(this))]];
+    Layer : 2                         [[color("00FF00"), comment("always 0")]];
+    Protection_absence : 1            [[color("00FF00"), comment(GetProtectionAbsentComment(this))]];
+
+    Profile : 2                       [[color("0000FF"), comment(GetProfileComment(this))]];
+    Sampling_frequency_index : 4      [[color("0000FF"), comment(GetSamplingFrequencyIndexComment(this))]];
+    Private_bit : 1                   [[color("0000FF")]];
+    Channel_configuration : 3         [[color("0000FF"), comment(GetChannelConfigurationComment(this))]];
+    Originality : 1                   [[color("0000FF")]];
+    Home : 1                          [[color("0000FF")]];
+
+    // ADTS_VARIABLE_HEADER
+    Copyright_id_bit : 1              [[color("0000FF")]];
+    Copyright_id_start : 1            [[color("0000FF")]];
+    AAC_frame_length : 13             [[color("0000FF")]];
+    ADTS_buffer_fullness : 11         [[color("0000FF"), comment(GetBufferFullnessComment(this))]];
+    Number_of_AAC_frames_minus_1 : 2  [[color("0000FF"), comment(GetRawDataBlockComment(this))]];
+
+    // ADTS_CRC_HEADER
+    if (0 == Protection_absence) // Header with CRC
+    {
+        u16 CRC16                     [[color("FFFF00")]];
+    }
+    else // Header without CRC
+    {
+    }
+};
+
+
+struct ADTS_FRAME
+{
+    ADTS_HEADER Header;
+
+    if (0 == Header.Protection_absence) // Header with CRC 2 bytes
+    {
+        u8 Data[Header.AAC_frame_length - 9]   [[color("000000")]];
+    }
+    else // Header without CRC
+    {
+        u8 Data[Header.AAC_frame_length - 7]   [[color("000000")]];
+    }
+};
+
+//---------------------------------------------
+
+ADTS_FRAME adtsFrame[while(!std::mem::eof())] @ 0x00;
--- a/patterns/afe2.hexpat
+++ b/patterns/afe2.hexpat
@@ -3,8 +3,8 @@

 #pragma endian little

-#include <std/io.pat>
-#include <std/sys.pat>
+import std.io;
+import std.sys;

 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC   	"AFE2"
 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC_1 	"AFE1"
--- a/patterns/ani.hexpat
+++ b/patterns/ani.hexpat
@@ -0,0 +1,66 @@
+#pragma description Windows animated cursor
+#pragma MIME application/x-navi-animation
+#pragma endian little
+
+import std.io;
+import std.mem;
+
+bitfield HeaderFlags {
+    icon : 1;
+    sequence : 1;
+    padding: 30;
+};
+
+struct anih {
+    u32 struct_size;
+    u32 stored_frames;
+    u32 animation_steps;
+    u32 w;
+    u32 h;
+    u32 bits;
+    u32 planes;
+    u32 default_jiffies;
+    HeaderFlags flags;
+};
+
+struct rate {
+    u32 jiffies[parent.size / 4];
+};
+
+struct seq {
+    u32 index[parent.size / 4];
+};
+
+struct RiffChunk {
+    char signature[4];
+    u32 size;
+    if (signature == "RIFF" || signature == "LIST") {
+        char type[4];
+        RiffChunk chunks[while($ - addressof(type) < size)];
+    } else if (signature[0] == 'I' && parent.type == "INFO") {
+        char info[size];
+    } else if (signature == "anih") {
+        anih anih [[inline]];
+    } else if (signature == "rate") {
+        rate rate [[inline]];
+    } else if (signature == "seq ") {
+        seq seq [[inline]];
+    } else {
+        std::mem::Bytes<size> data;
+    }
+    padding[size % 2];
+} [[format_read("read_chunk")]];
+
+fn read_chunk(RiffChunk chunk) {
+    if (chunk.signature == "RIFF" || chunk.signature == "LIST") {
+        return std::format("{}<{}> ({})", chunk.signature, chunk.type, chunk.size);
+    } else {
+        str ret = std::format("{} ({})", chunk.signature, chunk.size);
+        try {
+            ret += std::format(" \"{}\"", chunk.info);
+        } catch {}
+        return ret;
+    }
+};
+
+RiffChunk riff @ 0;
--- a/patterns/ar.hexpat
+++ b/patterns/ar.hexpat
@@ -3,9 +3,9 @@

 #pragma MIME application/x-archive

-#include <std/string.pat>
-#include <std/mem.pat>
-#include <std/sys.pat>
+import std.string;
+import std.mem;
+import std.sys;

 struct ARFile {
 	char file_name[16];
--- a/patterns/aria2.hexpat
+++ b/patterns/aria2.hexpat
@@ -0,0 +1,36 @@
+#pragma author itsmeow
+#pragma description aria2 Control File
+
+#pragma endian big
+
+/*
+Format sourced from:
+https://aria2.github.io/manual/en/html/technical-notes.html#control-file-aria2-format
+
+Version 0 files are not supported by default
+However parsing one is as simple as changing to #pragma endian ittle
+and resolving any errors resulting from that by adding be prefixes to struct fields.
+*/
+
+struct AriaInFlight {
+    u32 index;
+    u32 length;
+    u32 bitfield_piece_length;
+    u8 bitfield_p[bitfield_piece_length];
+};
+
+struct AriaHeader {
+    u16 version;
+    u32 extension;
+    u32 infohash_length;
+    u8 infohash[infohash_length];
+    u32 piece_length;
+    u64 total_length;
+    u64 upload_length;
+    u32 bitfield_length;
+    u8 bitfield_d[bitfield_length];
+    u32 inflight_count;
+    AriaInFlight inflights[inflight_count];
+};
+
+AriaHeader aria_header @ 0x00;
--- a/patterns/arm_cm_vtor.hexpat
+++ b/patterns/arm_cm_vtor.hexpat
@@ -3,8 +3,8 @@

 #pragma endian little

-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;

 #define VTOR	0x00000000
 #define EXTERNAL_INTERRUPT_COUNT	64
--- a/patterns/bastion
+++ b/patterns/bastion
--- a/patterns/bencode.hexpat
+++ b/patterns/bencode.hexpat
@@ -3,9 +3,9 @@

 #pragma MIME application/x-bittorrent

-#include <std/ctype.pat>
-#include <std/mem.pat>
-#include <std/string.pat>
+import std.ctype;
+import std.mem;
+import std.string;

 namespace bencode {
 	
--- a/patterns/bgcode.hexpat
+++ b/patterns/bgcode.hexpat
@@ -0,0 +1,80 @@
+#pragma author Shadlock0133 (aka Aurora)
+#pragma description Binary G-Code from Prusa
+
+#include <type/magic.pat>
+#include <std/mem.pat>
+
+enum ChecksumType : u16 {
+    None,
+    CRC32,
+};
+
+enum BlockType : u16 {
+    FileMetadata,
+    GCode,
+    SlicerMetadata,
+    PrinterMetadata,
+    PrintMetadata,
+    Thumbnail,
+};
+
+enum Compression : u16 {
+    None,
+    Deflate,
+    Heatshrink11_4,
+    Heatshrink12_4,
+};
+
+enum Encoding : u16 {
+    Ini,
+};
+
+enum ImageFormat : u16 {
+    Png,
+    Jpg,
+    Qoi,
+};
+
+struct Header {
+    type::Magic<"GCDE"> magic;
+    u32 version;
+    ChecksumType checksum_type;
+};
+
+Header header @ 0;
+std::assert(header.version == 1, "only version 1 supported");
+    
+struct Block {
+    BlockType type;
+    Compression compression;
+    u32 uncompressed_size;
+    auto size = uncompressed_size;
+    if (compression != Compression::None) {
+        u32 compressed_size;
+        size = compressed_size;
+    }
+    match (type) {
+        (BlockType::FileMetadata
+        | BlockType::PrinterMetadata
+        | BlockType::PrintMetadata
+        | BlockType::SlicerMetadata): {
+            Encoding encoding;
+        }
+        (BlockType::Thumbnail): {
+            ImageFormat image_format;
+            u16 width;
+            u16 height;
+        }
+        (BlockType::GCode): {
+            u16;
+        }
+        (_): { std::assert(false, "unknown type"); }
+    }
+    u8 data[size];
+    match (header.checksum_type) {
+        (ChecksumType::None): {}
+        (ChecksumType::CRC32): { u32 checksum; }
+    }
+};
+
+Block blocks[while(!std::mem::eof())] @ $;
--- a/patterns/bmp.hexpat
+++ b/patterns/bmp.hexpat
@@ -2,7 +2,7 @@

 #pragma MIME image/bmp
 #pragma endian little
-#include <std/mem.pat>
+import std.mem;

 struct BitmapFileHeader {
 	u8 bfType[2];
--- a/patterns/bplist.hexpat
+++ b/patterns/bplist.hexpat
@@ -0,0 +1,273 @@
+#pragma description TODO
+
+import std.math;
+import std.core;
+import type.magic;
+import type.time;
+
+using CFBinaryPlistObject;
+
+enum Marker : u8 {
+    Null  = 0x00,
+    False = 0x08,
+    True = 0x09,
+    Fill = 0x0F,
+    Int = 0x10,
+    Real = 0x20,
+    Date = 0x30,
+    Data = 0x40,
+    ASCIIString = 0x50,
+    Unicode16String = 0x60,
+    UNK_0x70 = 0x70,
+    UID = 0x80,
+    UNK_0x90 = 0x90,
+    Array = 0xA0,
+    UNK_0xB0 = 0xB0,
+    Set = 0xC0,
+    Dict = 0xD0,
+    UNK_0xE0 = 0xE0,
+    UNK_0xF0 = 0xF0
+};
+
+fn get_marker_name(u8 marker) {    
+    if (marker == Marker::Null){//    null	0000 0000
+        return "Null ";
+    }else if (marker == Marker::False){ //bool	0000 1000			// false
+        return "False";
+    }else if (marker == Marker::True){//bool	0000 1001			// true
+        return "True";
+    }else if (marker == Marker::Fill){ //fill	0000 1111			// fill byte  
+        return "Fill";
+    }else if (marker & 0xF0 == Marker::Int){ //int	0001 nnnn	...		// # of bytes is 2^nnnn, big-endian bytes
+        return "Int";
+    }else if (marker & 0xF0 == Marker:: Real){ //real	0010 nnnn	...		// # of bytes is 2^nnnn, big-endian bytes
+        return "Real";
+    }else if (marker == Marker::Date){ //date	0011 0011	...		// 8 byte float follows, big-endian bytes
+        return "Date";
+    }else if (marker & 0xF0 == Marker::Data){ //data	0100 nnnn	[int]	...	// nnnn is number of bytes unless 1111 then int count follows, followed by bytes
+        return "Data";   
+    }else if (marker & 0xF0 == Marker::ASCIIString){ //string	0101 nnnn	[int]	...	// ASCII string, nnnn is # of chars, else 1111 then int count, then bytes
+        return "ASCIIString";
+    }else if (marker & 0xF0 == Marker::Unicode16String){ //string	0110 nnnn	[int]	...	// Unicode string, nnnn is # of chars, else 1111 then int count, then big-endian 2-byte 
+        return "Unicode16String";
+    }else if (marker & 0xF0 == Marker::UNK_0x70){ //0111 xxxx			// unused
+        return "UNK_0x70";
+    }else if (marker & 0xF0 == Marker::UID){ //uid	1000 nnnn	...		// nnnn+1 is # of bytes
+        return "UID";
+    }else if (marker & 0xF0 == Marker::UNK_0x90){ // 1001 xxxx			// unused
+        return "UNK_0x90";
+    }else if (marker & 0xF0 == Marker::Array){ //array	1010 nnnn	[int]	objref*	// nnnn is count, unless '1111', then int count follows        
+        return "Array";
+    }else if (marker & 0xF0 == Marker::UNK_0xB0){ //1011 xxxx			// unused
+        return "UNK_0xB0";
+    }else if (marker & 0xF0 == Marker::Set){ //set	1100 nnnn	[int]	objref* // nnnn is count, unless '1111', then int count follows
+        return "Set";
+    }else if (marker & 0xF0 == Marker::Dict){ //dict	1101 nnnn	[int]	keyref* objref*	// nnnn is count, unless '1111', then int count follows	
+        return "Dict";
+    }else if (marker & 0xF0 == Marker::UNK_0xE0){ // 1110 xxxx			// unused
+        return "UNK_0xE0";
+    }else if (marker & 0xF0 == Marker::UNK_0xF0){  //1111 xxxx			// unused
+        return "UNK_0xF0";
+    }    
+};
+
+fn format_tag(u8 marker) {
+    return std::format("{}", get_marker(marker));
+};
+
+fn coredata_to_date (double val){
+    return type::impl::format_time_t(978307200 + val);
+};
+
+struct DictElement {  
+    CFBinaryPlistObject key @ offsetTable[parent.objReference.key_refs[std::core::array_index()]].offset;
+    CFBinaryPlistObject value @ offsetTable[parent.objReference.value_refs[std::core::array_index()]].offset;
+};
+
+struct ArrayElement {  
+    CFBinaryPlistObject value @ offsetTable[parent.objReference.value_refs[std::core::array_index()]].offset;
+};
+
+struct ObjectReference{
+    match(trailer.objectRefSize){
+        (1): {
+            be u8 key_refs[parent.ObjectLen.size];
+            be u8 value_refs[parent.ObjectLen.size];
+        }
+        (2): {
+            be u16 key_refs[parent.ObjectLen.size];
+            be u16 value_refs[parent.ObjectLen.size];
+        }
+        (4): {
+            be u32 key_refs[parent.ObjectLen.size];
+            be u32 value_refs[parent.ObjectLen.size];
+        }
+        (8): {
+            be u64 key_refs[parent.ObjectLen.size];
+            be u64 value_refs[parent.ObjectLen.size];
+        }
+    }
+};
+
+struct ObjectReferenceArray{
+    match(trailer.objectRefSize){
+        (1): be u8 value_refs[parent.ObjectLen.size];
+        (2): be u16 value_refs[parent.ObjectLen.size];
+        (4): be u32 value_refs[parent.ObjectLen.size];
+        (8): be u64 value_refs[parent.ObjectLen.size];
+    }
+};
+
+struct ObjectLen{
+    if (parent.marker_lsb != 0x0F){
+        u8 size = parent.marker_lsb [[export]];
+    }else{
+        CFBinaryPlistObject obj;
+        if (obj.marker & 0xF0 != Marker::Int){
+            std::error(std::format("Expects a 'Int' marker. Got 0x{:x} marker, with value {}", obj.marker, obj.value));
+        }
+
+        u128 size = obj.value [[export]];
+    }
+};
+
+struct CFBinaryPlistOffset{
+    match (trailer.offsetIntSize){
+        (1): be u8 offset;
+        (2): be u16 offset;
+        (4): be u32 offset;
+        (8): be u64 offset;
+    }
+};
+
+struct CFBinaryPlistObject{
+    u8 marker [[format("get_marker_name")]];
+    
+    u8 marker_msb = marker & 0xF0;
+    u8 marker_lsb  = marker & 0x0F;
+
+    match (marker_msb){ 
+        (0x0): {
+                match (marker_lsb){
+                    (Marker::Null): {
+                        u8 value = 0x00 [[export]];
+                    }
+                    (Marker::False): { 
+                        bool value = false [[export]];
+                    }
+                    (Marker::True): {
+                        bool value = true [[export]];
+                    }
+                    (Marker::Fill): {  
+                        //I think the correct implementation is to do nothing here. The marker will be used as padding (Fill) ???
+                    }
+                    (_): {
+                        std::error("Detected unknown marker {}.", marker_msb);
+                    }
+                }
+        }
+        (Marker::Int): {
+            be u8 size = std::math::pow(2, marker_lsb);     
+            // in format version '00', 1, 2, and 4-byte integers have to be interpreted as unsigned,
+            // whereas 8-byte integers are signed (and 16-byte when available)
+            // negative 1, 2, 4-byte integers are always emitted as 8 bytes in format '00'
+            // integers are not required to be in the most compact possible representation, but only the last 64 bits are significant currently
+            // Source: https://opensource.apple.com/source/CF/CF-550/CFBinaryPList.c
+
+            match (size) {
+                (1): be u8 value;
+                (2): be u16 value;
+                (4): be u32 value;
+                (8): be s64 value;
+                (16): be s128 value;
+                (_): std::error(std::format("Invalid size detected for 'Int' marker. Got size: {}.", size));
+            }                    
+        }
+        (Marker::Real): {
+            be u8 size = std::math::pow(2, marker_lsb); 
+            match (size){
+                (4): be float value;
+                (8): be double value;
+                (_): std::error(std::format("Invalid size detected for 'Real' marker. Got size: {}.", size));
+            }
+        }
+        (Marker::Date): {
+            be double value [[format("coredata_to_date")]];
+        }
+        (Marker::Data): {
+            ObjectLen ObjectLen;
+            u8 value[ObjectLen.size];      
+        }
+        (Marker::ASCIIString): {
+            ObjectLen ObjectLen;
+            char value[ObjectLen.size];
+        }
+        (Marker::Unicode16String): {
+           ObjectLen ObjectLen;
+           be char16 value[ObjectLen.size];
+        }
+        (Marker::UID): {
+            //Not 100% sure if this is correct for UID. Need more testing
+            u8 size = marker_lsb+1;
+            match (size) {
+                (1): be u8 value;
+                (2): be u16 value;
+                (4): be u32 value;
+                (8): be u64 value;
+                (16): be u128 value;
+                (_): std::error(std::format("Invalid size detected for 'UID' marker. Got size: {}.", size));
+            }      
+        }
+        (Marker::Set | Marker::Array): {
+            ObjectLen ObjectLen;
+
+            ObjectReferenceArray objReference;
+            ArrayElement value[ObjectLen.size];
+        }
+        (Marker::Dict): {
+            ObjectLen ObjectLen;
+            
+            ObjectReference objReference;
+            DictElement value[ObjectLen.size];
+        }
+        (Marker::UNK_0x70 | Marker::UNK_0x90 | Marker::UNK_0xB0 | Marker::UNK_0xE0 | Marker::UNK_0xF0): {
+            std::error(std::format("Got unused marker 0x{:x}", marker));
+        }
+        (_): {
+            std::error(std::format("Got unknown marker 0x{:x}", marker));
+        }    
+    }
+};
+
+struct CFBinaryPlistHeader{
+    type::Magic<"bplist"> magic;
+    u16 version;
+    if (version != 0x3030){
+        std::error("Unsupported version detected. Only version 00 is supported (bplist00).");
+    }
+};
+
+struct CFBinaryPlistTrailer {
+    u8 unused[5];
+    u8 sortVersion; 
+    be u8 offsetIntSize;
+    match (offsetIntSize){
+        (1|2|4|8): {}
+        (_): {std::error("Invalid offsetIntSize.");}
+    }
+    be u8 objectRefSize; 
+    match (objectRefSize){
+        (1|2|4|8): {}
+        (_): {std::error("Invalid objectRefSize.");}
+    }
+    be u64 numObjects;
+    be u64 topObject;
+    be u64 offsetTableOffset;
+};
+
+
+CFBinaryPlistHeader header @ 0x00;
+CFBinaryPlistTrailer trailer @ std::mem::size()-32;
+
+CFBinaryPlistOffset offsetTable[trailer.numObjects] @ trailer.offsetTableOffset;
+CFBinaryPlistObject objectTable  @ offsetTable[trailer.topObject].offset;
--- a/patterns/bson.hexpat
+++ b/patterns/bson.hexpat
@@ -3,8 +3,8 @@

 #pragma MIME application/bson

-#include <std/mem.pat>
-#include <type/time.pat>
+import std.mem;
+import type.time;

 enum Type : u8 {
    Double              = 0x01,
--- a/patterns/bsp_goldsrc.hexpat
+++ b/patterns/bsp_goldsrc.hexpat
@@ -1,8 +1,8 @@
 #pragma description GoldSrc engine maps format (used in Half-Life 1)

-#include <std/ptr.pat>
-#include <std/mem.pat>
-#include <std/sys.pat>
+import std.ptr;
+import std.mem;
+import std.sys;

 #pragma endian little

--- a/patterns/chm.hexpat
+++ b/patterns/chm.hexpat
@@ -1,11 +1,11 @@
 #pragma author WerWolv
 #pragma description Windows HtmlHelp Data (ITSF / CHM)

-#include <type/magic.pat>
-#include <type/size.pat>
-#include <type/guid.pat>
-#include <type/leb128.pat>
-#include <std/sys.pat>
+import type.magic;
+import type.size;
+import type.guid;
+import type.leb128;
+import std.sys;

 enum WindowsLanguageId : u32 {
    Arabic_SaudiArabia                          = 0x401,
--- a/patterns/coff.hexpat
+++ b/patterns/coff.hexpat
@@ -3,8 +3,8 @@

 #pragma MIME application/x-coff

-#include <type/time.pat>
-#include <type/size.pat>
+import type.time;
+import type.size;

 enum Machine : u16 {
    Unknown     = 0x0000,
--- a/patterns/cpio.hexpat
+++ b/patterns/cpio.hexpat
@@ -1,12 +1,12 @@
 #pragma author WerWolv
 #pragma description Old Binary CPIO Format

-#include <type/base.pat>
+import type.base;

-#include <std/time.pat>
-#include <std/core.pat>
-#include <std/sys.pat>
-#include <std/mem.pat>
+import std.time;
+import std.core;
+import std.sys;
+import std.mem;

 #pragma MIME application/x-cpio

--- a/patterns/dds.hexpat
+++ b/patterns/dds.hexpat
@@ -167,16 +167,26 @@ bitfield Caps2Flags {
 };

 bitfield PixelFormatFlags {
-  alphaPixels : 1;
-  alpha       : 1;
-  fourCC      : 1;
-  padding     : 3;
-  rgb         : 1; // 0x40
-  padding     : 2;
-  yuv         : 1; // 0x200
-  padding     : 3;
-  luminance   : 1; // 0x20000
-  padding     : 17;
+  alphaPixels 	    : 1;  // DDPF_ALPHAPIXELS
+  alpha       	    : 1;  // DDPF_ALPHA
+  fourCC      	    : 1;  // DDPF_FOURCC
+  paletteIndexed4   : 1;  // DDPF_PALETTEINDEXED4
+  paletteIndexedTo8 : 1;  // DDPF_PALETTEINDEXEDTO8
+  paletteIndexed8   : 1;  // DDPF_PALETTEINDEXED8
+  rgb               : 1;  // DDPF_RGB
+  compressed        : 1;  // DDPF_COMPRESSED
+  rgbToYuv          : 1;  // DDPF_RGBTOYUV
+  yuv               : 1;  // DDPF_YUV
+  zBuffer           : 1;  // DDPF_ZBUFFER
+  paletteIndexed1   : 1;  // DDPF_PALETTEINDEXED1
+  paletteIndexed2   : 1;  // DDPF_PALETTEINDEXED2
+  zPixels           : 1;  // DDPF_ZPIXELS
+  stencilBuffer     : 1;  // DDPF_STENCILBUFFER
+  alphaResult       : 1;  // DDPF_ALPHARESULT
+  luminance         : 1;  // DDPF_LUMINANCE
+  bumpLuminance     : 1;  // DDPF_BUMPLUMINANCE
+  bumpDudv          : 1;  // DDPF_BUMPDUDV
+  padding           : 13; // Padding bits to complete 32-bit structure
 };

 enum DX10ResourceDimension : u32 {
--- a/patterns/dex.hexpat
+++ b/patterns/dex.hexpat
@@ -1,6 +1,6 @@
 #pragma description Dalvik EXecutable Format

-#include <type/leb128.pat>
+import type.leb128;

 struct header_item {
    u8 magic[8];
--- a/patterns/dicom.hexpat
+++ b/patterns/dicom.hexpat
--- a/patterns/dmg.hexpat
+++ b/patterns/dmg.hexpat
@@ -2,10 +2,10 @@

 #pragma endian big

-#include <type/magic.pat>
-#include <type/size.pat>
-#include <type/guid.pat>
-#include <std/mem.pat>
+import type.magic;
+import type.size;
+import type.guid;
+import std.mem;

 // Parse DMG Structure per http://newosxbook.com/DMG.html
 //
--- a/patterns/dsstore.hexpat
+++ b/patterns/dsstore.hexpat
@@ -2,7 +2,7 @@

 // Apple macOS .DS_Store format
 #pragma endian big
-#include <std/io.pat>
+import std.io;

 struct RecordEntry {
  u32 length;
--- a/patterns/dted.hexpat
+++ b/patterns/dted.hexpat
@@ -0,0 +1,117 @@
+#pragma description Digital Terrain Elevation Data
+#pragma endian big
+
+import std.core;
+import std.io;
+import std.mem;
+import std.string;
+
+
+enum Magic:u24 { 
+    UHL = 0x55484C,
+    DSI = 0x445349,
+    ACC = 0x414343,
+}; 
+
+struct UHL {
+    Magic magic;
+    char one;
+    char lon[8];
+    char lat[8];
+    char lon_data_interval[4];
+    char lat_data_interval[4];
+    char accuracy[4];
+    char security_code[3];
+    char uniq_ref[12];
+    char lon_lines[4];
+    char lat_points[4];
+    char multi_accuracy;
+    char reserved[24];
+};
+
+struct DSI {
+    Magic magic;
+    char classification;
+    char stuff1[29];
+    char stuff2[26];
+    char product_level[5];
+    char uniq_ref[15];
+    char reserved[8];
+    char data_edition[2];
+    char match_version;
+    char maint_date[4];
+    char match_date[4];
+    char main_desc_code[4];
+    char producer_code[8];
+    char reserved2[16];
+    char product_spec[9];
+    char numbers[2];
+    char product_spec_date[4];
+    char vertical_datum[3];
+    char horizontal_datum[5];
+    char digitizing_system[10];
+    char compilation_date[4];
+    char reserved3[22];
+    char lat_origin[9];
+    char lon_origin[10];
+    char lat_sw_corner[7];
+    char lon_sw_corner[8];
+    char lat_nw_corner[7];
+    char lon_nw_corner[8];
+    char lat_ne_corner[7];
+    char lon_ne_corner[8];
+    char lat_se_corner[7];
+    char lon_se_corner[8];
+    char clockwise_orientation[9];
+    char lat_interval[4];
+    char lon_interval[4];
+    char lat_lines[4];
+    char lon_lines[4];
+    char partial_cell[2];
+    char reserved4[101];
+    char reserved5[100];
+    char reserved6[156];
+};
+
+struct ACCSub {
+    char abs_vertical_accuracy[4];
+    char abs_horizontal_accuracy[4];
+    char rel_vertical_accuracy[4];
+    char rel_horizontal_accuracy[4];
+    char num_coords[2];
+    char pairs[19*14];
+};
+
+struct ACC {
+    Magic magic;
+    char abs_horizontal_accuracy[4];
+    char abs_vertical_accuracy[4];
+    char rel_horizontal_accuracy[4];
+    char rel_vertical_accuracy[4];
+    char reserved1[4];
+    char reserved2[1];
+    char reserved3[31];
+    char multi_accuracy_outline[2]; // determines sub regions
+    ACCSub subs[9];
+    char reserved4[18];
+    char reserved5[69];
+    
+};
+
+struct DataRecords {
+    char magic;
+    s24 data_block_count;
+    s16 lon_count;
+    s16 lat_count;
+    s16 elevation[std::string::parse_int(parent.dsi.lat_lines, 10)];
+    u32 checksum;
+};
+
+struct DTED {
+    UHL uhl;
+    DSI dsi;
+    ACC acc;
+    DataRecords records[std::string::parse_int(this.dsi.lon_lines, 10)];
+};
+
+DTED dted @ 0x00;
--- a/patterns/elf.hexpat
+++ b/patterns/elf.hexpat
@@ -7,9 +7,9 @@
 #pragma MIME application/x-object
 #pragma MIME application/x-sharedlib

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

 using BitfieldOrder = std::core::BitfieldOrder;

@@ -498,12 +498,12 @@ bitfield SHF {
 bitfield ELF32_R_INFO {
    SYM  : 8;
    TYPE : 8;
-} [[left_to_right]];
+} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 16)]];

 bitfield ELF64_R_INFO {
    SYM  : 32;
    TYPE : 32;
-} [[left_to_right]];
+} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 64)]];

 bitfield PF {
    X        : 1;
--- a/patterns/fas_oskasoftware.hexpat
+++ b/patterns/fas_oskasoftware.hexpat
@@ -0,0 +1,111 @@
+#pragma author DmitriLeon2000
+#pragma description Oska Software DeskMates FAS (Frames and Sequences) file
+#pragma endian little
+
+enum Compression : u32 {
+	BI_RGB,
+	BI_RLE8,
+	BI_RLE4,
+	BI_BITFIELDS,
+	BI_JPEG,
+	BI_PNG,
+	BI_ALPHABITFIELDS,
+	BI_CMYK,
+	BI_CMYKRLE8,
+	BI_CMYKRLE4,
+};
+
+struct Colors {
+	u8 blue;
+	u8 green;
+	u8 red;
+	u8 reserved;
+};
+
+struct FASHeader {
+    char name[50]; // name of the pack, may include garbage data
+    u16 version; // Format version number
+    s16 frameIDFirst; // assigned ID of the first frame
+    s16 frameIDLast; // assigned ID of the last frame
+    s32 width; // width of the animation (in pixels)
+    s32 height; // height of the animation (in pixels)
+    u16 frameSize; // size of the animation ((frameWidth * BPP + 31) // 32 * 4 * frameHeight)
+    u16 DblHeaderCount; // amount of BitmapInfoHeader pairs (one for color, one for masking)
+};
+
+struct BitmapInfoHeader { // bog-standard BitmapInfoHeaderV1
+    u32 biSize;
+    s32 biWidth;
+    s32 biHeight;
+    u16 biPlanes;
+    u16 biBitCount;
+    Compression compression;
+    u32 biSizeImage;
+    s32 biXPelsPerMeter;
+    s32 biYPelsPerMeter;
+    u32 biClrUsed;
+    u32 biClrImportant;
+};
+
+struct BitmapInfo {
+    BitmapInfoHeader header;
+    Colors colorMap[header.biClrUsed == 0 ?
+        1 << header.biBitCount : header.biClrUsed];
+};
+
+struct ExtraSprite {
+    char name[];
+};
+
+struct AnimSequence {
+    char name[];
+    char sequence[];
+};
+
+struct SeqHeader {
+    le u32       size;
+    le u32       count;
+    le u32       strPointers[count*2];
+};
+
+struct Bitmap {
+    u8 byte[fas.fasHeader.version >= 3 ? fas.fasHeader.frameSize + (fas.frameSizeHigh << 16) : fas.fasHeader.frameSize];
+};
+
+struct FramesHeader {
+    le u32 count;
+    le s16 frameID[count];
+    u8     frameDblHdrID[count];
+};
+
+struct FAS {
+    FASHeader fasHeader;
+    BitmapInfo dibHeaders[fasHeader.DblHeaderCount * 2];
+        if (fasHeader.version >= 1)
+        u8 charID;
+    if (fasHeader.version >= 2)
+    {
+        u32 extraEndOffset;
+        u16 extraSpritesCount;
+        if (extraSpritesCount)
+            // char extraSpriteList[touchOffset - 6];
+            ExtraSprite extraSprites[extraSpritesCount];
+    }
+    if (fasHeader.version >= 3)
+      le u16 frameSizeHigh;
+    le u16 touchColors;
+    if (touchColors)
+    {
+        u32 touchColorMap[touchColors];
+        u16 touchWidth;
+        u8 touchBitmap[this.touchWidth * fasHeader.height];
+    }
+    SeqHeader seqHeader;
+    if (fasHeader.version >= 1)
+        u8 filenameChecksum; // a checksum for a filename in ASCII
+    AnimSequence sequences[seqHeader.count];
+    FramesHeader framesHeader;
+};
+
+FAS fas @ 0x00;
+Bitmap framesBitmap[fas.framesHeader.count] @ $;
--- a/patterns/fas_oskasoftware_old.hexpat
+++ b/patterns/fas_oskasoftware_old.hexpat
@@ -0,0 +1,87 @@
+#pragma author DmitriLeon2000
+#pragma description Oska Software DeskMates FAS (Frames and Sequences) file (Oska DeskMate versions 1.3 and 2.06)
+#pragma endian little
+
+enum Compression : u32 {
+	BI_RGB,
+	BI_RLE8,
+	BI_RLE4,
+	BI_BITFIELDS,
+	BI_JPEG,
+	BI_PNG,
+	BI_ALPHABITFIELDS,
+	BI_CMYK,
+	BI_CMYKRLE8,
+	BI_CMYKRLE4,
+};
+
+struct Colors {
+	u8 blue;
+	u8 green;
+	u8 red;
+	u8 reserved;
+};
+
+struct FASHeader {
+    s32 width; // width of the animation (in pixels)
+    s32 height; // height of the animation (in pixels)
+    u16 reserved1;
+    u16 reserved2;
+    u16 frameSizeCombined; // a sum of frameSizeColor and frameSizeMask
+    u16 frameSizeColor; // size of the animation ((frameWidth * 4 + 31) // 32 * 4 * frameHeight)
+    u16 frameSizeMask; // size of the animation's mask ((frameWidth * 1 + 31) // 32 * 4 * frameHeight)
+    u16 headerCount; // amount of DIB headers
+};
+
+struct BitmapInfoHeader { // bog-standard BitmapInfoHeaderV1
+    u32 biSize;
+    s32 biWidth;
+    s32 biHeight;
+    u16 biPlanes;
+    u16 biBitCount;
+    Compression compression;
+    u32 biSizeImage;
+    s32 biXPelsPerMeter;
+    s32 biYPelsPerMeter;
+    u32 biClrUsed;
+    u32 biClrImportant;
+};
+
+struct BitmapInfo {
+    BitmapInfoHeader header;
+    le u32 colorMap[header.biClrUsed == 0 ?
+        1 << header.biBitCount : header.biClrUsed];
+};
+
+struct AnimSequence {
+    char name[];
+    char sequence[];
+};
+
+struct SeqHeader {
+    le u32       size;
+    le u32       count;
+    le u32       strPointers[count*2];
+};
+
+struct Frame {
+    u8 colorBitmap[fas.fasHeader.frameSizeColor];
+    u8 maskBitmap[fas.fasHeader.frameSizeMask];
+};
+
+struct FramesHeader {
+    le u32 count;
+    le s16 frameID[count];
+};
+
+struct FAS {
+    FASHeader fasHeader;
+    BitmapInfo dibHeaders[fasHeader.headerCount];
+    SeqHeader seqHeader;
+    AnimSequence sequences[seqHeader.count];
+    FramesHeader framesHeader;
+};
+
+
+FAS fas @ 0x00;
+Frame frames[fas.framesHeader.count] @ $;
--- a/patterns/fdt.hexpat
+++ b/patterns/fdt.hexpat
@@ -3,12 +3,12 @@

 #pragma endian big

-#include <std/sys.pat>
-#include <std/io.pat>
-#include <std/core.pat>
+import std.sys;
+import std.io;
+import std.core;

-#include <type/magic.pat>
-#include <type/size.pat>
+import type.magic;
+import type.size;

 // These are used in order for the children to be able to find strings
 u64 fdt_addr;
--- a/patterns/ffx
+++ b/patterns/ffx
--- a/patterns/flac.hexpat
+++ b/patterns/flac.hexpat
@@ -1,9 +1,9 @@
 #pragma author WerWolv
 #pragma description Free Lossless Audio Codec, FLAC Audio Format

-#include <std/sys.pat>
-#include <std/core.pat>
-#include <std/io.pat>
+import std.sys;
+import std.core;
+import std.io;

 #pragma endian big

@@ -307,6 +307,8 @@ struct METADATA_BLOCK {
 		METADATA_BLOCK_PADDING data;
 	else if (header.blockType == BLOCK_TYPE::APPLICATION)
 		METADATA_BLOCK_APPLICATION data;
+	else if (header.blockType == BLOCK_TYPE::SEEKTABLE)
+	     METADATA_BLOCK_SEEKTABLE data;
 	else if (header.blockType == BLOCK_TYPE::VORBIS_COMMENT)
 		METADATA_BLOCK_VORBIS_COMMENT data;
 	else if (header.blockType == BLOCK_TYPE::CUESHEET)
@@ -323,4 +325,4 @@ struct STREAM {
 	//FRAME frames[while(!std::mem::eof())];
 };

-STREAM stream @ 0x00;
+STREAM stream @ 0x00;
--- a/patterns/fs.hexpat
+++ b/patterns/fs.hexpat
@@ -1,7 +1,7 @@
 #pragma author WerWolv
 #pragma description Drive File System

-#include <std/io.pat>
+import std.io;

 struct DiskTimeStamp {
 	u8 seconds, minutes, hours;
@@ -52,7 +52,7 @@ namespace fat32 {
 		lastLogical : 1;
 		padding : 1;
 		number : 5;
-	} [[left_to_right]];
+	} [[bitfield_order(BitfieldOrder::MostToLeastSignificant, 8)]];
 	
 	enum EntryStatus : u8 {
 		Regular = 0x00,
@@ -73,7 +73,7 @@ namespace fat32 {
 		subdirectory : 1;
 		archive : 1;
 		padding : 2;
-	} [[right_to_left]];
+	} [[bitfield_order(BitfieldOrder::LeastToMostSignificant, 8)]];
 	
 	struct DirEntry {
 		char fileName[8];
--- a/patterns/gb.hexpat
+++ b/patterns/gb.hexpat
@@ -1,340 +1,361 @@
 #pragma author WerWolv
 #pragma description Gameboy ROM

-#include <type/size.pat>
-#include <std/io.pat>
-#include <std/string.pat>
-
 #pragma MIME application/x-gameboy-rom

+import type.size;
+import std.string;
+import std.mem;
+
+bool uppercaseROMFeatures in;
+bool brandedROMFeatures in;
+
+bitfield CGB {
+	padding : 2;
+	PGB_MODE : 2;
+	padding : 2;
+	CGB_ONLY : 1 [[comment("gbcOnly")]];
+	CGB_SUPPORT : 1 [[comment("supportsGBC")]];
+} [[comment("GBCFlags")]];
+
 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";
-    };
+	fn cart_size(u8 cartSizeType) {
+		u32 romSize = 32768 * (1 << cartSizeType);
+		u16 romBanks = 2 * (1 << cartSizeType);
+		if (cartSizeType == 0x52) {
+			romSize = 1153434;
+			romBanks = 72;
+		}
+		if (cartSizeType == 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 = "( ";
+		if (brandedROMFeatures) match(type) {
+				(0xFC): result += "pocket ";
+				(0xFD): result += "bandai ";
+			}
+		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";
+		}
+		if (uppercaseROMFeatures) result = std::string::to_upper(result);
+		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 code";
+			(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 (std::mem::read_unsigned(0x14B, 1) != 0x33) return "See old licensee code";
+		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 Software";
+			("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";
+	};
+
+	using CGB;
+	
+	fn null_cgb_flags(CGB flags) {
+		return "NO_CGB";
+	};
 }

+enum DestinationType : u8 {
+	Japanese,
+	NonJapanese
+};
+
+enum SGBFlagType : u8 {
+	NoSGBFunctionality,
+	SGBFunctionality = 0x03
+};
+
+struct Header {
+	char title[16-(std::mem::read_unsigned(addressof(this)+15, 1) >= 0x80)];
+	if (std::mem::read_unsigned(addressof(this)+15, 1) == 0)
+		CGB gbcFlags @ $-1 [[format("format::null_cgb_flags")]];
+	else if (std::mem::read_unsigned(addressof(this)+15, 1) >= 0x80)
+		CGB gbcFlags;
+	char newLicenseeCode[2] [[format("format::new_licensee_code")]];
+	SGBFlagType sgbFlag;
+	u8 romType [[format("format::rom_features")]];
+	u8 cartSize [[format("format::cart_size")]];
+	u8 ramType [[format("format::ram_type")]];
+	DestinationType destination;
+	u8 licenseeCode [[format("format::licensee_code")]];
+	u8 maskROMVersionNumber;
+	u8 headerChecksum [[comment("Checksum for: $134-$14C")]];
+	u16 globalChecksum [[comment("Checksum for entire range")]];
+};
+
 bitfield pixel_packed {
-    p1 : 1;
-    p2 : 1;
-    p3 : 1;
-    p4 : 1;
-    p5 : 1;
-    p6 : 1;
-    p7 : 1;
-    p8 : 1;
+	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 CartridgeStart {
+	u8 entryCode[4];
+	pixel_packed logo[0x30];
+	Header header;
 };

 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")]];
+	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 Cartrige {
-    JumpVectors jumpVectors [[comment("Instructions called on interupts or rst instructions")]];
-    padding[0x100 - sizeof(JumpVectors)];
-    Header header;
-};
-
-
-Cartrige cart @ 0x00;
+JumpVectors jumpVectors @ 0x00 [[comment("Instructions called on interrupts or RST instructions")]];
+CartridgeStart cartridgeStart @ 0x100;
--- a/patterns/gguf.hexpat
+++ b/patterns/gguf.hexpat
@@ -0,0 +1,215 @@
+// https://github.com/ggerganov/ggml/blob/master/docs/gguf.md
+// https://github.com/openxla/iree/blob/main/runtime/src/iree/io/formats/gguf/gguf_parser.c
+
+#pragma description GGUF v3 File Format Patter
+#pragma authors @leonjza, jessie @ imhex discord
+
+#pragma pattern_limit 300000
+
+enum ggml_type: u32 {
+    GGML_TYPE_F32     = 0,
+    GGML_TYPE_F16     = 1,
+    GGML_TYPE_Q4_0    = 2,
+    GGML_TYPE_Q4_1    = 3,
+    // GGML_TYPE_Q4_2 = 4, support has been removed
+    // GGML_TYPE_Q4_3 = 5, support has been removed
+    GGML_TYPE_Q5_0    = 6,
+    GGML_TYPE_Q5_1    = 7,
+    GGML_TYPE_Q8_0    = 8,
+    GGML_TYPE_Q8_1    = 9,
+    GGML_TYPE_Q2_K    = 10,
+    GGML_TYPE_Q3_K    = 11,
+    GGML_TYPE_Q4_K    = 12,
+    GGML_TYPE_Q5_K    = 13,
+    GGML_TYPE_Q6_K    = 14,
+    GGML_TYPE_Q8_K    = 15,
+    GGML_TYPE_IQ2_XXS = 16,
+    GGML_TYPE_IQ2_XS  = 17,
+    GGML_TYPE_IQ3_XXS = 18,
+    GGML_TYPE_IQ1_S   = 19,
+    GGML_TYPE_IQ4_NL  = 20,
+    GGML_TYPE_IQ3_S   = 21,
+    GGML_TYPE_IQ2_S   = 22,
+    GGML_TYPE_IQ4_XS  = 23,
+    GGML_TYPE_I8      = 24,
+    GGML_TYPE_I16     = 25,
+    GGML_TYPE_I32     = 26,
+    GGML_TYPE_I64     = 27,
+    GGML_TYPE_F64     = 28,
+    GGML_TYPE_IQ1_M   = 29,
+    GGML_TYPE_COUNT,
+};
+
+enum gguf_metadata_value_type: u32 {
+    // The value is a 8-bit unsigned integer.
+    GGUF_METADATA_VALUE_TYPE_UINT8 = 0,
+    // The value is a 8-bit signed integer.
+    GGUF_METADATA_VALUE_TYPE_INT8 = 1,
+    // The value is a 16-bit unsigned little-endian integer.
+    GGUF_METADATA_VALUE_TYPE_UINT16 = 2,
+    // The value is a 16-bit signed little-endian integer.
+    GGUF_METADATA_VALUE_TYPE_INT16 = 3,
+    // The value is a 32-bit unsigned little-endian integer.
+    GGUF_METADATA_VALUE_TYPE_UINT32 = 4,
+    // The value is a 32-bit signed little-endian integer.
+    GGUF_METADATA_VALUE_TYPE_INT32 = 5,
+    // The value is a 32-bit IEEE754 floating point number.
+    GGUF_METADATA_VALUE_TYPE_FLOAT32 = 6,
+    // The value is a boolean.
+    // 1-byte value where 0 is false and 1 is true.
+    // Anything else is invalid, and should be treated as either the model being invalid or the reader being buggy.
+    GGUF_METADATA_VALUE_TYPE_BOOL = 7,
+    // The value is a UTF-8 non-null-terminated string, with length prepended.
+    GGUF_METADATA_VALUE_TYPE_STRING = 8,
+    // The value is an array of other values, with the length and type prepended.
+    ///
+    // Arrays can be nested, and the length of the array is the number of elements in the array, not the number of bytes.
+    GGUF_METADATA_VALUE_TYPE_ARRAY = 9,
+    // The value is a 64-bit unsigned little-endian integer.
+    GGUF_METADATA_VALUE_TYPE_UINT64 = 10,
+    // The value is a 64-bit signed little-endian integer.
+    GGUF_METADATA_VALUE_TYPE_INT64 = 11,
+    // The value is a 64-bit IEEE754 floating point number.
+    GGUF_METADATA_VALUE_TYPE_FLOAT64 = 12,
+};
+
+// A string in GGUF.
+struct gguf_string_t {
+    // The length of the string, in bytes.
+    u64 len;
+    // The string as a UTF-8 non-null-terminated string.
+    char string[len];
+};
+
+
+struct gguf_metadata_value_t {
+    gguf_metadata_value_type type;
+    u64 length;
+    
+    match(type) {
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT8): u8 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_INT8): s8 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT16): u16 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_INT16): s16 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT32): u32 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_INT32): s32 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_FLOAT32): float value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_BOOL): bool value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_STRING): gguf_string_t value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT64): u64 value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_FLOAT64): double value[length];
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_ARRAY): double value[length];
+    }
+};
+
+struct gguf_metadata_value {
+    gguf_metadata_value_type type;
+
+    match(type) {
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT8): u8 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_INT8): s8 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT16): u16 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_INT16): s16 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT32): u32 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_INT32): s32 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_FLOAT32): float value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_BOOL): bool value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_STRING): gguf_string_t value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_UINT64): u64 value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_FLOAT64): double value;
+        (gguf_metadata_value_type::GGUF_METADATA_VALUE_TYPE_ARRAY): gguf_metadata_value_t value;       
+    }
+};
+
+struct gguf_metadata_kv_t {
+    // The key of the metadata. It is a standard GGUF string, with the following caveats:
+    // - It must be a valid ASCII string.
+    // - It must be a hierarchical key, where each segment is `lower_snake_case` and separated by a `.`.
+    // - It must be at most 2^16-1/65535 bytes long.
+    // Any keys that do not follow these rules are invalid.
+    gguf_string_t key;
+
+    // The type of the value.
+    // Must be one of the `gguf_metadata_value_type` values.
+    // gguf_metadata_value_type value_type;
+    
+    // The value.
+    gguf_metadata_value value;
+};
+
+struct gguf_header_t {
+    // Magic number to announce that this is a GGUF file.
+    // Must be `GGUF` at the byte level: `0x47` `0x47` `0x55` `0x46`.
+    // Your executor might do little-endian byte order, so it might be
+    // check for 0x46554747 and letting the endianness cancel out.
+    // Consider being *very* explicit about the byte order here.
+    u32 magic;
+    // The version of the format implemented.
+    // Must be `3` for version described in this spec, which introduces big-endian support.
+    //
+    // This version should only be increased for structural changes to the format.
+    // Changes that do not affect the structure of the file should instead update the metadata
+    // to signify the change.
+    u32 version;
+    // The number of tensors in the file.
+    // This is explicit, instead of being included in the metadata, to ensure it is always present
+    // for loading the tensors.
+    u64 tensor_count;
+    // The number of metadata key-value pairs.
+    u64 metadata_kv_count;
+    // The metadata key-value pairs.
+    gguf_metadata_kv_t metadata_kv[metadata_kv_count];
+};
+
+struct gguf_tensor_info_t {
+    // The name of the tensor. It is a standard GGUF string, with the caveat that
+    // it must be at most 64 bytes long.
+    gguf_string_t name;
+    // The number of dimensions in the tensor.
+    // Currently at most 4, but this may change in the future.
+    u32 n_dimensions;
+    // The dimensions of the tensor.
+    u64 dimensions[n_dimensions];
+    // The type of the tensor.
+    ggml_type type;
+    // The offset of the tensor's data in this file in bytes.
+    //
+    // This offset is relative to `tensor_data`, not to the start
+    // of the file, to make it easier for writers to write the file.
+    // Readers should consider exposing this offset relative to the
+    // file to make it easier to read the data.
+    //
+    // Must be a multiple of `ALIGNMENT`. That is, `align_offset(offset) == offset`.
+    u64 offset;
+};
+
+struct gguf_file_t {
+    // The header of the file.
+    gguf_header_t header;
+
+    // Tensor infos, which can be used to locate the tensor data.
+    gguf_tensor_info_t tensor_infos[header.tensor_count];
+
+    // Padding to the nearest multiple of `ALIGNMENT`.
+    //
+    // That is, if `sizeof(header) + sizeof(tensor_infos)` is not a multiple of `ALIGNMENT`,
+    // this padding is added to make it so.
+    //
+    // This can be calculated as `align_offset(position) - position`, where `position` is
+    // the position of the end of `tensor_infos` (i.e. `sizeof(header) + sizeof(tensor_infos)`).
+    u8 _padding[];
+
+    // Tensor data.
+    //
+    // This is arbitrary binary data corresponding to the weights of the model. This data should be close
+    // or identical to the data in the original model file, but may be different due to quantization or
+    // other optimizations for inference. Any such deviations should be recorded in the metadata or as
+    // part of the architecture definition.
+    //
+    // Each tensor's data must be stored within this array, and located through its `tensor_infos` entry.
+    // The offset of each tensor's data must be a multiple of `ALIGNMENT`, and the space between tensors
+    // should be padded to `ALIGNMENT` bytes.
+    u8 tensor_data[];
+};
+
+gguf_file_t GGUF @ 0x00;
--- a/patterns/gif.hexpat
+++ b/patterns/gif.hexpat
@@ -13,13 +13,13 @@
 #define EXTENSION_INTRODUCER_MAGIC 0x21
 #define GIF_TRAILER_MAGIC 0x3B

-#include <std/io.pat>
-#include <std/core.pat>
-#include <std/mem.pat>
-#include <std/string.pat>
-#include <std/math.pat>
+import std.io;
+import std.core;
+import std.mem;
+import std.string;
+import std.math;

-#include <type/magic.pat>
+import type.magic;

 bitfield GCT_Flags {
    size : 3 [[comment("physical size = 2^(flags.size + 1)")]];
--- a/patterns/gltf.hexpat
+++ b/patterns/gltf.hexpat
@@ -0,0 +1,68 @@
+/**
+ * @file <gltf.pat> ImHex Pattern for glTF binary files.
+ * 
+ * Copyright (c) 2023 H. Utku Maden <utkumaden@hotmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma description TODO
+
+import std.mem;
+import std.io;
+
+/**
+ * @brief The glTF magic section.
+ */
+struct gltf_magic_t {
+    char magic[4];  /**< The magic value. Must be "glTF" */
+    u32 version;    /**< The version. Must be 2 for glTF 2.0. */
+    u32 length;     /**< Length of the file in bytes, including magic section. */
+};
+
+/**
+ * @brief Enumeration of well defined glTF chunks.
+ */
+enum gltf_chunk_type_t : u32 {
+    JSON = 1313821514 /* "JSON"  */,  /**< JSON chunk. */
+    BIN  = 5130562    /* "BIN\0" */,  /**< Binary data chunk. Could be an image or model data. */
+};
+
+/**
+ * @brief A glTF chunk.
+ */
+struct gltf_chunk_t {
+    u32 length;             /**< Length of this chunk. */
+    gltf_chunk_type_t type [[format("gltf_format")]]; /**< Type of the chunk. JSON or BIN expected. */
+    u8 string[length];      /**< The chunk data. */
+};
+
+fn gltf_format(gltf_chunk_type_t x)
+{
+         if (x == gltf_chunk_type_t::JSON) return "JSON";
+    else if (x == gltf_chunk_type_t::BIN) return "BIN";
+    
+    return "";
+};
+
+gltf_magic_t magic @ 0x00;
+gltf_chunk_t chunks[while(!std::mem::eof())] @ $;
+
+if (magic.magic != "glTF")
+    std::error("This file might not be a glTF file, expected \"glTF\", got %s", magic.magic);
--- a/patterns/gzip.hexpat
+++ b/patterns/gzip.hexpat
@@ -3,10 +3,10 @@

 #pragma MIME application/gzip

-#include <type/time.pat>
-#include <type/size.pat>
-#include <std/core.pat>
-#include <std/mem.pat>
+import type.time;
+import type.size;
+import std.core;
+import std.mem;

 using BitfieldOrder = std::core::BitfieldOrder;

--- a/patterns/hinf_luas.hexpat
+++ b/patterns/hinf_luas.hexpat
@@ -0,0 +1,441 @@
+#pragma author Surasia
+#pragma description Halo Infinite HavokScript 5.1 "luas" file
+
+import std.io;
+import std.mem;
+import std.core;
+import std.string;
+
+struct String32 {
+    s32 length;
+    if (length != 0) {
+        char s[length - 1];
+        u8 endbyte;
+    }
+};
+
+struct String64 {
+    s64 length;
+    if (length != 0) {
+        char s[length - 1];
+        u8 endbyte;
+    }
+};
+
+enum lua_endian : u8 {
+    little_endian = 1,
+    big_endian = 0,
+};
+    
+enum lua_numbertype : u8 {
+    _float = 0,
+    _int32 = 1,
+};
+
+struct lua_enum {
+    s32 value;
+    String32 string;
+};
+
+struct LuaEnum {
+    s32 count;
+    lua_enum entries[count];
+    };
+
+enum HksOpCode : s8 {
+        GETFIELD,
+        TEST,
+        CALL_I,
+        CALL_C,
+        EQ,
+        EQ_BK,
+        GETGLOBAL,
+        MOVE,
+        SELF,
+        RETURN,
+        GETTABLE_S,
+        GETTABLE_N,
+        GETTABLE,
+        LOADBOOL,
+        TFORLOOP,
+        SETFIELD,
+        SETTABLE_S,
+        SETTABLE_S_BK,
+        SETTABLE_N,
+        SETTABLE_N_BK,
+        SETTABLE,
+        SETTABLE_BK,
+        TAILCALL_I,
+        TAILCALL_C,
+        TAILCALL_M,
+        LOADK,
+        LOADNIL,
+        SETGLOBAL,
+        JMP,
+        CALL_M,
+        CALL,
+        INTRINSIC_INDEX,
+        INTRINSIC_NEWINDEX,
+        INTRINSIC_SELF,
+        INTRINSIC_LITERAL,
+        INTRINSIC_NEWINDEX_LITERAL,
+        INTRINSIC_SELF_LITERAL,
+        TAILCALL,
+        GETUPVAL,
+        SETUPVAL,
+        ADD,
+        ADD_BK,
+        SUB,
+        SUB_BK,
+        MUL,
+        MUL_BK,
+        DIV,
+        DIV_BK,
+        MOD,
+        MOD_BK,
+        POW,
+        POW_BK,
+        NEWTABLE,
+        UNM,
+        NOT,
+        LEN,
+        LT,
+        LT_BK,
+        LE,
+        LE_BK,
+        CONCAT,
+        TESTSET,
+        FORPREP,
+        FORLOOP,
+        SETLIST,
+        CLOSE,
+        CLOSURE,
+        VARARG,
+        TAILCALL_I_R1,
+        CALL_I_R1,
+        SETUPVAL_R1,
+        TEST_R1,
+        NOT_R1,
+        GETFIELD_R1,
+        SETFIELD_R1,
+        NEWSTRUCT,
+        DATA,
+        SETSLOTN,
+        SETSLOTI,
+        SETSLOT,
+        SETSLOTS,
+        SETSLOTMT,
+        CHECKTYPE,
+        CHECKTYPES,
+        GETSLOT,
+        GETSLOTMT,
+        SELFSLOT,
+        SELFSLOTMT,
+        GETFIELD_MM,
+        CHECKTYPE_D,
+        GETSLOT_D,
+        GETGLOBAL_MEM,
+    };
+    
+enum HksType : u8
+    {
+        TNIL,
+        TBOOLEAN,
+        TLIGHTUSERDATA,
+        TNUMBER,
+        TSTRING,
+        TTABLE,
+        TFUNCTION,
+        TUSERDATA,
+        TTHREAD,
+        TIFUNCTION,
+        TCFUNCTION,
+        TUI64,
+        TSTRUCT
+    };
+
+bitfield REG_CONST_UNUSED {
+    argB : 17 & 0x1ffff;
+    argA : 8 & 0xff;
+};
+
+bitfield REG_NUM_NUM {
+    argC : 9 & 0x1ff;
+    argB : 8 & 0xff;
+    argA : 8 & 0xff;
+};
+
+bitfield REG_NUM_UNUSED {
+    argB : 8 & 0xff;
+    argA : 8 & 0xff;
+    argC : 9 & 0x1ff;
+};
+
+bitfield UNUSED_OFFSET_UNUSED {
+    argA : 8 & 0xff;
+    argB : 9 & 0x1ff;
+    argC : 8 & 0xff;
+};
+
+
+bitfield LuaBitfield {
+    HksOpCode OpCode : 7;
+    //Arguments : 25; // read on how to process them at https://raw.githubusercontent.com/soupstream/havok-script-tools/main/HavokScriptToolsCommon/HksOpCodes.cs
+    match(OpCode) {
+        (HksOpCode::LOADK) : REG_CONST_UNUSED arguments;
+        (HksOpCode::SETGLOBAL) : REG_CONST_UNUSED arguments;
+        (HksOpCode::NEWTABLE) : REG_NUM_NUM arguments;
+        (HksOpCode::CLOSURE) : REG_CONST_UNUSED arguments;
+        (HksOpCode::RETURN) : REG_NUM_UNUSED arguments;
+        (HksOpCode::NEWSTRUCT) : REG_NUM_NUM arguments;
+        (HksOpCode::DATA) : UNUSED_OFFSET_UNUSED arguments;
+        (_): arguments : 25;
+    }
+};
+
+struct LuaInstruction {
+    LuaBitfield OpCode;
+};
+
+struct LuaConstant {
+    HksType type;
+    if (type == HksType::TNIL) {
+    }
+    else if (type == HksType::TSTRING) {
+        String64 string;
+    }
+    else if (type == HksType::TNUMBER) {
+        float number;
+    }
+    else if (type == HksType::TBOOLEAN) {
+        bool boolean;
+    }
+    else if (type == HksType::TLIGHTUSERDATA) {
+        s64 userdata;
+    } 
+    else {
+        s64 data;
+    } 
+};
+
+struct HksLocal {
+    String64 string;
+    u32 start;
+    u32 end;
+};
+
+
+struct LuaFunction {
+   
+    s32 upvaluecount;
+    s32 paramcount;
+    s8 isVarArg;
+    s32 slotCount;
+    s32 unk;
+    s32 instruction_count;
+    if ($ % 4 != 0) {
+        $ += (4 - ($ % 4));
+    }
+    LuaInstruction instructions[instruction_count];
+    s32 constantCount;
+    LuaConstant constants[constantCount];;
+    s32 HasDebugInfo;
+    if (HasDebugInfo != 0) {
+        u32 LineCount;
+        u32 LocalsCount;
+        u32 UpValueCount;
+        u32 LineBegin;
+        u32 LineEnd;
+        String64 path;
+        String64 functionName;
+        s32 Lines[LineCount];
+        HksLocal Locals[LocalsCount];
+        String64 UpValues[UpValueCount];
+    }
+    s32 function_count;
+    LuaFunction children[function_count];
+};
+
+
+
+struct LuaStructHeader {
+    String64 name;
+    s32 structID;
+    s32 pad;
+    s24 unk1;
+    HksType type;
+    s32 unk2;
+};
+
+
+struct LuaStructMember {
+    s32 pad;
+    LuaStructHeader header;
+    s32 index;
+};
+
+struct LuaStruct {
+    try {
+        u32 unk;
+        LuaStructHeader ExtendedStructHeader;
+        s64 ExtendedStructMemberCount;
+        LuaStructMember ExtendedStructMembers[ExtendedStructMemberCount];
+        u32 unk2;
+    } catch {
+        std::print("WARNING: this file does not support structs.");
+    }
+    try {
+        LuaStructHeader StructHeader;
+        s64 StructMemberCount;
+        LuaStructMember StructMembers[StructMemberCount];
+    } catch {
+        std::print("WARNING: this file does not support multiple structs.");
+    }
+};
+
+
+struct LuaHeader {
+    char luaheader[4];
+    u8 version;
+    u8 format;
+    lua_endian Endianness;
+    if (Endianness == lua_endian::big_endian) {
+        std::core::set_endian(std::mem::Endian::Big);
+    } else {
+        std::core::set_endian(std::mem::Endian::Little);
+    }
+    u8 intSize;
+    u8 size_tSize;
+    u8 instruction_size;
+    u8 number_size;
+    lua_numbertype numberType;
+    u8 flags;
+    u8 unknown;
+    LuaEnum enums;
+    LuaFunction LuaFunctions;
+    LuaStruct LuaStructures;
+};
+
+struct Header {
+    u32 magic;
+    u32 version;
+    u64 RootStructAltGUID;
+    u64 AssetChecksum;
+    u32 DependencyCount;
+    s32 DataBlockCount;
+    s32 TagStructCount;
+    s32 DataReferenceCount;
+    s32 TagReferenceCount;
+    u32 StringTableSize;
+    u32 ZoneSetDataSize;
+    u32 Unk_0x34;
+    u32 HeaderSize;
+    u32 DataSize;
+    u32 ResourceDataSize;
+    u32 ActualResoureDataSize;
+    u8 HeaderAlignment;
+    u8 TagDataAlignment;
+    u8 ResourceDataAlignment;
+    u8 ActualResourceDataAlignment;
+    s32 IsResource;
+};
+
+struct _s_tagblock {
+    char tagblock[16];
+    s32 count;
+};
+
+struct _s_resource {
+    char resource[12];
+    s32 count;
+};
+
+struct _s_data {
+    char data[24];
+};
+
+
+struct Data_Block {
+    u32 Size;
+    u16 Padding;
+    u16 Section;
+    u64 Offset;
+};
+
+struct Tag_Def_Structure {
+    s64 GUID_1;
+    s64 GUID_2;
+    u16 Type;
+    u16 Unk_0x12;
+    s32 TargetIndex;
+    s32 FieldBlock;
+    u32 FieldOffset;
+};
+
+struct Tag_Dependency {
+    char GroupTag[4] [[format("std::string::reverse")]];
+    u32 NameOffset;
+    u64 AssetID;
+    u32 GlobalID;
+    u32 Unk_0x14;
+};
+
+struct Data_Reference {
+    s32 ParentStructIndex;
+    s32 Unk_0x04;
+    s32 TargetIndex;
+    s32 FieldBlock;
+    u32 FieldOffset;
+};
+
+struct _s_tagref {
+    s64 GlobalHandle;
+    s32 ref_id_int;
+    s32 ref_id_sub;
+    s32 ref_id_center_int;
+    char TagGroupRev[4] [[format("std::string::reverse")]];
+    s32 local_handle;
+};
+
+struct Tag_Fixup_Reference {
+    s32 FieldBlock;
+    u32 FieldOffset;
+    u32 NameOffset;
+    s32 DependencyIndex;
+    _s_tagref tagreference @ header.HeaderSize + datablocks[FieldBlock].Offset + FieldOffset;
+};
+
+struct InternalStruct {
+    s64 vtablespace;
+    u32 global_tag_id;
+    char local_tag_handle[4];
+};
+
+struct LuaReferencedTagContainer {
+   _s_tagref tagReference;
+};
+struct LuaScriptTagDefinition {
+   u32 luaFileName;
+   _s_data luaFileData;
+   char luaFileNameString[256];
+   _s_tagblock referencedTags_count;
+   LuaHeader lua_header;
+   try {
+    char pad[14];
+    LuaReferencedTagContainer referencedTags[referencedTags_count.count]; 
+   } catch {
+    std::print("This file does not support referenced Tags.");
+   }
+};
+
+
+// TAG LAYOUT
+Header header @ 0x00;
+Tag_Dependency Dependencies[header.DependencyCount] @ 0x50;
+Data_Block datablocks[header.DataBlockCount] @ header.DependencyCount * 0x18 + 0x50;
+Tag_Def_Structure tagdefstructure[header.TagStructCount] @ header.DependencyCount * 0x18 + 0x50 + header.DataBlockCount * 0x10;
+Data_Reference Data_References[header.DataReferenceCount] @ header.DependencyCount * 0x18 + 0x50 + header.DataBlockCount * 0x10 + header.TagStructCount * 0x20;
+Tag_Fixup_Reference tagfixupreference[header.TagReferenceCount] @ header.DependencyCount * 0x18 + 0x50 + header.DataBlockCount * 0x10 + header.TagStructCount * 0x20 + header.DataReferenceCount * 0x14;
+char ZoneSet[header.ZoneSetDataSize] @ header.HeaderSize - header.ZoneSetDataSize;
+InternalStruct internalstruct @ header.HeaderSize;
+LuaScriptTagDefinition lua_script @ header.HeaderSize + 16;
--- a/patterns/hinf_module.hexpat
+++ b/patterns/hinf_module.hexpat
@@ -0,0 +1,77 @@
+#pragma author Surasia
+#pragma description Halo Infinite Module
+#pragma array_limit 4294967295
+#pragma pattern_limit 4294967295
+
+import std.string;
+
+struct ModuleHeader 
+{
+    char magic[4];
+    s32 version;
+    s64 moduleId;
+    u32 fileCount;
+    s32 manifest0Count;
+    s32 manifest1Count;
+    s32 manifest2Count;
+    s32 resourceIndex;
+    u32 stringSize;
+    u32 resourceCount;
+    u32 blockCount;
+    u64 buildVersion;
+    s64 hd1Delta;
+    u64 dataSize;
+};
+
+
+struct ModuleFile
+{
+    u32 resourceCount;
+    s32 parentIndex;
+    s16 pad;
+    u16 blockCount;
+    s32 blockIndex;
+    s32 resourceIndex;
+    char class[4] [[format("std::string::reverse")]];
+    u64 dataOffsetBytes;
+    u64 dataOffset = dataOffsetBytes & 0x0000FFFFFFFFFFFF [[export]];
+    u16 dataOffsetFlags = dataOffsetBytes >> 48 [[export]];
+    u32 totalCompressedSize;
+    u32 totalUncompressedSize;
+    u32 globalTagId;
+    u32 uncompressedHeaderSize;
+    u32 uncompressedTagDataSize;
+    u32 uncompressedResourceDataSize;
+    u32 uncompressedActualResourceDataSize;
+    u32 resourceBlockCount;
+    u32 nameOffset;
+    s32 parentResource;
+    u64 assetChecksum;
+    u64 assetId;
+};
+
+
+struct ModuleBlock
+{
+    u32 compressedOffset;
+    u32 compressedSize;
+    u32 decompressedOffset;
+    u32 decompressedSize;
+    bool compressed;
+    s24 pad;
+};
+
+
+struct Module
+{
+    ModuleHeader module_header;
+    ModuleFile files[module_header.fileCount];
+    $ = $ + 8;
+    s32 resources[module_header.resourceCount];
+    ModuleBlock blocks[module_header.blockCount]; 
+    padding[while($[$] == 0)];
+    std::print("Compressed Tag Data starts at: {}", $);
+};
+
+
+Module module_root @ 0x00;
--- a/patterns/hinf_tag.hexpat
+++ b/patterns/hinf_tag.hexpat
@@ -0,0 +1,168 @@
+#pragma author Surasia
+#pragma description Halo Infinite Tag File
+
+import std.string;
+import type.guid;
+
+u32 fileStart = 0;
+
+enum TagSectionType : u16
+{
+    header,
+    tagData,
+    resourceData
+};
+
+
+enum TagStructType : u16
+{
+    mainStruct,
+    tagBlock,
+    resource,
+    custom,
+    literal
+};
+
+
+struct TagHeader
+{
+    char magic[4];
+    s32 version;
+    u64 hash;
+    u64 checksum;
+    u32 dependencyCount;
+    u32 dataBlockCount;
+    u32 tagStructCount;
+    u32 dataReferenceCount;
+    u32 tagReferenceCount;
+    u32 stringTableSize;
+    u32 zoneSetDataSize;
+    u32 unknown0;
+    u32 headerSize;
+    fileStart = headerSize;
+    u32 dataSize;
+    u32 resourceDataSize;
+    u32 actualResourceDataSize;
+    u8 headerAlignment;
+    u8 tagDataAlignment;
+    u8 resourceDataAlignment;
+    u8 actualResourceAlignment;
+    u32 unknown1;
+};
+
+
+struct TagDependency
+{
+    char tagGroup[4] [[format("std::string::reverse")]];
+    u32 nameOffset;
+    u64 assetId;
+    u32 globalId;
+    u32 parentTag;
+};
+
+
+struct TagDataBlock
+{
+    u32 entrySize;
+    u16 pad;
+    TagSectionType section;
+    u64 offset;
+    if (section == TagSectionType::tagData)
+    {
+        char dataBlock[entrySize] @ fileStart + offset;
+    }
+};
+
+
+struct TagStruct
+{
+    type::GUID guid;
+    TagStructType type;
+    u16 unknown0;
+    s32 targetIndex;
+    s32 fieldBlockIndex;
+    u32 fieldOffset;
+};
+
+
+struct TagDataReference
+{
+    s32 parentStructIndex;
+    s32 unknown0;
+    s32 targetIndex;
+    s32 fieldBlockIndex;
+    u32 fieldOffset;
+};
+
+
+struct TagReference
+{
+    s32 fieldBlockIndex;
+    u32 fieldOffset;
+    u32 nameOffset;
+    s32 dependencyIndex;
+};
+
+
+struct TagZonesetHeader
+{
+    s32 version;
+    u32 zonesetCount;
+    u32 footerCount;
+    s32 parentCount;
+};
+
+
+struct TagZonesetInstanceHeader
+{
+    s32 stringId;
+    u32 tagCount;
+    u32 parentCount;
+    u32 footerCount;
+};
+
+
+struct TagZonesetTag
+{
+    u32 globalId;
+    s32 stringId;
+
+};
+
+
+struct TagZonesetInstance
+{
+    TagZonesetInstanceHeader header;
+    TagZonesetTag tags[header.tagCount];
+    TagZonesetTag footers[header.footerCount];
+    s32 parents[header.parentCount];
+
+};
+
+
+struct TagZoneset
+{
+    TagZonesetHeader zoneset_header;
+    TagZonesetInstance instances[zoneset_header.zonesetCount];
+};
+
+
+struct Tag
+{
+    TagHeader header;
+    TagDependency dependencies[header.dependencyCount];
+    TagDataBlock data_blocks[header.dataBlockCount];
+    TagStruct tag_structs[header.tagStructCount];
+    TagDataReference data_references[header.dataReferenceCount];
+    TagReference tag_references[header.tagReferenceCount];
+    TagZoneset zonesets;
+    if (header.headerSize != $)
+    {
+        std::print("Header size is wrong, additional data in tag");
+        $ = header.headerSize;
+        std::print("Data offset now at: {}", $);
+    }
+};
+
+
+Tag tag_root @ 0x00;
--- a/patterns/ico.hexpat
+++ b/patterns/ico.hexpat
@@ -3,7 +3,7 @@

 #pragma endian little

-#include <std/sys.pat>
+import std.sys;

 #pragma MIME image/vnd.microsoft.icon
 #pragma MIME image/x-icon
--- a/patterns/id3.hexpat
+++ b/patterns/id3.hexpat
@@ -2,7 +2,7 @@

 #pragma MIME audio/mpeg

-#include <std/mem.pat>
+import std.mem;

 namespace v1 {

--- a/patterns/intel_hex.hexpat
+++ b/patterns/intel_hex.hexpat
@@ -1,4 +1,4 @@
-#pragma description [Intel hexadecimal object file format definition]("https://en.wikipedia.org/wiki/Intel_HEX")
+#pragma description Intel hexadecimal object file format definition

 /* If you have no delimiters between data records then remove 
 * the null_bytes field in the data_packet struct.
@@ -8,7 +8,7 @@
 */
 #pragma endian big

-#include <std/mem.pat>
+import std.mem;

 enum FileType: u16 {
 	Data = 0x3030,
--- a/patterns/ip.hexpat
+++ b/patterns/ip.hexpat
@@ -3,8 +3,8 @@

 #pragma endian big

-#include <std/sys.pat>
-#include <std/io.pat>
+import std.sys;
+import std.io;

 struct MAC {
 	u8 octets[6];
@@ -132,7 +132,7 @@ namespace ip {
 			if (flags.data_offset > 5)
 				u8 options[(flags.data_offset - 5) * sizeof(u32)];
 				
-			u8 data[parent.parent.header.total_length - 40];
+			u8 data[parent.parent.header.total_length - parent.parent.header.ihl * 4 - flags.data_offset * 4];
 		};
 	
 	}
--- a/patterns/ips.hexpat
+++ b/patterns/ips.hexpat
@@ -1,16 +1,15 @@
+#pragma author gmestanley
 #pragma description IPS (International Patching System) files

-#include <std/mem.pat>
-#include <std/string.pat>
-
 #pragma endian big

-u8 eofOffset = 3;
+import std.mem;
+import std.string;

 struct Hunk {
 	u24 offset;
 	u16 length;
-	if (length == 0) {
+	if (!length) {
 		u16 runCount;
 		u8 payload;
 	}
@@ -21,12 +20,9 @@ struct Hunk {

 struct IPS {
 	char signature[5];
-	if (std::mem::read_string(std::mem::size()-3, 3) != "EOF") {
-		eofOffset += 3;
-	}
-	Hunk hunks[while($ < std::mem::size()-eofOffset)];
+	Hunk hunks[while($ < std::mem::size() - (3 + 3 * (std::mem::read_string(std::mem::size()-3, 3) != "EOF")))];
 	char eof[3];
-	u24 truncatedSize[eofOffset>3];
+	u24 truncatedSize[3+(std::mem::read_string(std::mem::size()-3, 3) != "EOF")>3];
 };

-IPS ips @ 0x00;
+IPS ips @ 0x00;
--- a/patterns/iso.hexpat
+++ b/patterns/iso.hexpat
@@ -2,7 +2,7 @@

 #pragma endian little

-#include <std/io.pat>
+import std.io;

 enum VolumeDescriptorTypes : u8 {
  BootRecord,
--- a/patterns/java_class.hexpat
+++ b/patterns/java_class.hexpat
@@ -5,11 +5,11 @@
 #pragma pattern_limit 100000000
 #pragma MIME application/x-java-applet

-#include <std/string.pat>
-#include <std/math.pat>
-#include <std/core.pat>
-#include <std/io.pat>
-#include <std/sys.pat>
+import std.string;
+import std.math;
+import std.core;
+import std.io;
+import std.sys;

 using BitfieldOrder = std::core::BitfieldOrder;

--- a/patterns/jpeg.hexpat
+++ b/patterns/jpeg.hexpat
@@ -1,7 +1,9 @@
 #pragma author WerWolv
 #pragma description JPEG Image Format

-#include <std/mem.pat>
+import std.io;
+import std.mem;
+import type.magic;
 #pragma endian big

 #pragma MIME image/jpeg
@@ -39,7 +41,8 @@ enum Marker : u8 {
    APP13   = 0xED,
    APP14   = 0xEE,
    APP15   = 0xEF,
-    COM     = 0xFE
+    COM     = 0xFE,
+    UNKNOWN = 0X00
 };

 enum DensityUnit : u8 {
@@ -48,6 +51,12 @@ enum DensityUnit : u8 {
    PixelsPerCm = 0x02
 };

+enum ColorTransform : u8 {
+    Unknown = 0x00,
+    YCbCr = 0x01,
+    YCCK = 0x02
+};
+
 struct Pixel {
    u8 r, g, b;
 } [[sealed, transform("transform_pixel")]];
@@ -58,7 +67,7 @@ fn transform_pixel(Pixel pixel) {


 struct APP0 {
-    char magic[5];
+    type::Magic<"JFIF\x00"> magic;
    u8 versionMajor, versionMinor;
    DensityUnit densityUnit;
    u16 densityX, densityY;
@@ -66,18 +75,42 @@ struct APP0 {
    Pixel thumbnail[thumbnailX * thumbnailY] [[sealed]];
 };

+struct APP14 {
+    type::Magic<"Adobe"> magic;
+    u16 version;
+    u16 flags0;
+    u16 flags1;
+    ColorTransform transform;
+};
+
 enum ComponentId : u8 {
    Y   = 1,
    CB  = 2,
    CR  = 3,
    I   = 4,
-    Q   = 5
+    Q   = 5,
+    B   = 66,
+    G   = 71,
+    R   = 82
 };

 struct SOF0Component {
    ComponentId componentId;
    u8 samplingFactors;
    u8 quantizationTableId;
+} [[format_read("sof0_component_read")]];
+
+fn sof0_component_read(SOF0Component c) {
+    return std::format("({}, {}, {})", c.componentId, c.samplingFactors, c.quantizationTableId);
+};
+
+fn get_eoi_marker_position() {
+    u32 pos = std::mem::find_sequence_in_range(0, $, std::mem::size(), 0xFF);
+    while (std::mem::read_unsigned(pos + 1, 1) != 0xD9) {
+        pos = std::mem::find_sequence_in_range(0, pos + 1, std::mem::size() + 1, 0xFF);
+    }
+    return pos;
+    
 };

 struct SOF0 {
@@ -98,28 +131,40 @@ struct SOS {
    u8 startSpectralSelection;
    u8 endSpectral;
    u8 apprBitPos;
-    
-    u8 image_data[while(!std::mem::eof())] [[sealed]];
+    u8 image_data[get_eoi_marker_position() - $] [[sealed]];
 };

 struct Segment {
-    u8 magic;
-    Marker marker;
-    
-    if (marker == Marker::SOI || marker == Marker::EOI) {
-        
+    if (std::mem::read_unsigned($, 1) != 0xFF) {
+        Marker marker = Marker::UNKNOWN;
+        u8 data[get_eoi_marker_position() - $];
    } else {
-        u16 length;
-        if (marker == Marker::APP0) {
-            APP0 data;
-        } else if (marker == Marker::SOF0) {
-            SOF0 data;
-        } else if (marker == Marker::SOS) {
-            SOS data;
+        type::Magic<"\xff"> magic;
+        Marker marker;
+        
+        if (marker == Marker::SOI || marker == Marker::EOI) {
+            
        } else {
-            u8 data[length - sizeof(length)] [[sealed]];
+            u16 length;
+            if (marker == Marker::APP0) {
+                APP0 data;
+            } else if (marker == Marker::APP14) {
+                APP14 data;
+            } else if (marker == Marker::COM) {
+                char data[length - sizeof(length)];
+            } else if (marker == Marker::SOF0) {
+                SOF0 data;
+            } else if (marker == Marker::SOS) {
+                SOS data;
+            } else {
+                u8 data[length - sizeof(length)] [[sealed]];
+            }
        }
    }
+} [[format_read("segment_read")]];
+
+fn segment_read(Segment s) {
+    return std::format("{}", s.marker);
 };

-Segment segments[while(!std::mem::eof())] @ 0x00 [[hex::visualize("image", this)]];
+Segment segments[while(!std::mem::eof())] @ 0x00 [[hex::visualize("image", this)]];
--- a/patterns/lnk.hexpat
+++ b/patterns/lnk.hexpat
@@ -3,9 +3,9 @@

 #pragma MIME application/x-ms-shortcut

-#include <std/core.pat>
-#include <type/guid.pat>
-#include <type/size.pat>
+import std.core;
+import type.guid;
+import type.size;

 using BitfieldOrder = std::core::BitfieldOrder;

--- a/patterns/lua54.hexpat
+++ b/patterns/lua54.hexpat
@@ -1,7 +1,7 @@
 #pragma description Lua 5.4 bytecode

-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;

 namespace impl {

--- a/patterns/macho.hexpat
+++ b/patterns/macho.hexpat
@@ -3,7 +3,7 @@

 #pragma MIME application/x-mach-binary

-#include <type/size.pat>
+import type.size;

 enum Magic : u32 {
    _32BitMagic = 0xFEEDFACE,
--- a/patterns/max_v104.hexpat
+++ b/patterns/max_v104.hexpat
@@ -1,7 +1,7 @@
 #pragma description Mechanized Assault and Exploration v1.04 (strategy game) save file format

-#include <std/sys.pat>
-#include <std/mem.pat>
+import std.sys;
+import std.mem;

 #pragma array_limit 12544
 #pragma pattern_limit 2000000
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
WerWolv	4299243e95	includes/std: Added hex::dec::lz4_decompress()	2024-07-07 15:51:40 +02:00
Surasia	23b3c2b5d0	git: Fix hinf_tag and hinf_module links in readme (#268 )	2024-07-07 13:44:04 +02:00
Surasia	da1c2687e8	patterns/hinf_: Add Halo Infinite tag and module file patterns (#267 ) patterns/hinf: Add Halo Infinite Tag and Module patterns * patterns/hinf_bitmap: remove pattern	2024-07-06 17:33:03 +02:00
WerWolv	18f968df5b	includes/std: Drastically improved `std::mem::MagicSearch`, added find_string and find_string_in_range	2024-07-04 20:47:39 +02:00
WerWolv	f797c711ca	includes/std: Optimize std::bit::popcount	2024-07-04 17:58:12 +02:00
WerWolv	5380877da4	tests: Added error message when no description is used	2024-07-04 08:28:20 +02:00
Marc Butler	bb46276bde	patterns: Added Password Safe Version 3 pattern (#266 ) * Add password safe V3 * Added description pragma --------- Co-authored-by: Nik <werwolv98@gmail.com>	2024-07-04 08:27:51 +02:00
Nik	4242869ac1	patterns/zlib: Cast bitfield enums to integers before doing math with them	2024-07-03 22:48:15 +02:00
WerWolv	8bdcd814a9	includes/std: Added std::unimplemented()	2024-07-02 18:00:52 +02:00
WerWolv	d7811ff5e9	patterns: Replaced old bitfield order attributes with new ones Fixes #265	2024-07-02 18:00:41 +02:00
WerWolv	4d0b3e21bc	includes/std: Added better documentation to std::mem::current_bit_offset()	2024-07-02 18:00:05 +02:00
WerWolv	acd6903b21	includes/std: Added crc8, crc16 and crc64 functions Fixes #226	2024-07-02 17:59:40 +02:00
WerWolv	8d2a39f7d4	git: Added build folders to gitignore	2024-07-02 17:58:47 +02:00
Nik	65ef3a7783	includes/std: Removed cyclic dependency between std.mem and std.string	2024-07-01 23:47:09 +02:00
Nik	21a0b99eac	includes/std: Added missing string include to std::mem	2024-06-29 23:25:58 +02:00
Rebuild	a33b68921d	patterns: Added ttf/otf format (#263 ) * Add ttf/otf format * ttf: Put cff to preprocessing	2024-06-29 22:52:21 +02:00
Nik	a0bb71be58	includes/std: Added std::core::execute_function()	2024-06-29 11:53:43 +02:00
WerWolv	c7fc39ac19	git: Make sure test data is always treated as binaries	2024-06-26 20:59:41 +02:00
WerWolv	b540ead0ae	includes/std: Added std::IIndexed as a nicer wrapper around std::core::array_index()	2024-06-25 22:52:57 +02:00
Nik	26878548f0	includes/std: Fixed NullString not including null terminator and not checking for string end correctly	2024-06-23 18:45:13 +02:00
C3pa	e4c9d86755	includes/std: Add some fixes from the WerWolv/Documentation repo (#262 ) * Escape backslash in DOSPath docs * Spelling correction for std\sys.pat --------- Co-authored-by: Nik <werwolv98@gmail.com>	2024-06-22 10:59:36 +02:00
WerWolv	2a3de1b705	includes: Tabs -> Spaces	2024-06-22 10:46:30 +02:00
WerWolv	e02280f9ee	includes/type: Added arbitrarily formattable type	2024-06-20 21:21:42 +02:00
WerWolv	bbba68cef7	includes/std: Added null-terminated strings to the strings library	2024-06-20 21:21:30 +02:00
Joachim Schiele	28b281b403	patterns/pe: Added .didata section support (#257 )	2024-06-16 15:23:01 +02:00
Kirill Gladkikh	c807959d75	patterns/jpeg: Support EOF in the middle of JPEG (#240 ) * Support EOF in the middle of file * Changed to eoi marker searching	2024-06-16 15:16:01 +02:00
Francisco J. Solis	3416d30f2b	pattern/dds: Fix bitfield PixelFormatFlags (#259 ) * Fix bitfield PixelFormatFlags The padding names should not repeat Comments should be added to each field for clarification Padding should be corrected for luminance. * Re-work of PixelFormatFlags Add more information considering current GIMP repository structure https://gitlab.gnome.org/GNOME/gimp/-/blame/master/plug-ins/file-dds/dds.h\#L145	2024-06-09 22:15:05 +02:00
iTrooz	10bf1c76cf	chore: mention description pragma in PR template	2024-05-20 01:05:48 +02:00
iTrooz	5b7c212029	git: use ccache (#253 )	2024-05-20 01:01:59 +02:00
iTrooz	1c2e948940	test: Make description pragma mandatory (#251 )	2024-05-20 00:35:24 +02:00
iTrooz	7ea34e410a	fix: add missing ; to core.pat	2024-05-20 00:13:52 +02:00
iTrooz	56950e44d8	fix: use renamed PatternRuntime::getEvalError() (#252 )	2024-05-20 00:10:34 +02:00
iTrooz	ed42452fc1	chore: remove old coverage code	2024-05-20 00:01:36 +02:00
iTrooz	a68ecb8888	fix: run tests concurrently	2024-05-20 00:01:00 +02:00
WerWolv	8d4cf59497	patterns/ffx: Updated submodule	2024-05-19 17:05:56 +02:00
Benjamin Gilbert	3c2fed22e4	patterns: Add Windows animated cursor (#242 ) * patterns: Add Windows animated cursor * Added readme entry * Added mime type to readme --------- Co-authored-by: Nik <werwolv98@gmail.com>	2024-05-19 16:58:03 +02:00
Christoph Koehler	ff550bd105	patterns: Add Digital Terrain Elevation Data (DTED) pattern file (#243 ) Tested on DTED0 and DTED2, will likely work with DTED1 as well.	2024-05-19 16:55:30 +02:00
Rebuild	0ad6e3abde	patterns/mp4: Use FixedPoint32 instead of u32 for width and height (#248 ) Update mp4.hexpat * Use FixedPoint32 instead of u32 for width and height * Add formatting for displaying fixed point 16.16 and 8.8 numbers	2024-05-19 16:55:04 +02:00
Marijn Kneppers	891968db53	includes/std: Add create_directories to std (#250 )	2024-05-19 16:46:05 +02:00
Marijn Kneppers	5799d1d7ea	includes/std: Make std::file::flush not delete files (#246 )	2024-05-12 23:39:49 +02:00
Marijn Kneppers	9c6bfeb50f	includes/hex: Added hex::core::add_virtual_file (#247 )	2024-05-12 23:38:57 +02:00
AdventureT	9f7cdded6a	Crashlvl: Added support for version 0.95 (#245 ) * Working on new Version * Needs testing * Updated CrashLvl script to support version 0.94c * Update README.md * Added TestData and author to script * Delete tests/patterns/test_data/CrashLvl.hexpat.bin * CrashLvl.hexpat: Added support for version 0.95	2024-05-12 23:38:25 +02:00
Claudius Coenen	03298b0b0c	patterns: Added Wintec TES file pattern (#238 )	2024-04-21 12:33:19 +02:00
LolHacksRule	5f2738872e	patterns: Added XGSPak and XGSTexture patterns (#237 ) * Add XGSPak and XGSTexture patterns * Whoops forgot proper pointers * Fix typo * Whoops * Proper start * Update xgstexture.hexpat	2024-04-21 12:32:26 +02:00
nazDridoy	63585e6de7	patterns/7z: Added MIME type (#241 )	2024-04-21 12:25:00 +02:00
Sabhya Raj Mehta	cb6caafa64	patterns/refs: Added Structure for MinStoreB+ node, missing GlobalRootNode Names & parses all Superblocks (#236 ) [+] Added Structure for MinStoreB+ node, Missing GlobalRootNode Names	2024-03-29 11:55:01 +01:00
Leon Jacobs	236fadee47	patterns: Added gguf pattern (#235 ) * (feat) add gguf parser * (chore) cleanup empty struct * (tests) add sample gguf for tests and update readme * (feat) update type enum	2024-03-28 21:55:18 +01:00
GlorifiedPig	0549e62a14	patterns/tar: Fixed minor typo (#230 ) changes "if" to "id"	2024-03-21 22:16:37 +01:00
Sabhya Raj Mehta	b4bf2b946f	patterns/refs: Added filesystem Checking, comments, Renamed REFS_HEADER, and Fixed typo. (#231 ) Added FileSystem Checking and comments && renamed struct ReFSHeader to VolumeBootRecord && Fixed Typo	2024-03-21 22:16:15 +01:00
Zwip-Zwap Zapony	5e82bfadac	includes/std: Replace get_attribute_value with get_attribute_argument (#233 ) Update get_attribute_argument/get_attribute_value Replace std::core::get_attribute_value with std::core::get_attribute_argument Mark optional arguments with square brackets in the documentation comments, and list their default values	2024-03-21 21:48:53 +01:00
Sabhya	a5c9f3b18a	patterns: Added ReFS filesystem pattern (#229 ) Added Pattern File For Parsing ReFS filesystem Header, SuperBlock and CheckPoint && updated README.md	2024-03-17 10:19:18 +01:00
Nik	38262e6bb9	tests/patterns: Moved xilinx bootgen test file to correct folder	2024-03-16 10:24:09 +01:00
Nik	0a37b60d70	git: Mark all test files as binary	2024-03-16 10:22:51 +01:00
Shadlock0133	345e264ff8	patterns: Add .bgcode file (#222 ) Support for binary G-code files, used by 3d printers	2024-03-15 21:54:58 +01:00
syuuha	ba2c396534	patterns: Added pattern for ADTS files (#223 )	2024-03-15 21:54:41 +01:00
paxcut	439f04e19b	includes/std: Fixed "unknown function fm" error was shown in pattern data. (#225 )	2024-03-15 21:54:03 +01:00
ogmini	eaeea8d093	patterns: Added pattern for Windows 11 Notepad Window State bin file (#228 ) * Add files via upload * Update README.md * Update README.md * Add files via upload * Update Notepad-WindowState.hexpat * Update and rename Notepad-WindowState.hexpat to notepadwindowstate.hexpat * Rename Notepad-WindowState.hexpat.bin to notepad-windowstate.hexpat.bin * Update README.md	2024-03-15 21:53:40 +01:00
Nik	9af8d7e693	includes/std: Added back #pragma once to mem library	2024-02-27 20:28:02 +01:00
WerWolv	dac2e0f786	patterns: Fixed a few errors	2024-02-25 22:59:32 +01:00
Nik	f70b7066b9	includes: Switch over to import statements (#224 ) * Update includes and patterns to new import system * Update namespaces to new syntax	2024-02-25 22:04:41 +01:00
WerWolv	3f44a743e8	yara: Added advanced analysis rules	2024-02-25 11:29:59 +01:00
WerWolv	834e5261b3	tests: Fixed tests not building	2024-02-18 13:07:04 +01:00
Nik	0e2966f10d	includes/std: Added missing `std::core::set_pattern_comment` function	2024-02-09 13:23:51 +01:00
Nik	b2bc248447	includes/hex: SectionId -> Section	2024-01-31 08:24:03 +01:00
Nik	e6589ecba1	includes/std: Make std::mem::read_string take in a larger size	2024-01-31 08:22:25 +01:00
apewo	f75ba4b6ee	patterns/pe: Add extra MIME Type (#220 ) add pe mime Co-authored-by: John Doe <bla@bla.bla>	2024-01-29 18:36:21 +01:00
Nik	cf18580960	includes/hex: Added decompress functions	2024-01-27 17:05:08 +01:00
lucia c	e7d1973957	patterns: Added SWF header pattern (#219 ) * patterns: Added pattern for SWF files. * Added test file for SWF header. * Update README with SWF file type.	2024-01-27 15:53:16 +01:00
t1hq	35cc68544b	encodings: Add custom encoding file for Big5 (#218 ) * add big5 encoding table * add notes for big5 encoding, and how to import custom encoding file	2024-01-27 11:18:47 +01:00
Nik	41d8967deb	patterns/pyc: Remove unused function	2024-01-20 22:14:47 +01:00
pew	658ec20b37	patterns: Add .ras pattern (#216 ) * Add simple .ras file pattern * Update ras.hexpat * Update README.md * Add .ras test file * Update ras.hexpat * Update ras.hexpat * Update ras.hexpat * Update ras.hexpat	2024-01-10 00:38:18 +01:00
paxcut	fb5fcbafc1	includes/type: Changes to magic type to include address of failed asserts. (#217 )	2024-01-10 00:36:17 +01:00
Brandon Maier	6f7988e96e	patterns: Added Xilinx boot images (#210 ) * Adds pattern for Xilinx's Zynq UltraScale+ Boot Image format. * Boot images are generated by Xilinx's `bootgen` tool. * Spec: Xilinx UG1283 https://docs.xilinx.com/r/en-US/ug1283-bootgen-user-guide/Zynq-UltraScale-MPSoC-Boot-and-Configuration * Add test file generated as follows - Build bootgen tool from https://github.com/Xilinx/bootgen - Create dummy data with `dd if=/dev/zero of=image.bin count=1` - Create bif with `echo "img: {image.bin}" >image.bif` - Create test bin with `./bootgen -arch zynqmp -image image.bif -o xilinx_bootgen.hexpat.bin`	2023-12-28 18:32:13 +01:00
g4ngli0s	0a631f0c1f	patterns/pe: Fix BaseRelocationBlock count inside BaseRelocationTable (#212 )	2023-12-28 18:31:53 +01:00
EvelynTSMG	5942897c29	patterns/ffx: Pull in latest updates (#209 ) * Add Final Fantasy X patterns * Update README * Fix: github dum * Add Bastion patterns * git: update submodules --------- Co-authored-by: Nik <werwolv98@gmail.com>	2023-12-22 14:02:37 +01:00
utkumaden	a7e6209791	patterns: Added gITF pattern(#205 ) * Create gltf.hexpat Added glTF binary file pattern. * Add a test file for the glTF pattern. * Renamed the test file to fit the pattern file name. * Fixed typo in documentation.	2023-12-07 17:09:25 +01:00
EvelynTSMG	294f69fa36	patterns: Add Bastion patterns (#207 ) * Add Final Fantasy X patterns * Update README * Fix: github dum * Add Bastion patterns --------- Co-authored-by: Nik <werwolv98@gmail.com>	2023-12-07 16:38:32 +01:00
gmestanley	1ea12cd4bd	patterns/pe: Bringing over the massively improved version of pe.hexpat (#204 ) * Add files via upload * Update README.md Added nes.hexpat to list of hex patterns * Fix indenting of hex patterns list Moved nes.hexpat below NE.hexpat * Update README.md Fixed indenting of PP pattern file's description being wrong * Added x-msdownload MIME type to PE description * Made indenting & code of ips.hexpat better * Improvements to gb.hexpat * Urgent fix to ips.hexpat * Urgent fix to gb.hexpat * Massive pe.hexpat improvement * Replaced virtualDifference with relativeVirtualDifference * Fixing unnecessary pattern_limit	2023-12-07 16:36:50 +01:00
Surasia	8129504dcb	patterns/hinf_luas: Added pattern for reading HavokScript 5.1 Bytecode from Halo Infinite (#203 ) * patterns/hinf_luas: Added pattern for reading HavokScript 5.1 Bytecode from Halo Infinite * Parses Header and Structures of the parent tag * Reads Bytecode types and arguments * Reads Constants and Debug Info * Reads Referenced Tags in the File * readme: fix relative link	2023-12-07 16:36:27 +01:00
klirktag	22e30cfef9	patterns/mp4: Add STBL-box children (#202 ) add STBL-box children	2023-12-07 16:36:07 +01:00
EvelynTSMG	9b819cf392	patterns: Add Final Fantasy X patterns (#197 ) * Add Final Fantasy X patterns * Update README * Fix: github dum	2023-11-20 11:54:56 +01:00
klirktag	3277821153	patterns/mp4: Support mp4a and avc1 codec boxes (#195 ) add support for mp4a and avc1 codec boxes, and sample-time-to-sample box	2023-11-15 22:26:10 +01:00
paxcut	f23dbbb565	includes/std: Fixed std::string::replace not replacing sequences correctly (#198 ) fix: [Bug] std::string::replace("aa", "aa", "") returns "a" #1408	2023-11-15 22:25:34 +01:00
Surasia	52f7d9e77a	patterns/hinf_bitmap: Added pattern for parsing Halo Infinite bitmap files (#194 ) * patterns/hinf_bitmap: Added pattern for parsing Halo Infinite bitmap files * Parses the header of all Halo Infinite files which includes related "dependencies", datablocks, structure references * Read bitmap sequence data, including bitmap index, complete index, sprite info * Find the width/height and DDS Format of the raw texture, which can then be parsed into usable DDS textures * Locates raw DDS block info * Nulled out the DDS section of the bitmap	2023-11-14 00:20:32 +01:00
klirktag	99df77baf2	patterns/mp4: Add childbox support for STBL boxes (#192 ) * find childboxes in stbl * add implementation for SampleDescriptionBox	2023-11-14 00:06:50 +01:00
klirktag	d7b0819ff0	patterns/mp4: Make handler_type into a char[4], which reflects how it is used (#193 ) make handler_type into a char[4], which reflects how it is used	2023-11-14 00:06:31 +01:00
Nik	70f491d2fa	includes/type: Fixed formatting of time_t values in big endian patterns	2023-11-12 22:18:46 +01:00
Hugo	08680a6544	patterns/bplist: Added pattern file for Apple’s binary property list format (bplist) (#190 ) * Added pattern file for Apple’s binary property list format (bplist) * renamed some stuff and improved error messages * added error handling for object size special case (0x0F)	2023-11-12 01:02:50 +01:00
Ange Albertini	23bc36c4bd	patterns/selinux: Detailed SELinux config bitfield (#188 )	2023-11-06 16:30:53 +01:00
Ange Albertini	8ae778944d	patterns/se: Increased array limit (#187 ) Increased array limit	2023-11-01 20:19:10 +01:00
klirktag	7e6a5d3bfa	patterns/mp4: Added stbl box (#185 )	2023-10-29 19:54:23 +01:00
Hugo	27e55d2e6d	patterns/zip: Added parsing of extra field (#182 ) * zip pattern: Improved fallback method for finding eocd. Added test data to cover this edge case * zip pattern: added parsing of extra field	2023-10-29 19:47:11 +01:00
Benjamin Gilbert	e0a602c10a	patterns/jpeg: Small improvements (#184 ) * patterns/jpeg: exclude EOI marker from SOS image data * patterns/jpeg: use type::Magic for magic numbers * patterns/jpeg: add RGB component IDs * patterns/jpeg: add struct for APP14 marker * patterns/jpeg: add definition for COM marker * patterns/jpeg: add some format_read() for better legibility	2023-10-29 19:46:51 +01:00
AdventureT	8748646016	patterns/CrashLvl: Update Crash Back in Time level format (#186 ) * Working on new Version * Needs testing * Updated CrashLvl script to support version 0.94c * Update README.md * Added TestData and author to script * Delete tests/patterns/test_data/CrashLvl.hexpat.bin	2023-10-29 19:46:28 +01:00
iTrooz	4a52ee4cf8	patterns: add UEFI Boot Entry pattern (#183 ) add uefi_boot_entry pattern	2023-10-24 23:04:49 +02:00
iTrooz	e517e3534b	patterns: fix description pragmas (#181 )	2023-10-24 17:25:43 +02:00
DmitriLeon2000	edd0aa9a2f	patterns: Add .fas and .was pattern files (Oska DeskMates) (#176 ) * Add .fas and .was pattern files (Oska DeskMates) * Update .was pattern file * Update .was/.wa3 pattern file * Update README.md * Update README.md * Update .fas & .was pattern files * Update README.md * Update fas_oskasoftware_old.hexpat * Added WAS test file * Update WAS test file * Update was_oskasoftware.hexpat	2023-10-24 07:35:38 +02:00
Hugo	a992d1ba92	patterns/zip: Improved fallback method for finding eocd (#177 ) zip pattern: Improved fallback method for finding eocd. Added test data to cover this edge case	2023-10-24 07:35:02 +02:00
leen	6fbdcac556	patterns/ip: Fix payload size when ip header or tcp header has options in ip.hexpat (#178 )	2023-10-24 07:34:35 +02:00
itsmeow	47fce1628f	patterns: Add ARIA2 Control format (#179 )	2023-10-24 07:33:56 +02:00
Nik	9b152ae560	includes/std: Fixed doc comment of std::math::atan2	2023-10-22 21:25:14 +02:00
Nik	6b136b7fc6	includes/std: Fixed `std::math::atan2` not taking correct arguments	2023-10-22 21:23:51 +02:00
gmestanley	93494a19a4	patterns: Better code + credit given for ips.hexpat & better readme (#174 ) * Add files via upload * Update README.md Added nes.hexpat to list of hex patterns * Fix indenting of hex patterns list Moved nes.hexpat below NE.hexpat * Update README.md Fixed indenting of PP pattern file's description being wrong * Added x-msdownload MIME type to PE description * Made indenting & code of ips.hexpat better * Improvements to gb.hexpat * Urgent fix to ips.hexpat * Urgent fix to gb.hexpat	2023-10-15 21:21:19 +02:00
H0L0	4fd710e23e	patterns/flac: Fix SEEKTABLE metadata block (#173 ) Add SEEKTABLE to blocktype check	2023-10-15 21:19:34 +02:00
Nik	44842dc44b	includes/std: Added `std::mem::set_section_size` (#175 )	2023-10-15 21:15:12 +02:00
HalfInner	056035c540	patterns/zip: Add parsing local file header with minor adjustment (#172 ) patterns/zip: add parsing local file header, and another adjustmenst Add missing parsing for local file headers Add compression method Minor adjustments: removed black colors, marked magic ids	2023-10-06 12:20:30 +02:00
Diego	5ad8e15afc	patterns/shp: Added ESRI patterns (#170 ) * add .shp and .shx patterns * add tests	2023-10-06 12:20:11 +02:00
Nik	39c4d11404	patterns/uefi: Remove invalid MIME pragma	2023-10-05 08:54:59 +02:00
Benjamin Gilbert	815bd5f7f3	git: Minor readme fixes (#168 )	2023-09-26 16:51:31 +02:00
Benjamin Gilbert	917b05a9f2	patterns: Add DICOM (#162 ) DICOM files specify a "transfer syntax" which defines the image compression format, the encoding rules for the entire file, and any special-case encoding rules for particular fields. Many transfer syntaxes have common design features, but a transfer syntax is allowed to use completely custom encoding rules, and need not be publicly documented. Explicitly reject transfer syntaxes we know we don't support: implicit VR (uncommon), explicit VR big-endian (deprecated), deflate-compressed. In all other cases, follow some general rules and hope it works out. The large lookup functions were generated by a script, but I haven't included the code here, since its input is hand-massaged data copied from HTML tables. Add a JPEG WSI test case from the WG26 2021 hackathon (CC0 license) and a synthetic LE Explicit VLP case produced with img2dcm.	2023-09-26 16:51:02 +02:00
brliron	46a2cef993	patterns: Added Android VBMeta image pattern (#169 )	2023-09-26 14:03:24 +02:00
Nik	bca25b1a78	includes/hex: Fixed duplicate variable name in `hex::core::get_selection()` function Fixes #167	2023-09-25 07:22:06 +02:00