hacktools 0.40.1__tar.gz → 1.0.0__tar.gz

{hacktools-0.40.1 → hacktools-1.0.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2025 Illidan
+Copyright (c) 2020-2026 Illidan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{hacktools-0.40.1/hacktools.egg-info → hacktools-1.0.0}/PKG-INFO

@@ -1,19 +1,17 @@
 Metadata-Version: 2.4
 Name: hacktools
-Version: 0.40.1
+Version: 1.0.0
 Summary: A set of utilities and tools for rom hacking and translations.
 Home-page: https://github.com/Illidanz/hacktools
 Author: Illidan
 License: MIT
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: nds
@@ -61,6 +59,8 @@ Dynamic: summary
 # hacktools
 A set of utilities and tools for rom hacking and translations.
 
+Documentation is available at [illidanz.github.io/hacktools](https://illidanz.github.io/hacktools/).
+
 ## Installing dependencies
 Most dependencies are optional, and can be installed with `pip install 'hacktools[name1,name2]'` or `pip install 'hacktools[all]'` to install all of them.
 ### Dependencies list

{hacktools-0.40.1 → hacktools-1.0.0}/README.md

@@ -1,6 +1,8 @@
 # hacktools
 A set of utilities and tools for rom hacking and translations.
 
+Documentation is available at [illidanz.github.io/hacktools](https://illidanz.github.io/hacktools/).
+
 ## Installing dependencies
 Most dependencies are optional, and can be installed with `pip install 'hacktools[name1,name2]'` or `pip install 'hacktools[all]'` to install all of them.
 ### Dependencies list

hacktools-1.0.0/hacktools/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

{hacktools-0.40.1 → hacktools-1.0.0}/hacktools/arch.py

@@ -1,29 +1,63 @@
+"""Support for ARCH archives, including compression and decompression.
+
+An ARCH archive starts with an "ARCH" magic followed by a header, a name
+table, a file allocation table and the file data. Files can optionally be
+compressed with a byte-pair encoding scheme, based on Tinke's implementation.
+"""
 import os
 from collections import Counter
 from hacktools import common
 
 
 class ARCHArchive:
+    """Structure of an ARCH archive header.
+
+    Attributes:
+        filenum: Number of files in the archive.
+        tableoff: Offset of the name table.
+        fatoff: Offset of the file allocation table.
+        nameindexoff: Offset of the name index.
+        dataoff: Offset of the file data.
+        files: List of files in the archive.
+    """
     def __init__(self):
-        self.filenum = 0
-        self.tableoff = 0
-        self.fatoff = 0
-        self.nameindexoff = 0
-        self.dataoff = 0
-        self.files = []
+        self.filenum: int = 0
+        self.tableoff: int = 0
+        self.fatoff: int = 0
+        self.nameindexoff: int = 0
+        self.dataoff: int = 0
+        self.files: list[ARCHFile] = []
 
 
 class ARCHFile:
+    """Structure of a single file entry in an ARCH archive.
+
+    Attributes:
+        name: File name, read from the archive name table.
+        length: Length of the file data as stored in the archive.
+        declength: Decompressed length, equal to length if not encoded.
+        offset: Offset of the file data, relative to the archive dataoff.
+        nameoffset: Offset of the file name, relative to the archive tableoff.
+        encoded: Whether the file data is compressed.
+    """
     def __init__(self):
-        self.name = ""
-        self.length = 0
-        self.declength = 0
-        self.offset = 0
-        self.nameoffset = 0
-        self.encoded = False
+        self.name: str = ""
+        self.length: int = 0
+        self.declength: int = 0
+        self.offset: int = 0
+        self.nameoffset: int = 0
+        self.encoded: bool = False
+
 
+def read(f: common.Stream) -> ARCHArchive:
+    """Read the header and file table of an ARCH archive.
 
-def read(f):
+    Args:
+        f: Stream opened on the archive file.
+
+    Returns:
+        The parsed archive structure.
+    """
     f.seek(4)  # Magic: ARCH
     archive = ARCHArchive()
     archive.filenum = f.readUInt()
@@ -47,7 +81,19 @@ def read(f):
     return archive
 
 
-def repack(fin, f, archive, infolder):
+def repack(fin: common.Stream, f: common.Stream, archive: ARCHArchive, infolder: str) -> None:
+    """Repack an ARCH archive, replacing the files found in a folder.
+
+    Files that exist in infolder are read from there, compressing the ones
+    marked as encoded in the archive, while the others are copied from fin.
+    File data is aligned to 16 bytes with zeros.
+
+    Args:
+        fin: Stream opened on the original archive file.
+        f: Stream opened on the output archive file.
+        archive: Archive structure returned by :func:`read`.
+        infolder: Path of the folder containing the replacement files.
+    """
     # Copy everything up to dataoff
     fin.seek(0)
     f.seek(0)
@@ -96,7 +142,16 @@ def repack(fin, f, archive, infolder):
         dataoff = f.tell() - archive.dataoff
 
 
-def extract(f, archive, outfolder):
+def extract(f: common.Stream, archive: ARCHArchive, outfolder: str) -> None:
+    """Extract all the files of an ARCH archive to a folder.
+
+    Files marked as encoded are decompressed.
+
+    Args:
+        f: Stream opened on the archive file.
+        archive: Archive structure returned by :func:`read`.
+        outfolder: Path of the folder to extract the files to.
+    """
     for subfile in archive.files:
         with common.Stream(outfolder + subfile.name, "wb") as fout:
             f.seek(archive.dataoff + subfile.offset)
@@ -106,7 +161,19 @@ def extract(f, archive, outfolder):
                 fout.write(decompress(f.read(subfile.length), subfile.declength))
 
 
-def compress(data):
+def compress(data: bytes) -> bytes:
+    """Compress data with the byte-pair encoding used by ARCH archives.
+
+    The most common byte pairs are recursively replaced with single bytes
+    that don't occur in the data, and a dictionary of these replacements is
+    written before the encoded content.
+
+    Args:
+        data: Data to compress.
+
+    Returns:
+        The compressed data.
+    """
     # Find unused bytes in the data
     dictkeys = []
     for i in range(1, 0x100):
@@ -199,7 +266,16 @@ def compress(data):
         return f.read()
 
 
-def decompress(data, declen):
+def decompress(data: bytes, declen: int) -> bytes:
+    """Decompress byte-pair encoded data from an ARCH archive.
+
+    Args:
+        data: Data to decompress.
+        declen: Expected length of the decompressed data, currently unused.
+
+    Returns:
+        The decompressed data.
+    """
     with common.Stream() as f:
         with common.Stream() as fout:
             f.write(data)
@@ -235,7 +311,7 @@ def decompress(data, declen):
                 # Process
                 numloops = (f.readByte() << 8) + f.readByte()
                 common.logDebug("Decompressing with", common.toHex(numloops), "loops starting at", common.toHex(f.tell()))
-                nextsamples = []
+                nextsamples: list[int] = []
                 while True:
                     if len(nextsamples) == 0:
                         if numloops == 0:

{hacktools-0.40.1 → hacktools-1.0.0}/hacktools/c_ext/cmp_cri.c

@@ -1,5 +1,20 @@
 #include "inc.h"
 
+PyDoc_STRVAR(compressCRILAYLA_doc,
+"compressCRILAYLA($module, /, indata)\n"
+"--\n"
+"\n"
+"Compress data with the CRILAYLA scheme used by CPK archives.\n"
+"\n"
+"The first 0x100 bytes of the input are stored uncompressed after the\n"
+"compressed stream, so the input must be at least 0x100 bytes long.\n"
+"\n"
+"Args:\n"
+"    indata (bytes): Data to compress.\n"
+"\n"
+"Returns:\n"
+"    bytes: The compressed data, starting with the CRILAYLA signature.");
+
 // https://github.com/ConnorKrammer/cpk-tools/blob/master/LibCRIComp/LibCRIComp.cpp
 static PyObject* compressCRILAYLA(PyObject* module, PyObject* args, PyObject* kwargs)
 {
@@ -160,6 +175,18 @@ static inline uint16_t get_next_bits(unsigned char* input_buffer, long* const of
     return out_bits;
 }
 
+PyDoc_STRVAR(decompressCRILAYLA_doc,
+"decompressCRILAYLA($module, /, indata)\n"
+"--\n"
+"\n"
+"Decompress CRILAYLA-compressed data.\n"
+"\n"
+"Args:\n"
+"    indata (bytes): Compressed data, starting with the CRILAYLA signature.\n"
+"\n"
+"Returns:\n"
+"    bytes: The decompressed data.");
+
 // https://github.com/hcs64/vgm_ripping/blob/master/multi/utf_tab/cpk_uncompress.c
 static PyObject* decompressCRILAYLA(PyObject* m, PyObject* args, PyObject* kwargs)
 {
@@ -244,20 +271,20 @@ static PyObject* decompressCRILAYLA(PyObject* m, PyObject* args, PyObject* kwarg
 }
 
 static PyMethodDef Cmp_criMethods[] = {
-    {"compressCRILAYLA", (PyCFunction)compressCRILAYLA, METH_VARARGS | METH_KEYWORDS, "Compress CRILAYLA data."},
-    {"decompressCRILAYLA", (PyCFunction)decompressCRILAYLA, METH_VARARGS | METH_KEYWORDS, "Decompress CRILAYLA data."},
+    {"compressCRILAYLA", (PyCFunction)compressCRILAYLA, METH_VARARGS | METH_KEYWORDS, compressCRILAYLA_doc},
+    {"decompressCRILAYLA", (PyCFunction)decompressCRILAYLA, METH_VARARGS | METH_KEYWORDS, decompressCRILAYLA_doc},
     {NULL, NULL, 0, NULL}
 };
 
 static struct PyModuleDef cmp_crimodule = {
     PyModuleDef_HEAD_INIT,
     "cmp_cri",
-    "CRILAYLA functions.",
+    "C implementation of the CRILAYLA compression scheme used by CPK archives.",
     -1,
     Cmp_criMethods
 };
 
 PyMODINIT_FUNC PyInit_cmp_cri(void)
 {
-    return PyModule_Create(&cmp_crimodule);
+    return moduleCreate(&cmp_crimodule);
 }

hacktools-1.0.0/hacktools/c_ext/cmp_huff.c

@@ -0,0 +1,405 @@
+#include "inc.h"
+
+// Free the buffer before raising, as the checks happen after allocating it
+#define ERROR_CHECK_FREE(cond, error, ptr) if (cond) { PyMem_Free(ptr); PyErr_SetString(PyExc_ValueError, error); return NULL; }
+
+// A tree can hold at most 256 leaves, one per possible value, plus the 255 branches joining them
+#define MAX_NODES 512
+// With at most 256 leaves the tree is at most 255 levels deep, so codes are at most 255 bits long
+#define MAX_CODE_BITS 256
+
+PyDoc_STRVAR(decompressHuffman_doc,
+"decompressHuffman($module, /, rawdata, decomplength, numbits=8, little=True)\n"
+"--\n"
+"\n"
+"Decompress Huffman-coded data, as used by the GBA and NDS BIOS.\n"
+"\n"
+"The data is expected to start with the tree size and the tree itself,\n"
+"followed by the 32-bit codeword stream, without the 4-byte header with\n"
+"compression type and length.\n"
+"\n"
+"Args:\n"
+"    rawdata (bytes): Compressed data to read.\n"
+"    decomplength (int): Length of the decompressed data.\n"
+"    numbits (int): Data size in bits, 8 or 4.\n"
+"    little (bool): Whether nibbles are ordered low-first when numbits is 4.\n"
+"\n"
+"Returns:\n"
+"    bytes: The decompressed data.");
+
+static PyObject* decompressHuffman(PyObject* m, PyObject* args, PyObject* kwargs)
+{
+    static char *kwlist[] = { "rawdata", "decomplength", "numbits", "little", NULL };
+
+    unsigned char* rawdata;
+    size_t datalength;
+    unsigned int decomplength;
+    int numbits = 8;
+    int little = 1;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#I|ip", kwlist, &rawdata, &datalength, &decomplength, &numbits, &little))
+        return NULL;
+    ERROR_CHECK(numbits != 8 && numbits != 4, "Data size must be 8 or 4 bits.");
+    ERROR_CHECK(datalength < 2, "Not enough data.");
+
+    unsigned int treesize = rawdata[0];
+    unsigned int treeroot = rawdata[1];
+    unsigned char* treebuffer = rawdata + 2;
+    size_t treelength = (size_t)treesize * 2;
+    ERROR_CHECK(datalength < 2 + treelength, "Not enough data.");
+
+    // Every written byte holds numbits bits of the decompressed data
+    size_t outlength = (size_t)decomplength * (8 / numbits);
+    unsigned char* out = PyMem_Malloc(outlength > 0 ? outlength : 1);
+    MALLOC_CHECK(out);
+
+    size_t readbytes = 2 + treelength;
+    ERROR_CHECK_FREE(readbytes + 4 > datalength, "Not enough data.", out);
+    unsigned int code = READ_32(rawdata, readbytes);
+    readbytes += 4;
+
+    size_t writebytes = 0;
+    unsigned int i = 0;
+    unsigned int next = 0;
+    unsigned int pos = treeroot;
+    while (writebytes < outlength)
+    {
+        // All the bits of the current codeword have been read, get a new one
+        if (i == 32)
+        {
+            ERROR_CHECK_FREE(readbytes + 4 > datalength, "Not enough data.", out);
+            code = READ_32(rawdata, readbytes);
+            readbytes += 4;
+            i = 0;
+        }
+        next += (pos & 0x3f) * 2 + 2;
+        unsigned int direction = ((code >> (31 - i)) & 1) == 0 ? 2 : 1;
+        int leaf = (((pos >> 5) >> direction) & 1) != 0;
+        ERROR_CHECK_FREE(next - direction >= treelength, "Tree offset out of range.", out);
+        pos = treebuffer[next - direction];
+        if (leaf)
+        {
+            out[writebytes++] = (unsigned char)(pos & 0xff);
+            pos = treeroot;
+            next = 0;
+        }
+        ++i;
+    }
+
+    // Pack the nibbles back into bytes
+    if (numbits == 4)
+    {
+        for (unsigned int j = 0; j < decomplength; ++j)
+        {
+            unsigned char b1 = out[2 * j + 1];
+            unsigned char b2 = out[2 * j];
+            if (little)
+                out[j] = (unsigned char)((b1 * 16 + b2) & 0xff);
+            else
+                out[j] = (unsigned char)((b2 * 16 + b1) & 0xff);
+        }
+    }
+
+    PyObject *output = PyBytes_FromStringAndSize(out, decomplength);
+    PyMem_Free(out);
+    return output;
+}
+
+// Node of the binary tree built by compressHuffman
+typedef struct HuffNode
+{
+    unsigned int freqcount;
+    int code;
+    int score;
+    int haschildren;
+    struct HuffNode* children[2];
+} HuffNode;
+
+// Sort the nodes by frequency, keeping the order of equal elements.
+// The list is always sorted except for the node appended by the last iteration,
+// so the insertion sort only has to move that one back into place.
+static void sortByFreq(HuffNode** freq, int freqlen)
+{
+    for (int i = 1; i < freqlen; ++i)
+    {
+        HuffNode* node = freq[i];
+        int j = i - 1;
+        while (j >= 0 && freq[j]->freqcount > node->freqcount)
+        {
+            freq[j + 1] = freq[j];
+            --j;
+        }
+        freq[j + 1] = node;
+    }
+}
+
+// Store the code of every leaf node under this node as a string of 0 and 1 bits
+static void getHuffCodes(HuffNode* node, unsigned char* seed, int seedlen, unsigned char* codebits, int* codelengths)
+{
+    if (!node->haschildren)
+    {
+        for (int i = 0; i < seedlen; ++i)
+            codebits[node->code * MAX_CODE_BITS + i] = seed[i];
+        codelengths[node->code] = seedlen;
+        return;
+    }
+    for (int i = 0; i < 2; ++i)
+    {
+        seed[seedlen] = (unsigned char)i;
+        getHuffCodes(node->children[i], seed, seedlen + 1, codebits, codelengths);
+    }
+}
+
+PyDoc_STRVAR(compressHuffman_doc,
+"compressHuffman($module, /, indata, numbits=8, little=True)\n"
+"--\n"
+"\n"
+"Compress data with Huffman coding, as used by the GBA and NDS BIOS.\n"
+"\n"
+"The output starts with the tree size and the tree itself, followed by\n"
+"the 32-bit codeword stream. The 4-byte header with compression type and\n"
+"length is not included and should be written separately.\n"
+"\n"
+"Args:\n"
+"    indata (bytes): Data to compress.\n"
+"    numbits (int): Data size in bits, 8 or 4.\n"
+"    little (bool): Whether nibbles are ordered low-first when numbits is 4.\n"
+"\n"
+"Returns:\n"
+"    bytes: The compressed data.");
+
+static PyObject* compressHuffman(PyObject* m, PyObject* args, PyObject* kwargs)
+{
+    static char *kwlist[] = { "indata", "numbits", "little", NULL };
+
+    unsigned char* indata;
+    size_t inlength;
+    int numbits = 8;
+    int little = 1;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|ip", kwlist, &indata, &inlength, &numbits, &little))
+        return NULL;
+    ERROR_CHECK(numbits != 8 && numbits != 4, "Data size must be 8 or 4 bits.");
+    ERROR_CHECK(inlength == 0, "No data to compress.");
+
+    // Read indata as nibbles if numbits is 4
+    unsigned char* workdata = indata;
+    size_t worklength = inlength;
+    unsigned char* nibbles = NULL;
+    if (numbits == 4)
+    {
+        nibbles = PyMem_Malloc(inlength * 2);
+        MALLOC_CHECK(nibbles);
+        for (size_t i = 0; i < inlength; ++i)
+        {
+            unsigned char b1 = indata[i] % 16;
+            unsigned char b2 = indata[i] / 16;
+            nibbles[2 * i] = little ? b1 : b2;
+            nibbles[2 * i + 1] = little ? b2 : b1;
+        }
+        workdata = nibbles;
+        worklength = inlength * 2;
+    }
+
+    // Get frequencies
+    unsigned int freqcount[256] = { 0 };
+    for (size_t i = 0; i < worklength; ++i)
+        ++freqcount[workdata[i]];
+
+    HuffNode* nodes = PyMem_Malloc(MAX_NODES * sizeof(HuffNode));
+    HuffNode** freq = PyMem_Malloc(MAX_NODES * sizeof(HuffNode*));
+    HuffNode** lst = PyMem_Malloc(MAX_NODES * sizeof(HuffNode*));
+    unsigned char* codebits = PyMem_Malloc(256 * MAX_CODE_BITS);
+    if (nodes == NULL || freq == NULL || lst == NULL || codebits == NULL)
+    {
+        PyMem_Free(nibbles);
+        PyMem_Free(nodes);
+        PyMem_Free(freq);
+        PyMem_Free(lst);
+        PyMem_Free(codebits);
+        return PyErr_NoMemory();
+    }
+    int nodecount = 0;
+    int freqlen = 0;
+    for (int i = 0; i < 256; ++i)
+    {
+        if (freqcount[i] > 0)
+        {
+            HuffNode* node = &nodes[nodecount++];
+            node->freqcount = freqcount[i];
+            node->code = i;
+            node->score = 0;
+            node->haschildren = 0;
+            freq[freqlen++] = node;
+        }
+    }
+
+    // Add a stub entry in the special case that there's only one item
+    if (freqlen == 1)
+    {
+        HuffNode* node = &nodes[nodecount++];
+        node->freqcount = 0;
+        node->code = (workdata[0] + 1) & 0xff;
+        node->score = 0;
+        node->haschildren = 0;
+        freq[freqlen++] = node;
+    }
+
+    // Sort and create the tree
+    while (freqlen > 1)
+    {
+        sortByFreq(freq, freqlen);
+        HuffNode* node = &nodes[nodecount++];
+        node->freqcount = freq[0]->freqcount + freq[1]->freqcount;
+        node->code = 0;
+        node->score = 0;
+        node->haschildren = 1;
+        node->children[0] = freq[0];
+        node->children[1] = freq[1];
+        for (int i = 2; i < freqlen; ++i)
+            freq[i - 2] = freq[i];
+        freqlen -= 2;
+        freq[freqlen++] = node;
+    }
+
+    // Label nodes to keep bandwidth small
+    int lstlen = 0;
+    while (freqlen > 0)
+    {
+        // Take the node with the lowest score, the first one if there are ties
+        int best = 0;
+        for (int i = 0; i < freqlen; ++i)
+        {
+            freq[i]->score = freq[i]->code - i;
+            if (freq[i]->score < freq[best]->score)
+                best = i;
+        }
+        HuffNode* node = freq[best];
+        for (int i = best; i < freqlen - 1; ++i)
+            freq[i] = freq[i + 1];
+        --freqlen;
+        node->code = (lstlen - node->code) & 0xff;
+        lst[lstlen++] = node;
+        if (node->haschildren)
+        {
+            for (int i = 1; i >= 0; --i)
+            {
+                if (node->children[i]->haschildren)
+                {
+                    node->children[i]->code = lstlen & 0xff;
+                    freq[freqlen++] = node->children[i];
+                }
+            }
+        }
+    }
+
+    // Convert our list of nodes to a table of bytes -> huffman codes
+    int codelengths[256] = { 0 };
+    unsigned char seed[MAX_CODE_BITS];
+    getHuffCodes(lst[0], seed, 0, codebits, codelengths);
+
+    // The output holds the tree, then the codes padded to a multiple of 32 bits
+    size_t totalbits = 0;
+    for (int i = 0; i < 256; ++i)
+        totalbits += (size_t)freqcount[i] * codelengths[i];
+    size_t outcap = 2 + 2 * (size_t)lstlen + 2 + (totalbits + 31) / 32 * 4 + 4;
+    unsigned char* out = PyMem_Malloc(outcap);
+    if (out == NULL)
+    {
+        PyMem_Free(nibbles);
+        PyMem_Free(nodes);
+        PyMem_Free(freq);
+        PyMem_Free(lst);
+        PyMem_Free(codebits);
+        return PyErr_NoMemory();
+    }
+    size_t outlength = 0;
+
+    // Write header
+    out[outlength++] = (unsigned char)(lstlen & 0xff);
+
+    // Write Huffman tree, reusing the now empty freq list to hold it
+    HuffNode** tree = freq;
+    int treelen = 0;
+    tree[treelen++] = lst[0];
+    for (int i = 0; i < lstlen; ++i)
+    {
+        if (lst[i]->haschildren)
+            for (int j = 0; j < 2; ++j)
+                tree[treelen++] = lst[i]->children[j];
+    }
+    for (int i = 0; i < treelen; ++i)
+    {
+        HuffNode* node = tree[i];
+        if (node->haschildren)
+        {
+            int childsum = 0;
+            for (int j = 0; j < 2; ++j)
+                if (!node->children[j]->haschildren)
+                    childsum += (0x80 >> j) & 0xff;
+            node->code |= childsum & 0xff;
+        }
+        out[outlength++] = (unsigned char)(node->code & 0xff);
+    }
+
+    // Ensure nodes are word-aligned
+    if (lstlen % 2 == 0)
+    {
+        out[outlength++] = 0;
+        out[outlength++] = 0;
+        out[0] = (unsigned char)((lstlen + 1) & 0xff);
+    }
+
+    // Write bits to stream
+    unsigned int data = 0;
+    size_t setbits = 0;
+    for (size_t i = 0; i < worklength; ++i)
+    {
+        unsigned char* bits = codebits + workdata[i] * MAX_CODE_BITS;
+        int bitslength = codelengths[workdata[i]];
+        for (int j = 0; j < bitslength; ++j)
+        {
+            data = data * 2 + bits[j];
+            ++setbits;
+            if (setbits % 32 == 0)
+            {
+                WRITE_32(out, outlength, data);
+                outlength += 4;
+                data = 0;
+            }
+        }
+    }
+    if (setbits % 32 != 0)
+    {
+        WRITE_32(out, outlength, data << (32 - (setbits % 32)));
+        outlength += 4;
+    }
+
+    PyObject *output = PyBytes_FromStringAndSize(out, outlength);
+    PyMem_Free(out);
+    PyMem_Free(nibbles);
+    PyMem_Free(nodes);
+    PyMem_Free(freq);
+    PyMem_Free(lst);
+    PyMem_Free(codebits);
+    return output;
+}
+
+static PyMethodDef Cmp_huffMethods[] = {
+    {"decompressHuffman", (PyCFunction)decompressHuffman, METH_VARARGS | METH_KEYWORDS, decompressHuffman_doc},
+    {"compressHuffman", (PyCFunction)compressHuffman, METH_VARARGS | METH_KEYWORDS, compressHuffman_doc},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef cmp_huffmodule = {
+    PyModuleDef_HEAD_INIT,
+    "cmp_huff",
+    "C implementation of the Huffman coding scheme used by the GBA and NDS BIOS.",
+    -1,
+    Cmp_huffMethods
+};
+
+PyMODINIT_FUNC PyInit_cmp_huff(void)
+{
+    return moduleCreate(&cmp_huffmodule);
+}