kaitai: adjustments and rearrangements for python2/3 compat

16 files changed, 0 insertions, 3941 deletions

diff --git a/python/examples/kaitai/kaitai_struct_formats/game/__init__.py b/python/examples/kaitai/kaitai_struct_formats/game/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/__init__.py
+++ /dev/null
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/allegro_dat.py b/python/examples/kaitai/kaitai_struct_formats/game/allegro_dat.py
deleted file mode 100644
index 0078bf45..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/allegro_dat.py
+++ /dev/null
@@ -1,365 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class AllegroDat(KaitaiStruct):
-    """Allegro library for C (mostly used for game and multimedia apps
-    programming) used its own container file format.
-    
-    In general, it allows storage of arbitrary binary data blocks
-    bundled together with some simple key-value style metadata
-    ("properties") for every block. Allegro also pre-defines some simple
-    formats for bitmaps, fonts, MIDI music, sound samples and
-    palettes. Allegro library v4.0+ also support LZSS compression.
-    
-    This spec applies to Allegro data files for library versions 2.2 up
-    to 4.4.
-    
-    .. seealso::
-       Source - https://liballeg.org/stabledocs/en/datafile.html
-    """
-
-    class PackEnum(Enum):
-        unpacked = 1936484398
-    SEQ_FIELDS = ["pack_magic", "dat_magic", "num_objects", "objects"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['pack_magic']['start'] = self._io.pos()
-        self.pack_magic = KaitaiStream.resolve_enum(self._root.PackEnum, self._io.read_u4be())
-        self._debug['pack_magic']['end'] = self._io.pos()
-        self._debug['dat_magic']['start'] = self._io.pos()
-        self.dat_magic = self._io.ensure_fixed_contents(b"\x41\x4C\x4C\x2E")
-        self._debug['dat_magic']['end'] = self._io.pos()
-        self._debug['num_objects']['start'] = self._io.pos()
-        self.num_objects = self._io.read_u4be()
-        self._debug['num_objects']['end'] = self._io.pos()
-        self._debug['objects']['start'] = self._io.pos()
-        self.objects = [None] * (self.num_objects)
-        for i in range(self.num_objects):
-            if not 'arr' in self._debug['objects']:
-                self._debug['objects']['arr'] = []
-            self._debug['objects']['arr'].append({'start': self._io.pos()})
-            _t_objects = self._root.DatObject(self._io, self, self._root)
-            _t_objects._read()
-            self.objects[i] = _t_objects
-            self._debug['objects']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['objects']['end'] = self._io.pos()
-
-    class DatFont16(KaitaiStruct):
-        """Simple monochrome monospaced font, 95 characters, 8x16 px
-        characters.
-        """
-        SEQ_FIELDS = ["chars"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['chars']['start'] = self._io.pos()
-            self.chars = [None] * (95)
-            for i in range(95):
-                if not 'arr' in self._debug['chars']:
-                    self._debug['chars']['arr'] = []
-                self._debug['chars']['arr'].append({'start': self._io.pos()})
-                self.chars[i] = self._io.read_bytes(16)
-                self._debug['chars']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['chars']['end'] = self._io.pos()
-
-
-    class DatBitmap(KaitaiStruct):
-        SEQ_FIELDS = ["bits_per_pixel", "width", "height", "image"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['bits_per_pixel']['start'] = self._io.pos()
-            self.bits_per_pixel = self._io.read_s2be()
-            self._debug['bits_per_pixel']['end'] = self._io.pos()
-            self._debug['width']['start'] = self._io.pos()
-            self.width = self._io.read_u2be()
-            self._debug['width']['end'] = self._io.pos()
-            self._debug['height']['start'] = self._io.pos()
-            self.height = self._io.read_u2be()
-            self._debug['height']['end'] = self._io.pos()
-            self._debug['image']['start'] = self._io.pos()
-            self.image = self._io.read_bytes_full()
-            self._debug['image']['end'] = self._io.pos()
-
-
-    class DatFont(KaitaiStruct):
-        SEQ_FIELDS = ["font_size", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['font_size']['start'] = self._io.pos()
-            self.font_size = self._io.read_s2be()
-            self._debug['font_size']['end'] = self._io.pos()
-            self._debug['body']['start'] = self._io.pos()
-            _on = self.font_size
-            if _on == 8:
-                self.body = self._root.DatFont8(self._io, self, self._root)
-                self.body._read()
-            elif _on == 16:
-                self.body = self._root.DatFont16(self._io, self, self._root)
-                self.body._read()
-            elif _on == 0:
-                self.body = self._root.DatFont39(self._io, self, self._root)
-                self.body._read()
-            self._debug['body']['end'] = self._io.pos()
-
-
-    class DatFont8(KaitaiStruct):
-        """Simple monochrome monospaced font, 95 characters, 8x8 px
-        characters.
-        """
-        SEQ_FIELDS = ["chars"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['chars']['start'] = self._io.pos()
-            self.chars = [None] * (95)
-            for i in range(95):
-                if not 'arr' in self._debug['chars']:
-                    self._debug['chars']['arr'] = []
-                self._debug['chars']['arr'].append({'start': self._io.pos()})
-                self.chars[i] = self._io.read_bytes(8)
-                self._debug['chars']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['chars']['end'] = self._io.pos()
-
-
-    class DatObject(KaitaiStruct):
-        SEQ_FIELDS = ["properties", "len_compressed", "len_uncompressed", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['properties']['start'] = self._io.pos()
-            self.properties = []
-            i = 0
-            while True:
-                if not 'arr' in self._debug['properties']:
-                    self._debug['properties']['arr'] = []
-                self._debug['properties']['arr'].append({'start': self._io.pos()})
-                _t_properties = self._root.Property(self._io, self, self._root)
-                _t_properties._read()
-                _ = _t_properties
-                self.properties.append(_)
-                self._debug['properties']['arr'][len(self.properties) - 1]['end'] = self._io.pos()
-                if not (_.is_valid):
-                    break
-                i += 1
-            self._debug['properties']['end'] = self._io.pos()
-            self._debug['len_compressed']['start'] = self._io.pos()
-            self.len_compressed = self._io.read_s4be()
-            self._debug['len_compressed']['end'] = self._io.pos()
-            self._debug['len_uncompressed']['start'] = self._io.pos()
-            self.len_uncompressed = self._io.read_s4be()
-            self._debug['len_uncompressed']['end'] = self._io.pos()
-            self._debug['body']['start'] = self._io.pos()
-            _on = self.type
-            if _on == u"BMP ":
-                self._raw_body = self._io.read_bytes(self.len_compressed)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.DatBitmap(io, self, self._root)
-                self.body._read()
-            elif _on == u"RLE ":
-                self._raw_body = self._io.read_bytes(self.len_compressed)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.DatRleSprite(io, self, self._root)
-                self.body._read()
-            elif _on == u"FONT":
-                self._raw_body = self._io.read_bytes(self.len_compressed)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.DatFont(io, self, self._root)
-                self.body._read()
-            else:
-                self.body = self._io.read_bytes(self.len_compressed)
-            self._debug['body']['end'] = self._io.pos()
-
-        @property
-        def type(self):
-            if hasattr(self, '_m_type'):
-                return self._m_type if hasattr(self, '_m_type') else None
-
-            self._m_type = self.properties[-1].magic
-            return self._m_type if hasattr(self, '_m_type') else None
-
-
-    class DatFont39(KaitaiStruct):
-        """New bitmap font format introduced since Allegro 3.9: allows
-        flexible designation of character ranges, 8-bit colored
-        characters, etc.
-        """
-        SEQ_FIELDS = ["num_ranges", "ranges"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_ranges']['start'] = self._io.pos()
-            self.num_ranges = self._io.read_s2be()
-            self._debug['num_ranges']['end'] = self._io.pos()
-            self._debug['ranges']['start'] = self._io.pos()
-            self.ranges = [None] * (self.num_ranges)
-            for i in range(self.num_ranges):
-                if not 'arr' in self._debug['ranges']:
-                    self._debug['ranges']['arr'] = []
-                self._debug['ranges']['arr'].append({'start': self._io.pos()})
-                _t_ranges = self._root.DatFont39.Range(self._io, self, self._root)
-                _t_ranges._read()
-                self.ranges[i] = _t_ranges
-                self._debug['ranges']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['ranges']['end'] = self._io.pos()
-
-        class Range(KaitaiStruct):
-            SEQ_FIELDS = ["mono", "start_char", "end_char", "chars"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['mono']['start'] = self._io.pos()
-                self.mono = self._io.read_u1()
-                self._debug['mono']['end'] = self._io.pos()
-                self._debug['start_char']['start'] = self._io.pos()
-                self.start_char = self._io.read_u4be()
-                self._debug['start_char']['end'] = self._io.pos()
-                self._debug['end_char']['start'] = self._io.pos()
-                self.end_char = self._io.read_u4be()
-                self._debug['end_char']['end'] = self._io.pos()
-                self._debug['chars']['start'] = self._io.pos()
-                self.chars = [None] * (((self.end_char - self.start_char) + 1))
-                for i in range(((self.end_char - self.start_char) + 1)):
-                    if not 'arr' in self._debug['chars']:
-                        self._debug['chars']['arr'] = []
-                    self._debug['chars']['arr'].append({'start': self._io.pos()})
-                    _t_chars = self._root.DatFont39.FontChar(self._io, self, self._root)
-                    _t_chars._read()
-                    self.chars[i] = _t_chars
-                    self._debug['chars']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['chars']['end'] = self._io.pos()
-
-
-        class FontChar(KaitaiStruct):
-            SEQ_FIELDS = ["width", "height", "body"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['width']['start'] = self._io.pos()
-                self.width = self._io.read_u2be()
-                self._debug['width']['end'] = self._io.pos()
-                self._debug['height']['start'] = self._io.pos()
-                self.height = self._io.read_u2be()
-                self._debug['height']['end'] = self._io.pos()
-                self._debug['body']['start'] = self._io.pos()
-                self.body = self._io.read_bytes((self.width * self.height))
-                self._debug['body']['end'] = self._io.pos()
-
-
-
-    class Property(KaitaiStruct):
-        SEQ_FIELDS = ["magic", "type", "len_body", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['magic']['start'] = self._io.pos()
-            self.magic = (self._io.read_bytes(4)).decode(u"UTF-8")
-            self._debug['magic']['end'] = self._io.pos()
-            if self.is_valid:
-                self._debug['type']['start'] = self._io.pos()
-                self.type = (self._io.read_bytes(4)).decode(u"UTF-8")
-                self._debug['type']['end'] = self._io.pos()
-
-            if self.is_valid:
-                self._debug['len_body']['start'] = self._io.pos()
-                self.len_body = self._io.read_u4be()
-                self._debug['len_body']['end'] = self._io.pos()
-
-            if self.is_valid:
-                self._debug['body']['start'] = self._io.pos()
-                self.body = (self._io.read_bytes(self.len_body)).decode(u"UTF-8")
-                self._debug['body']['end'] = self._io.pos()
-
-
-        @property
-        def is_valid(self):
-            if hasattr(self, '_m_is_valid'):
-                return self._m_is_valid if hasattr(self, '_m_is_valid') else None
-
-            self._m_is_valid = self.magic == u"prop"
-            return self._m_is_valid if hasattr(self, '_m_is_valid') else None
-
-
-    class DatRleSprite(KaitaiStruct):
-        SEQ_FIELDS = ["bits_per_pixel", "width", "height", "len_image", "image"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['bits_per_pixel']['start'] = self._io.pos()
-            self.bits_per_pixel = self._io.read_s2be()
-            self._debug['bits_per_pixel']['end'] = self._io.pos()
-            self._debug['width']['start'] = self._io.pos()
-            self.width = self._io.read_u2be()
-            self._debug['width']['end'] = self._io.pos()
-            self._debug['height']['start'] = self._io.pos()
-            self.height = self._io.read_u2be()
-            self._debug['height']['end'] = self._io.pos()
-            self._debug['len_image']['start'] = self._io.pos()
-            self.len_image = self._io.read_u4be()
-            self._debug['len_image']['end'] = self._io.pos()
-            self._debug['image']['start'] = self._io.pos()
-            self.image = self._io.read_bytes_full()
-            self._debug['image']['end'] = self._io.pos()
-
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/doom_wad.py b/python/examples/kaitai/kaitai_struct_formats/game/doom_wad.py
deleted file mode 100644
index b5705ae9..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/doom_wad.py
+++ /dev/null
@@ -1,654 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-from enum import Enum
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class DoomWad(KaitaiStruct):
-    SEQ_FIELDS = ["magic", "num_index_entries", "index_offset"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['magic']['start'] = self._io.pos()
-        self.magic = (self._io.read_bytes(4)).decode(u"ASCII")
-        self._debug['magic']['end'] = self._io.pos()
-        self._debug['num_index_entries']['start'] = self._io.pos()
-        self.num_index_entries = self._io.read_s4le()
-        self._debug['num_index_entries']['end'] = self._io.pos()
-        self._debug['index_offset']['start'] = self._io.pos()
-        self.index_offset = self._io.read_s4le()
-        self._debug['index_offset']['end'] = self._io.pos()
-
-    class Sectors(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Sector(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class Vertex(KaitaiStruct):
-        SEQ_FIELDS = ["x", "y"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_s2le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_s2le()
-            self._debug['y']['end'] = self._io.pos()
-
-
-    class Texture12(KaitaiStruct):
-        """Used for TEXTURE1 and TEXTURE2 lumps, which designate how to
-        combine wall patches to make wall textures. This essentially
-        provides a very simple form of image compression, allowing
-        certain elements ("patches") to be reused / recombined on
-        different textures for more variety in the game.
-        
-        .. seealso::
-           Source - http://doom.wikia.com/wiki/TEXTURE1
-        """
-        SEQ_FIELDS = ["num_textures", "textures"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_textures']['start'] = self._io.pos()
-            self.num_textures = self._io.read_s4le()
-            self._debug['num_textures']['end'] = self._io.pos()
-            self._debug['textures']['start'] = self._io.pos()
-            self.textures = [None] * (self.num_textures)
-            for i in range(self.num_textures):
-                if not 'arr' in self._debug['textures']:
-                    self._debug['textures']['arr'] = []
-                self._debug['textures']['arr'].append({'start': self._io.pos()})
-                _t_textures = self._root.Texture12.TextureIndex(self._io, self, self._root)
-                _t_textures._read()
-                self.textures[i] = _t_textures
-                self._debug['textures']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['textures']['end'] = self._io.pos()
-
-        class TextureIndex(KaitaiStruct):
-            SEQ_FIELDS = ["offset"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['offset']['start'] = self._io.pos()
-                self.offset = self._io.read_s4le()
-                self._debug['offset']['end'] = self._io.pos()
-
-            @property
-            def body(self):
-                if hasattr(self, '_m_body'):
-                    return self._m_body if hasattr(self, '_m_body') else None
-
-                _pos = self._io.pos()
-                self._io.seek(self.offset)
-                self._debug['_m_body']['start'] = self._io.pos()
-                self._m_body = self._root.Texture12.TextureBody(self._io, self, self._root)
-                self._m_body._read()
-                self._debug['_m_body']['end'] = self._io.pos()
-                self._io.seek(_pos)
-                return self._m_body if hasattr(self, '_m_body') else None
-
-
-        class TextureBody(KaitaiStruct):
-            SEQ_FIELDS = ["name", "masked", "width", "height", "column_directory", "num_patches", "patches"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['name']['start'] = self._io.pos()
-                self.name = (KaitaiStream.bytes_strip_right(self._io.read_bytes(8), 0)).decode(u"ASCII")
-                self._debug['name']['end'] = self._io.pos()
-                self._debug['masked']['start'] = self._io.pos()
-                self.masked = self._io.read_u4le()
-                self._debug['masked']['end'] = self._io.pos()
-                self._debug['width']['start'] = self._io.pos()
-                self.width = self._io.read_u2le()
-                self._debug['width']['end'] = self._io.pos()
-                self._debug['height']['start'] = self._io.pos()
-                self.height = self._io.read_u2le()
-                self._debug['height']['end'] = self._io.pos()
-                self._debug['column_directory']['start'] = self._io.pos()
-                self.column_directory = self._io.read_u4le()
-                self._debug['column_directory']['end'] = self._io.pos()
-                self._debug['num_patches']['start'] = self._io.pos()
-                self.num_patches = self._io.read_u2le()
-                self._debug['num_patches']['end'] = self._io.pos()
-                self._debug['patches']['start'] = self._io.pos()
-                self.patches = [None] * (self.num_patches)
-                for i in range(self.num_patches):
-                    if not 'arr' in self._debug['patches']:
-                        self._debug['patches']['arr'] = []
-                    self._debug['patches']['arr'].append({'start': self._io.pos()})
-                    _t_patches = self._root.Texture12.Patch(self._io, self, self._root)
-                    _t_patches._read()
-                    self.patches[i] = _t_patches
-                    self._debug['patches']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['patches']['end'] = self._io.pos()
-
-
-        class Patch(KaitaiStruct):
-            SEQ_FIELDS = ["origin_x", "origin_y", "patch_id", "step_dir", "colormap"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['origin_x']['start'] = self._io.pos()
-                self.origin_x = self._io.read_s2le()
-                self._debug['origin_x']['end'] = self._io.pos()
-                self._debug['origin_y']['start'] = self._io.pos()
-                self.origin_y = self._io.read_s2le()
-                self._debug['origin_y']['end'] = self._io.pos()
-                self._debug['patch_id']['start'] = self._io.pos()
-                self.patch_id = self._io.read_u2le()
-                self._debug['patch_id']['end'] = self._io.pos()
-                self._debug['step_dir']['start'] = self._io.pos()
-                self.step_dir = self._io.read_u2le()
-                self._debug['step_dir']['end'] = self._io.pos()
-                self._debug['colormap']['start'] = self._io.pos()
-                self.colormap = self._io.read_u2le()
-                self._debug['colormap']['end'] = self._io.pos()
-
-
-
-    class Linedef(KaitaiStruct):
-        SEQ_FIELDS = ["vertex_start_idx", "vertex_end_idx", "flags", "line_type", "sector_tag", "sidedef_right_idx", "sidedef_left_idx"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['vertex_start_idx']['start'] = self._io.pos()
-            self.vertex_start_idx = self._io.read_u2le()
-            self._debug['vertex_start_idx']['end'] = self._io.pos()
-            self._debug['vertex_end_idx']['start'] = self._io.pos()
-            self.vertex_end_idx = self._io.read_u2le()
-            self._debug['vertex_end_idx']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_u2le()
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['line_type']['start'] = self._io.pos()
-            self.line_type = self._io.read_u2le()
-            self._debug['line_type']['end'] = self._io.pos()
-            self._debug['sector_tag']['start'] = self._io.pos()
-            self.sector_tag = self._io.read_u2le()
-            self._debug['sector_tag']['end'] = self._io.pos()
-            self._debug['sidedef_right_idx']['start'] = self._io.pos()
-            self.sidedef_right_idx = self._io.read_u2le()
-            self._debug['sidedef_right_idx']['end'] = self._io.pos()
-            self._debug['sidedef_left_idx']['start'] = self._io.pos()
-            self.sidedef_left_idx = self._io.read_u2le()
-            self._debug['sidedef_left_idx']['end'] = self._io.pos()
-
-
-    class Pnames(KaitaiStruct):
-        """
-        .. seealso::
-           Source - http://doom.wikia.com/wiki/PNAMES
-        """
-        SEQ_FIELDS = ["num_patches", "names"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_patches']['start'] = self._io.pos()
-            self.num_patches = self._io.read_u4le()
-            self._debug['num_patches']['end'] = self._io.pos()
-            self._debug['names']['start'] = self._io.pos()
-            self.names = [None] * (self.num_patches)
-            for i in range(self.num_patches):
-                if not 'arr' in self._debug['names']:
-                    self._debug['names']['arr'] = []
-                self._debug['names']['arr'].append({'start': self._io.pos()})
-                self.names[i] = (KaitaiStream.bytes_strip_right(self._io.read_bytes(8), 0)).decode(u"ASCII")
-                self._debug['names']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['names']['end'] = self._io.pos()
-
-
-    class Thing(KaitaiStruct):
-        SEQ_FIELDS = ["x", "y", "angle", "type", "flags"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_s2le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_s2le()
-            self._debug['y']['end'] = self._io.pos()
-            self._debug['angle']['start'] = self._io.pos()
-            self.angle = self._io.read_u2le()
-            self._debug['angle']['end'] = self._io.pos()
-            self._debug['type']['start'] = self._io.pos()
-            self.type = self._io.read_u2le()
-            self._debug['type']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_u2le()
-            self._debug['flags']['end'] = self._io.pos()
-
-
-    class Sector(KaitaiStruct):
-
-        class SpecialSector(Enum):
-            normal = 0
-            d_light_flicker = 1
-            d_light_strobe_fast = 2
-            d_light_strobe_slow = 3
-            d_light_strobe_hurt = 4
-            d_damage_hellslime = 5
-            d_damage_nukage = 7
-            d_light_glow = 8
-            secret = 9
-            d_sector_door_close_in_30 = 10
-            d_damage_end = 11
-            d_light_strobe_slow_sync = 12
-            d_light_strobe_fast_sync = 13
-            d_sector_door_raise_in_5_mins = 14
-            d_friction_low = 15
-            d_damage_super_hellslime = 16
-            d_light_fire_flicker = 17
-            d_damage_lava_wimpy = 18
-            d_damage_lava_hefty = 19
-            d_scroll_east_lava_damage = 20
-            light_phased = 21
-            light_sequence_start = 22
-            light_sequence_special1 = 23
-            light_sequence_special2 = 24
-        SEQ_FIELDS = ["floor_z", "ceil_z", "floor_flat", "ceil_flat", "light", "special_type", "tag"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['floor_z']['start'] = self._io.pos()
-            self.floor_z = self._io.read_s2le()
-            self._debug['floor_z']['end'] = self._io.pos()
-            self._debug['ceil_z']['start'] = self._io.pos()
-            self.ceil_z = self._io.read_s2le()
-            self._debug['ceil_z']['end'] = self._io.pos()
-            self._debug['floor_flat']['start'] = self._io.pos()
-            self.floor_flat = (self._io.read_bytes(8)).decode(u"ASCII")
-            self._debug['floor_flat']['end'] = self._io.pos()
-            self._debug['ceil_flat']['start'] = self._io.pos()
-            self.ceil_flat = (self._io.read_bytes(8)).decode(u"ASCII")
-            self._debug['ceil_flat']['end'] = self._io.pos()
-            self._debug['light']['start'] = self._io.pos()
-            self.light = self._io.read_s2le()
-            self._debug['light']['end'] = self._io.pos()
-            self._debug['special_type']['start'] = self._io.pos()
-            self.special_type = KaitaiStream.resolve_enum(self._root.Sector.SpecialSector, self._io.read_u2le())
-            self._debug['special_type']['end'] = self._io.pos()
-            self._debug['tag']['start'] = self._io.pos()
-            self.tag = self._io.read_u2le()
-            self._debug['tag']['end'] = self._io.pos()
-
-
-    class Vertexes(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Vertex(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class Sidedef(KaitaiStruct):
-        SEQ_FIELDS = ["offset_x", "offset_y", "upper_texture_name", "lower_texture_name", "normal_texture_name", "sector_id"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['offset_x']['start'] = self._io.pos()
-            self.offset_x = self._io.read_s2le()
-            self._debug['offset_x']['end'] = self._io.pos()
-            self._debug['offset_y']['start'] = self._io.pos()
-            self.offset_y = self._io.read_s2le()
-            self._debug['offset_y']['end'] = self._io.pos()
-            self._debug['upper_texture_name']['start'] = self._io.pos()
-            self.upper_texture_name = (self._io.read_bytes(8)).decode(u"ASCII")
-            self._debug['upper_texture_name']['end'] = self._io.pos()
-            self._debug['lower_texture_name']['start'] = self._io.pos()
-            self.lower_texture_name = (self._io.read_bytes(8)).decode(u"ASCII")
-            self._debug['lower_texture_name']['end'] = self._io.pos()
-            self._debug['normal_texture_name']['start'] = self._io.pos()
-            self.normal_texture_name = (self._io.read_bytes(8)).decode(u"ASCII")
-            self._debug['normal_texture_name']['end'] = self._io.pos()
-            self._debug['sector_id']['start'] = self._io.pos()
-            self.sector_id = self._io.read_s2le()
-            self._debug['sector_id']['end'] = self._io.pos()
-
-
-    class Things(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Thing(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class Linedefs(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Linedef(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class IndexEntry(KaitaiStruct):
-        SEQ_FIELDS = ["offset", "size", "name"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['offset']['start'] = self._io.pos()
-            self.offset = self._io.read_s4le()
-            self._debug['offset']['end'] = self._io.pos()
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_s4le()
-            self._debug['size']['end'] = self._io.pos()
-            self._debug['name']['start'] = self._io.pos()
-            self.name = (KaitaiStream.bytes_strip_right(self._io.read_bytes(8), 0)).decode(u"ASCII")
-            self._debug['name']['end'] = self._io.pos()
-
-        @property
-        def contents(self):
-            if hasattr(self, '_m_contents'):
-                return self._m_contents if hasattr(self, '_m_contents') else None
-
-            io = self._root._io
-            _pos = io.pos()
-            io.seek(self.offset)
-            self._debug['_m_contents']['start'] = io.pos()
-            _on = self.name
-            if _on == u"SECTORS":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Sectors(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"TEXTURE1":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Texture12(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"VERTEXES":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Vertexes(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"BLOCKMAP":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Blockmap(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"PNAMES":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Pnames(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"TEXTURE2":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Texture12(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"THINGS":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Things(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"LINEDEFS":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Linedefs(io, self, self._root)
-                self._m_contents._read()
-            elif _on == u"SIDEDEFS":
-                self._raw__m_contents = io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw__m_contents))
-                self._m_contents = self._root.Sidedefs(io, self, self._root)
-                self._m_contents._read()
-            else:
-                self._m_contents = io.read_bytes(self.size)
-            self._debug['_m_contents']['end'] = io.pos()
-            io.seek(_pos)
-            return self._m_contents if hasattr(self, '_m_contents') else None
-
-
-    class Sidedefs(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Sidedef(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class Blockmap(KaitaiStruct):
-        SEQ_FIELDS = ["origin_x", "origin_y", "num_cols", "num_rows", "linedefs_in_block"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['origin_x']['start'] = self._io.pos()
-            self.origin_x = self._io.read_s2le()
-            self._debug['origin_x']['end'] = self._io.pos()
-            self._debug['origin_y']['start'] = self._io.pos()
-            self.origin_y = self._io.read_s2le()
-            self._debug['origin_y']['end'] = self._io.pos()
-            self._debug['num_cols']['start'] = self._io.pos()
-            self.num_cols = self._io.read_s2le()
-            self._debug['num_cols']['end'] = self._io.pos()
-            self._debug['num_rows']['start'] = self._io.pos()
-            self.num_rows = self._io.read_s2le()
-            self._debug['num_rows']['end'] = self._io.pos()
-            self._debug['linedefs_in_block']['start'] = self._io.pos()
-            self.linedefs_in_block = [None] * ((self.num_cols * self.num_rows))
-            for i in range((self.num_cols * self.num_rows)):
-                if not 'arr' in self._debug['linedefs_in_block']:
-                    self._debug['linedefs_in_block']['arr'] = []
-                self._debug['linedefs_in_block']['arr'].append({'start': self._io.pos()})
-                _t_linedefs_in_block = self._root.Blockmap.Blocklist(self._io, self, self._root)
-                _t_linedefs_in_block._read()
-                self.linedefs_in_block[i] = _t_linedefs_in_block
-                self._debug['linedefs_in_block']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['linedefs_in_block']['end'] = self._io.pos()
-
-        class Blocklist(KaitaiStruct):
-            SEQ_FIELDS = ["offset"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['offset']['start'] = self._io.pos()
-                self.offset = self._io.read_u2le()
-                self._debug['offset']['end'] = self._io.pos()
-
-            @property
-            def linedefs(self):
-                """List of linedefs found in this block."""
-                if hasattr(self, '_m_linedefs'):
-                    return self._m_linedefs if hasattr(self, '_m_linedefs') else None
-
-                _pos = self._io.pos()
-                self._io.seek((self.offset * 2))
-                self._debug['_m_linedefs']['start'] = self._io.pos()
-                self._m_linedefs = []
-                i = 0
-                while True:
-                    if not 'arr' in self._debug['_m_linedefs']:
-                        self._debug['_m_linedefs']['arr'] = []
-                    self._debug['_m_linedefs']['arr'].append({'start': self._io.pos()})
-                    _ = self._io.read_s2le()
-                    self._m_linedefs.append(_)
-                    self._debug['_m_linedefs']['arr'][len(self._m_linedefs) - 1]['end'] = self._io.pos()
-                    if _ == -1:
-                        break
-                    i += 1
-                self._debug['_m_linedefs']['end'] = self._io.pos()
-                self._io.seek(_pos)
-                return self._m_linedefs if hasattr(self, '_m_linedefs') else None
-
-
-
-    @property
-    def index(self):
-        if hasattr(self, '_m_index'):
-            return self._m_index if hasattr(self, '_m_index') else None
-
-        _pos = self._io.pos()
-        self._io.seek(self.index_offset)
-        self._debug['_m_index']['start'] = self._io.pos()
-        self._m_index = [None] * (self.num_index_entries)
-        for i in range(self.num_index_entries):
-            if not 'arr' in self._debug['_m_index']:
-                self._debug['_m_index']['arr'] = []
-            self._debug['_m_index']['arr'].append({'start': self._io.pos()})
-            _t__m_index = self._root.IndexEntry(self._io, self, self._root)
-            _t__m_index._read()
-            self._m_index[i] = _t__m_index
-            self._debug['_m_index']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['_m_index']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_index if hasattr(self, '_m_index') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/dune_2_pak.py b/python/examples/kaitai/kaitai_struct_formats/game/dune_2_pak.py
deleted file mode 100644
index e074b018..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/dune_2_pak.py
+++ /dev/null
@@ -1,122 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class Dune2Pak(KaitaiStruct):
-    SEQ_FIELDS = ["dir"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['dir']['start'] = self._io.pos()
-        self._raw_dir = self._io.read_bytes(self.dir_size)
-        io = KaitaiStream(BytesIO(self._raw_dir))
-        self.dir = self._root.Files(io, self, self._root)
-        self.dir._read()
-        self._debug['dir']['end'] = self._io.pos()
-
-    class Files(KaitaiStruct):
-        SEQ_FIELDS = ["files"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['files']['start'] = self._io.pos()
-            self.files = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['files']:
-                    self._debug['files']['arr'] = []
-                self._debug['files']['arr'].append({'start': self._io.pos()})
-                _t_files = self._root.File(i, self._io, self, self._root)
-                _t_files._read()
-                self.files.append(_t_files)
-                self._debug['files']['arr'][len(self.files) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['files']['end'] = self._io.pos()
-
-
-    class File(KaitaiStruct):
-        SEQ_FIELDS = ["ofs", "file_name"]
-        def __init__(self, idx, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self.idx = idx
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['ofs']['start'] = self._io.pos()
-            self.ofs = self._io.read_u4le()
-            self._debug['ofs']['end'] = self._io.pos()
-            if self.ofs != 0:
-                self._debug['file_name']['start'] = self._io.pos()
-                self.file_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
-                self._debug['file_name']['end'] = self._io.pos()
-
-
-        @property
-        def next_ofs0(self):
-            if hasattr(self, '_m_next_ofs0'):
-                return self._m_next_ofs0 if hasattr(self, '_m_next_ofs0') else None
-
-            if self.ofs != 0:
-                self._m_next_ofs0 = self._root.dir.files[(self.idx + 1)].ofs
-
-            return self._m_next_ofs0 if hasattr(self, '_m_next_ofs0') else None
-
-        @property
-        def next_ofs(self):
-            if hasattr(self, '_m_next_ofs'):
-                return self._m_next_ofs if hasattr(self, '_m_next_ofs') else None
-
-            if self.ofs != 0:
-                self._m_next_ofs = (self._root._io.size() if self.next_ofs0 == 0 else self.next_ofs0)
-
-            return self._m_next_ofs if hasattr(self, '_m_next_ofs') else None
-
-        @property
-        def body(self):
-            if hasattr(self, '_m_body'):
-                return self._m_body if hasattr(self, '_m_body') else None
-
-            if self.ofs != 0:
-                io = self._root._io
-                _pos = io.pos()
-                io.seek(self.ofs)
-                self._debug['_m_body']['start'] = io.pos()
-                self._m_body = io.read_bytes((self.next_ofs - self.ofs))
-                self._debug['_m_body']['end'] = io.pos()
-                io.seek(_pos)
-
-            return self._m_body if hasattr(self, '_m_body') else None
-
-
-    @property
-    def dir_size(self):
-        if hasattr(self, '_m_dir_size'):
-            return self._m_dir_size if hasattr(self, '_m_dir_size') else None
-
-        _pos = self._io.pos()
-        self._io.seek(0)
-        self._debug['_m_dir_size']['start'] = self._io.pos()
-        self._m_dir_size = self._io.read_u4le()
-        self._debug['_m_dir_size']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_dir_size if hasattr(self, '_m_dir_size') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/fallout2_dat.py b/python/examples/kaitai/kaitai_struct_formats/game/fallout2_dat.py
deleted file mode 100644
index e22fc0d5..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/fallout2_dat.py
+++ /dev/null
@@ -1,161 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-import zlib
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class Fallout2Dat(KaitaiStruct):
-
-    class Compression(Enum):
-        none = 0
-        zlib = 1
-    SEQ_FIELDS = []
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        pass
-
-    class Pstr(KaitaiStruct):
-        SEQ_FIELDS = ["size", "str"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_u4le()
-            self._debug['size']['end'] = self._io.pos()
-            self._debug['str']['start'] = self._io.pos()
-            self.str = (self._io.read_bytes(self.size)).decode(u"ASCII")
-            self._debug['str']['end'] = self._io.pos()
-
-
-    class Footer(KaitaiStruct):
-        SEQ_FIELDS = ["index_size", "file_size"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['index_size']['start'] = self._io.pos()
-            self.index_size = self._io.read_u4le()
-            self._debug['index_size']['end'] = self._io.pos()
-            self._debug['file_size']['start'] = self._io.pos()
-            self.file_size = self._io.read_u4le()
-            self._debug['file_size']['end'] = self._io.pos()
-
-
-    class Index(KaitaiStruct):
-        SEQ_FIELDS = ["file_count", "files"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['file_count']['start'] = self._io.pos()
-            self.file_count = self._io.read_u4le()
-            self._debug['file_count']['end'] = self._io.pos()
-            self._debug['files']['start'] = self._io.pos()
-            self.files = [None] * (self.file_count)
-            for i in range(self.file_count):
-                if not 'arr' in self._debug['files']:
-                    self._debug['files']['arr'] = []
-                self._debug['files']['arr'].append({'start': self._io.pos()})
-                _t_files = self._root.File(self._io, self, self._root)
-                _t_files._read()
-                self.files[i] = _t_files
-                self._debug['files']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['files']['end'] = self._io.pos()
-
-
-    class File(KaitaiStruct):
-        SEQ_FIELDS = ["name", "flags", "size_unpacked", "size_packed", "offset"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['name']['start'] = self._io.pos()
-            self.name = self._root.Pstr(self._io, self, self._root)
-            self.name._read()
-            self._debug['name']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = KaitaiStream.resolve_enum(self._root.Compression, self._io.read_u1())
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['size_unpacked']['start'] = self._io.pos()
-            self.size_unpacked = self._io.read_u4le()
-            self._debug['size_unpacked']['end'] = self._io.pos()
-            self._debug['size_packed']['start'] = self._io.pos()
-            self.size_packed = self._io.read_u4le()
-            self._debug['size_packed']['end'] = self._io.pos()
-            self._debug['offset']['start'] = self._io.pos()
-            self.offset = self._io.read_u4le()
-            self._debug['offset']['end'] = self._io.pos()
-
-        @property
-        def contents(self):
-            if hasattr(self, '_m_contents'):
-                return self._m_contents if hasattr(self, '_m_contents') else None
-
-            if self.flags == self._root.Compression.zlib:
-                io = self._root._io
-                _pos = io.pos()
-                io.seek(self.offset)
-                self._debug['_m_contents']['start'] = io.pos()
-                self._raw__m_contents = io.read_bytes(self.size_packed)
-                self._m_contents = zlib.decompress(self._raw__m_contents)
-                self._debug['_m_contents']['end'] = io.pos()
-                io.seek(_pos)
-
-            return self._m_contents if hasattr(self, '_m_contents') else None
-
-
-    @property
-    def footer(self):
-        if hasattr(self, '_m_footer'):
-            return self._m_footer if hasattr(self, '_m_footer') else None
-
-        _pos = self._io.pos()
-        self._io.seek((self._io.size() - 8))
-        self._debug['_m_footer']['start'] = self._io.pos()
-        self._m_footer = self._root.Footer(self._io, self, self._root)
-        self._m_footer._read()
-        self._debug['_m_footer']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_footer if hasattr(self, '_m_footer') else None
-
-    @property
-    def index(self):
-        if hasattr(self, '_m_index'):
-            return self._m_index if hasattr(self, '_m_index') else None
-
-        _pos = self._io.pos()
-        self._io.seek(((self._io.size() - 8) - self.footer.index_size))
-        self._debug['_m_index']['start'] = self._io.pos()
-        self._m_index = self._root.Index(self._io, self, self._root)
-        self._m_index._read()
-        self._debug['_m_index']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_index if hasattr(self, '_m_index') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/fallout_dat.py b/python/examples/kaitai/kaitai_struct_formats/game/fallout_dat.py
deleted file mode 100644
index 4ce06191..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/fallout_dat.py
+++ /dev/null
@@ -1,156 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class FalloutDat(KaitaiStruct):
-
-    class Compression(Enum):
-        none = 32
-        lzss = 64
-    SEQ_FIELDS = ["folder_count", "unknown1", "unknown2", "timestamp", "folder_names", "folders"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['folder_count']['start'] = self._io.pos()
-        self.folder_count = self._io.read_u4be()
-        self._debug['folder_count']['end'] = self._io.pos()
-        self._debug['unknown1']['start'] = self._io.pos()
-        self.unknown1 = self._io.read_u4be()
-        self._debug['unknown1']['end'] = self._io.pos()
-        self._debug['unknown2']['start'] = self._io.pos()
-        self.unknown2 = self._io.read_u4be()
-        self._debug['unknown2']['end'] = self._io.pos()
-        self._debug['timestamp']['start'] = self._io.pos()
-        self.timestamp = self._io.read_u4be()
-        self._debug['timestamp']['end'] = self._io.pos()
-        self._debug['folder_names']['start'] = self._io.pos()
-        self.folder_names = [None] * (self.folder_count)
-        for i in range(self.folder_count):
-            if not 'arr' in self._debug['folder_names']:
-                self._debug['folder_names']['arr'] = []
-            self._debug['folder_names']['arr'].append({'start': self._io.pos()})
-            _t_folder_names = self._root.Pstr(self._io, self, self._root)
-            _t_folder_names._read()
-            self.folder_names[i] = _t_folder_names
-            self._debug['folder_names']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['folder_names']['end'] = self._io.pos()
-        self._debug['folders']['start'] = self._io.pos()
-        self.folders = [None] * (self.folder_count)
-        for i in range(self.folder_count):
-            if not 'arr' in self._debug['folders']:
-                self._debug['folders']['arr'] = []
-            self._debug['folders']['arr'].append({'start': self._io.pos()})
-            _t_folders = self._root.Folder(self._io, self, self._root)
-            _t_folders._read()
-            self.folders[i] = _t_folders
-            self._debug['folders']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['folders']['end'] = self._io.pos()
-
-    class Pstr(KaitaiStruct):
-        SEQ_FIELDS = ["size", "str"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_u1()
-            self._debug['size']['end'] = self._io.pos()
-            self._debug['str']['start'] = self._io.pos()
-            self.str = (self._io.read_bytes(self.size)).decode(u"ASCII")
-            self._debug['str']['end'] = self._io.pos()
-
-
-    class Folder(KaitaiStruct):
-        SEQ_FIELDS = ["file_count", "unknown", "flags", "timestamp", "files"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['file_count']['start'] = self._io.pos()
-            self.file_count = self._io.read_u4be()
-            self._debug['file_count']['end'] = self._io.pos()
-            self._debug['unknown']['start'] = self._io.pos()
-            self.unknown = self._io.read_u4be()
-            self._debug['unknown']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_u4be()
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['timestamp']['start'] = self._io.pos()
-            self.timestamp = self._io.read_u4be()
-            self._debug['timestamp']['end'] = self._io.pos()
-            self._debug['files']['start'] = self._io.pos()
-            self.files = [None] * (self.file_count)
-            for i in range(self.file_count):
-                if not 'arr' in self._debug['files']:
-                    self._debug['files']['arr'] = []
-                self._debug['files']['arr'].append({'start': self._io.pos()})
-                _t_files = self._root.File(self._io, self, self._root)
-                _t_files._read()
-                self.files[i] = _t_files
-                self._debug['files']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['files']['end'] = self._io.pos()
-
-
-    class File(KaitaiStruct):
-        SEQ_FIELDS = ["name", "flags", "offset", "size_unpacked", "size_packed"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['name']['start'] = self._io.pos()
-            self.name = self._root.Pstr(self._io, self, self._root)
-            self.name._read()
-            self._debug['name']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = KaitaiStream.resolve_enum(self._root.Compression, self._io.read_u4be())
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['offset']['start'] = self._io.pos()
-            self.offset = self._io.read_u4be()
-            self._debug['offset']['end'] = self._io.pos()
-            self._debug['size_unpacked']['start'] = self._io.pos()
-            self.size_unpacked = self._io.read_u4be()
-            self._debug['size_unpacked']['end'] = self._io.pos()
-            self._debug['size_packed']['start'] = self._io.pos()
-            self.size_packed = self._io.read_u4be()
-            self._debug['size_packed']['end'] = self._io.pos()
-
-        @property
-        def contents(self):
-            if hasattr(self, '_m_contents'):
-                return self._m_contents if hasattr(self, '_m_contents') else None
-
-            io = self._root._io
-            _pos = io.pos()
-            io.seek(self.offset)
-            self._debug['_m_contents']['start'] = io.pos()
-            self._m_contents = io.read_bytes((self.size_unpacked if self.flags == self._root.Compression.none else self.size_packed))
-            self._debug['_m_contents']['end'] = io.pos()
-            io.seek(_pos)
-            return self._m_contents if hasattr(self, '_m_contents') else None
-
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/ftl_dat.py b/python/examples/kaitai/kaitai_struct_formats/game/ftl_dat.py
deleted file mode 100644
index d56d478a..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/ftl_dat.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class FtlDat(KaitaiStruct):
-    SEQ_FIELDS = ["num_files", "files"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['num_files']['start'] = self._io.pos()
-        self.num_files = self._io.read_u4le()
-        self._debug['num_files']['end'] = self._io.pos()
-        self._debug['files']['start'] = self._io.pos()
-        self.files = [None] * (self.num_files)
-        for i in range(self.num_files):
-            if not 'arr' in self._debug['files']:
-                self._debug['files']['arr'] = []
-            self._debug['files']['arr'].append({'start': self._io.pos()})
-            _t_files = self._root.File(self._io, self, self._root)
-            _t_files._read()
-            self.files[i] = _t_files
-            self._debug['files']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['files']['end'] = self._io.pos()
-
-    class File(KaitaiStruct):
-        SEQ_FIELDS = ["ofs_meta"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['ofs_meta']['start'] = self._io.pos()
-            self.ofs_meta = self._io.read_u4le()
-            self._debug['ofs_meta']['end'] = self._io.pos()
-
-        @property
-        def meta(self):
-            if hasattr(self, '_m_meta'):
-                return self._m_meta if hasattr(self, '_m_meta') else None
-
-            if self.ofs_meta != 0:
-                _pos = self._io.pos()
-                self._io.seek(self.ofs_meta)
-                self._debug['_m_meta']['start'] = self._io.pos()
-                self._m_meta = self._root.Meta(self._io, self, self._root)
-                self._m_meta._read()
-                self._debug['_m_meta']['end'] = self._io.pos()
-                self._io.seek(_pos)
-
-            return self._m_meta if hasattr(self, '_m_meta') else None
-
-
-    class Meta(KaitaiStruct):
-        SEQ_FIELDS = ["len_file", "len_filename", "filename", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['len_file']['start'] = self._io.pos()
-            self.len_file = self._io.read_u4le()
-            self._debug['len_file']['end'] = self._io.pos()
-            self._debug['len_filename']['start'] = self._io.pos()
-            self.len_filename = self._io.read_u4le()
-            self._debug['len_filename']['end'] = self._io.pos()
-            self._debug['filename']['start'] = self._io.pos()
-            self.filename = (self._io.read_bytes(self.len_filename)).decode(u"UTF-8")
-            self._debug['filename']['end'] = self._io.pos()
-            self._debug['body']['start'] = self._io.pos()
-            self.body = self._io.read_bytes(self.len_file)
-            self._debug['body']['end'] = self._io.pos()
-
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/gran_turismo_vol.py b/python/examples/kaitai/kaitai_struct_formats/game/gran_turismo_vol.py
deleted file mode 100644
index 1b76c226..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/gran_turismo_vol.py
+++ /dev/null
@@ -1,136 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class GranTurismoVol(KaitaiStruct):
-    SEQ_FIELDS = ["magic", "num_files", "num_entries", "reserved", "offsets"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['magic']['start'] = self._io.pos()
-        self.magic = self._io.ensure_fixed_contents(b"\x47\x54\x46\x53\x00\x00\x00\x00")
-        self._debug['magic']['end'] = self._io.pos()
-        self._debug['num_files']['start'] = self._io.pos()
-        self.num_files = self._io.read_u2le()
-        self._debug['num_files']['end'] = self._io.pos()
-        self._debug['num_entries']['start'] = self._io.pos()
-        self.num_entries = self._io.read_u2le()
-        self._debug['num_entries']['end'] = self._io.pos()
-        self._debug['reserved']['start'] = self._io.pos()
-        self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00")
-        self._debug['reserved']['end'] = self._io.pos()
-        self._debug['offsets']['start'] = self._io.pos()
-        self.offsets = [None] * (self.num_files)
-        for i in range(self.num_files):
-            if not 'arr' in self._debug['offsets']:
-                self._debug['offsets']['arr'] = []
-            self._debug['offsets']['arr'].append({'start': self._io.pos()})
-            self.offsets[i] = self._io.read_u4le()
-            self._debug['offsets']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['offsets']['end'] = self._io.pos()
-
-    class FileInfo(KaitaiStruct):
-        SEQ_FIELDS = ["timestamp", "offset_idx", "flags", "name"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['timestamp']['start'] = self._io.pos()
-            self.timestamp = self._io.read_u4le()
-            self._debug['timestamp']['end'] = self._io.pos()
-            self._debug['offset_idx']['start'] = self._io.pos()
-            self.offset_idx = self._io.read_u2le()
-            self._debug['offset_idx']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_u1()
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['name']['start'] = self._io.pos()
-            self.name = (KaitaiStream.bytes_terminate(KaitaiStream.bytes_strip_right(self._io.read_bytes(25), 0), 0, False)).decode(u"ASCII")
-            self._debug['name']['end'] = self._io.pos()
-
-        @property
-        def size(self):
-            if hasattr(self, '_m_size'):
-                return self._m_size if hasattr(self, '_m_size') else None
-
-            self._m_size = ((self._root.offsets[(self.offset_idx + 1)] & 4294965248) - self._root.offsets[self.offset_idx])
-            return self._m_size if hasattr(self, '_m_size') else None
-
-        @property
-        def body(self):
-            if hasattr(self, '_m_body'):
-                return self._m_body if hasattr(self, '_m_body') else None
-
-            if not (self.is_dir):
-                _pos = self._io.pos()
-                self._io.seek((self._root.offsets[self.offset_idx] & 4294965248))
-                self._debug['_m_body']['start'] = self._io.pos()
-                self._m_body = self._io.read_bytes(self.size)
-                self._debug['_m_body']['end'] = self._io.pos()
-                self._io.seek(_pos)
-
-            return self._m_body if hasattr(self, '_m_body') else None
-
-        @property
-        def is_dir(self):
-            if hasattr(self, '_m_is_dir'):
-                return self._m_is_dir if hasattr(self, '_m_is_dir') else None
-
-            self._m_is_dir = (self.flags & 1) != 0
-            return self._m_is_dir if hasattr(self, '_m_is_dir') else None
-
-        @property
-        def is_last_entry(self):
-            if hasattr(self, '_m_is_last_entry'):
-                return self._m_is_last_entry if hasattr(self, '_m_is_last_entry') else None
-
-            self._m_is_last_entry = (self.flags & 128) != 0
-            return self._m_is_last_entry if hasattr(self, '_m_is_last_entry') else None
-
-
-    @property
-    def ofs_dir(self):
-        if hasattr(self, '_m_ofs_dir'):
-            return self._m_ofs_dir if hasattr(self, '_m_ofs_dir') else None
-
-        self._m_ofs_dir = self.offsets[1]
-        return self._m_ofs_dir if hasattr(self, '_m_ofs_dir') else None
-
-    @property
-    def files(self):
-        if hasattr(self, '_m_files'):
-            return self._m_files if hasattr(self, '_m_files') else None
-
-        _pos = self._io.pos()
-        self._io.seek((self.ofs_dir & 4294965248))
-        self._debug['_m_files']['start'] = self._io.pos()
-        self._m_files = [None] * (self._root.num_entries)
-        for i in range(self._root.num_entries):
-            if not 'arr' in self._debug['_m_files']:
-                self._debug['_m_files']['arr'] = []
-            self._debug['_m_files']['arr'].append({'start': self._io.pos()})
-            _t__m_files = self._root.FileInfo(self._io, self, self._root)
-            _t__m_files._read()
-            self._m_files[i] = _t__m_files
-            self._debug['_m_files']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['_m_files']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_files if hasattr(self, '_m_files') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/heaps_pak.py b/python/examples/kaitai/kaitai_struct_formats/game/heaps_pak.py
deleted file mode 100644
index 63937a47..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/heaps_pak.py
+++ /dev/null
@@ -1,173 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class HeapsPak(KaitaiStruct):
-    """
-    .. seealso::
-       Source - https://github.com/HeapsIO/heaps/blob/2bbc2b386952dfd8856c04a854bb706a52cb4b58/hxd/fmt/pak/Reader.hx
-    """
-    SEQ_FIELDS = ["header"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['header']['start'] = self._io.pos()
-        self.header = self._root.Header(self._io, self, self._root)
-        self.header._read()
-        self._debug['header']['end'] = self._io.pos()
-
-    class Header(KaitaiStruct):
-        SEQ_FIELDS = ["magic1", "version", "len_header", "len_data", "root_entry", "magic2"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['magic1']['start'] = self._io.pos()
-            self.magic1 = self._io.ensure_fixed_contents(b"\x50\x41\x4B")
-            self._debug['magic1']['end'] = self._io.pos()
-            self._debug['version']['start'] = self._io.pos()
-            self.version = self._io.read_u1()
-            self._debug['version']['end'] = self._io.pos()
-            self._debug['len_header']['start'] = self._io.pos()
-            self.len_header = self._io.read_u4le()
-            self._debug['len_header']['end'] = self._io.pos()
-            self._debug['len_data']['start'] = self._io.pos()
-            self.len_data = self._io.read_u4le()
-            self._debug['len_data']['end'] = self._io.pos()
-            self._debug['root_entry']['start'] = self._io.pos()
-            self._raw_root_entry = self._io.read_bytes((self.len_header - 16))
-            io = KaitaiStream(BytesIO(self._raw_root_entry))
-            self.root_entry = self._root.Header.Entry(io, self, self._root)
-            self.root_entry._read()
-            self._debug['root_entry']['end'] = self._io.pos()
-            self._debug['magic2']['start'] = self._io.pos()
-            self.magic2 = self._io.ensure_fixed_contents(b"\x44\x41\x54\x41")
-            self._debug['magic2']['end'] = self._io.pos()
-
-        class Entry(KaitaiStruct):
-            """
-            .. seealso::
-               Source - https://github.com/HeapsIO/heaps/blob/2bbc2b386952dfd8856c04a854bb706a52cb4b58/hxd/fmt/pak/Data.hx
-            """
-            SEQ_FIELDS = ["len_name", "name", "flags", "body"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['len_name']['start'] = self._io.pos()
-                self.len_name = self._io.read_u1()
-                self._debug['len_name']['end'] = self._io.pos()
-                self._debug['name']['start'] = self._io.pos()
-                self.name = (self._io.read_bytes(self.len_name)).decode(u"UTF-8")
-                self._debug['name']['end'] = self._io.pos()
-                self._debug['flags']['start'] = self._io.pos()
-                self.flags = self._root.Header.Entry.Flags(self._io, self, self._root)
-                self.flags._read()
-                self._debug['flags']['end'] = self._io.pos()
-                self._debug['body']['start'] = self._io.pos()
-                _on = self.flags.is_dir
-                if _on == True:
-                    self.body = self._root.Header.Dir(self._io, self, self._root)
-                    self.body._read()
-                elif _on == False:
-                    self.body = self._root.Header.File(self._io, self, self._root)
-                    self.body._read()
-                self._debug['body']['end'] = self._io.pos()
-
-            class Flags(KaitaiStruct):
-                SEQ_FIELDS = ["unused", "is_dir"]
-                def __init__(self, _io, _parent=None, _root=None):
-                    self._io = _io
-                    self._parent = _parent
-                    self._root = _root if _root else self
-                    self._debug = collections.defaultdict(dict)
-
-                def _read(self):
-                    self._debug['unused']['start'] = self._io.pos()
-                    self.unused = self._io.read_bits_int(7)
-                    self._debug['unused']['end'] = self._io.pos()
-                    self._debug['is_dir']['start'] = self._io.pos()
-                    self.is_dir = self._io.read_bits_int(1) != 0
-                    self._debug['is_dir']['end'] = self._io.pos()
-
-
-
-        class File(KaitaiStruct):
-            SEQ_FIELDS = ["ofs_data", "len_data", "checksum"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['ofs_data']['start'] = self._io.pos()
-                self.ofs_data = self._io.read_u4le()
-                self._debug['ofs_data']['end'] = self._io.pos()
-                self._debug['len_data']['start'] = self._io.pos()
-                self.len_data = self._io.read_u4le()
-                self._debug['len_data']['end'] = self._io.pos()
-                self._debug['checksum']['start'] = self._io.pos()
-                self.checksum = self._io.read_bytes(4)
-                self._debug['checksum']['end'] = self._io.pos()
-
-            @property
-            def data(self):
-                if hasattr(self, '_m_data'):
-                    return self._m_data if hasattr(self, '_m_data') else None
-
-                io = self._root._io
-                _pos = io.pos()
-                io.seek((self._root.header.len_header + self.ofs_data))
-                self._debug['_m_data']['start'] = io.pos()
-                self._m_data = io.read_bytes(self.len_data)
-                self._debug['_m_data']['end'] = io.pos()
-                io.seek(_pos)
-                return self._m_data if hasattr(self, '_m_data') else None
-
-
-        class Dir(KaitaiStruct):
-            SEQ_FIELDS = ["num_entries", "entries"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['num_entries']['start'] = self._io.pos()
-                self.num_entries = self._io.read_u4le()
-                self._debug['num_entries']['end'] = self._io.pos()
-                self._debug['entries']['start'] = self._io.pos()
-                self.entries = [None] * (self.num_entries)
-                for i in range(self.num_entries):
-                    if not 'arr' in self._debug['entries']:
-                        self._debug['entries']['arr'] = []
-                    self._debug['entries']['arr'].append({'start': self._io.pos()})
-                    _t_entries = self._root.Header.Entry(self._io, self, self._root)
-                    _t_entries._read()
-                    self.entries[i] = _t_entries
-                    self._debug['entries']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['entries']['end'] = self._io.pos()
-
-
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/heroes_of_might_and_magic_agg.py b/python/examples/kaitai/kaitai_struct_formats/game/heroes_of_might_and_magic_agg.py
deleted file mode 100644
index caff6a27..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/heroes_of_might_and_magic_agg.py
+++ /dev/null
@@ -1,116 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class HeroesOfMightAndMagicAgg(KaitaiStruct):
-    """
-    .. seealso::
-       Source - http://rewiki.regengedanken.de/wiki/.AGG_(Heroes_of_Might_and_Magic)
-    """
-    SEQ_FIELDS = ["num_files", "entries"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['num_files']['start'] = self._io.pos()
-        self.num_files = self._io.read_u2le()
-        self._debug['num_files']['end'] = self._io.pos()
-        self._debug['entries']['start'] = self._io.pos()
-        self.entries = [None] * (self.num_files)
-        for i in range(self.num_files):
-            if not 'arr' in self._debug['entries']:
-                self._debug['entries']['arr'] = []
-            self._debug['entries']['arr'].append({'start': self._io.pos()})
-            _t_entries = self._root.Entry(self._io, self, self._root)
-            _t_entries._read()
-            self.entries[i] = _t_entries
-            self._debug['entries']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['entries']['end'] = self._io.pos()
-
-    class Entry(KaitaiStruct):
-        SEQ_FIELDS = ["hash", "offset", "size", "size2"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['hash']['start'] = self._io.pos()
-            self.hash = self._io.read_u2le()
-            self._debug['hash']['end'] = self._io.pos()
-            self._debug['offset']['start'] = self._io.pos()
-            self.offset = self._io.read_u4le()
-            self._debug['offset']['end'] = self._io.pos()
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_u4le()
-            self._debug['size']['end'] = self._io.pos()
-            self._debug['size2']['start'] = self._io.pos()
-            self.size2 = self._io.read_u4le()
-            self._debug['size2']['end'] = self._io.pos()
-
-        @property
-        def body(self):
-            if hasattr(self, '_m_body'):
-                return self._m_body if hasattr(self, '_m_body') else None
-
-            _pos = self._io.pos()
-            self._io.seek(self.offset)
-            self._debug['_m_body']['start'] = self._io.pos()
-            self._m_body = self._io.read_bytes(self.size)
-            self._debug['_m_body']['end'] = self._io.pos()
-            self._io.seek(_pos)
-            return self._m_body if hasattr(self, '_m_body') else None
-
-
-    class Filename(KaitaiStruct):
-        SEQ_FIELDS = ["str"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['str']['start'] = self._io.pos()
-            self.str = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
-            self._debug['str']['end'] = self._io.pos()
-
-
-    @property
-    def filenames(self):
-        if hasattr(self, '_m_filenames'):
-            return self._m_filenames if hasattr(self, '_m_filenames') else None
-
-        _pos = self._io.pos()
-        self._io.seek((self.entries[-1].offset + self.entries[-1].size))
-        self._debug['_m_filenames']['start'] = self._io.pos()
-        self._raw__m_filenames = [None] * (self.num_files)
-        self._m_filenames = [None] * (self.num_files)
-        for i in range(self.num_files):
-            if not 'arr' in self._debug['_m_filenames']:
-                self._debug['_m_filenames']['arr'] = []
-            self._debug['_m_filenames']['arr'].append({'start': self._io.pos()})
-            self._raw__m_filenames[i] = self._io.read_bytes(15)
-            io = KaitaiStream(BytesIO(self._raw__m_filenames[i]))
-            _t__m_filenames = self._root.Filename(io, self, self._root)
-            _t__m_filenames._read()
-            self._m_filenames[i] = _t__m_filenames
-            self._debug['_m_filenames']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['_m_filenames']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_filenames if hasattr(self, '_m_filenames') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/heroes_of_might_and_magic_bmp.py b/python/examples/kaitai/kaitai_struct_formats/game/heroes_of_might_and_magic_bmp.py
deleted file mode 100644
index cc02696a..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/heroes_of_might_and_magic_bmp.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class HeroesOfMightAndMagicBmp(KaitaiStruct):
-    SEQ_FIELDS = ["magic", "width", "height", "data"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['magic']['start'] = self._io.pos()
-        self.magic = self._io.read_u2le()
-        self._debug['magic']['end'] = self._io.pos()
-        self._debug['width']['start'] = self._io.pos()
-        self.width = self._io.read_u2le()
-        self._debug['width']['end'] = self._io.pos()
-        self._debug['height']['start'] = self._io.pos()
-        self.height = self._io.read_u2le()
-        self._debug['height']['end'] = self._io.pos()
-        self._debug['data']['start'] = self._io.pos()
-        self.data = self._io.read_bytes((self.width * self.height))
-        self._debug['data']['end'] = self._io.pos()
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/quake_mdl.py b/python/examples/kaitai/kaitai_struct_formats/game/quake_mdl.py
deleted file mode 100644
index 7077e8f8..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/quake_mdl.py
+++ /dev/null
@@ -1,377 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class QuakeMdl(KaitaiStruct):
-    SEQ_FIELDS = ["header", "skins", "texture_coordinates", "triangles", "frames"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['header']['start'] = self._io.pos()
-        self.header = self._root.MdlHeader(self._io, self, self._root)
-        self.header._read()
-        self._debug['header']['end'] = self._io.pos()
-        self._debug['skins']['start'] = self._io.pos()
-        self.skins = [None] * (self.header.num_skins)
-        for i in range(self.header.num_skins):
-            if not 'arr' in self._debug['skins']:
-                self._debug['skins']['arr'] = []
-            self._debug['skins']['arr'].append({'start': self._io.pos()})
-            _t_skins = self._root.MdlSkin(self._io, self, self._root)
-            _t_skins._read()
-            self.skins[i] = _t_skins
-            self._debug['skins']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['skins']['end'] = self._io.pos()
-        self._debug['texture_coordinates']['start'] = self._io.pos()
-        self.texture_coordinates = [None] * (self.header.num_verts)
-        for i in range(self.header.num_verts):
-            if not 'arr' in self._debug['texture_coordinates']:
-                self._debug['texture_coordinates']['arr'] = []
-            self._debug['texture_coordinates']['arr'].append({'start': self._io.pos()})
-            _t_texture_coordinates = self._root.MdlTexcoord(self._io, self, self._root)
-            _t_texture_coordinates._read()
-            self.texture_coordinates[i] = _t_texture_coordinates
-            self._debug['texture_coordinates']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['texture_coordinates']['end'] = self._io.pos()
-        self._debug['triangles']['start'] = self._io.pos()
-        self.triangles = [None] * (self.header.num_tris)
-        for i in range(self.header.num_tris):
-            if not 'arr' in self._debug['triangles']:
-                self._debug['triangles']['arr'] = []
-            self._debug['triangles']['arr'].append({'start': self._io.pos()})
-            _t_triangles = self._root.MdlTriangle(self._io, self, self._root)
-            _t_triangles._read()
-            self.triangles[i] = _t_triangles
-            self._debug['triangles']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['triangles']['end'] = self._io.pos()
-        self._debug['frames']['start'] = self._io.pos()
-        self.frames = [None] * (self.header.num_frames)
-        for i in range(self.header.num_frames):
-            if not 'arr' in self._debug['frames']:
-                self._debug['frames']['arr'] = []
-            self._debug['frames']['arr'].append({'start': self._io.pos()})
-            _t_frames = self._root.MdlFrame(self._io, self, self._root)
-            _t_frames._read()
-            self.frames[i] = _t_frames
-            self._debug['frames']['arr'][i]['end'] = self._io.pos()
-
-        self._debug['frames']['end'] = self._io.pos()
-
-    class MdlVertex(KaitaiStruct):
-        SEQ_FIELDS = ["values", "normal_index"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['values']['start'] = self._io.pos()
-            self.values = [None] * (3)
-            for i in range(3):
-                if not 'arr' in self._debug['values']:
-                    self._debug['values']['arr'] = []
-                self._debug['values']['arr'].append({'start': self._io.pos()})
-                self.values[i] = self._io.read_u1()
-                self._debug['values']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['values']['end'] = self._io.pos()
-            self._debug['normal_index']['start'] = self._io.pos()
-            self.normal_index = self._io.read_u1()
-            self._debug['normal_index']['end'] = self._io.pos()
-
-
-    class MdlTexcoord(KaitaiStruct):
-        SEQ_FIELDS = ["on_seam", "s", "t"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['on_seam']['start'] = self._io.pos()
-            self.on_seam = self._io.read_s4le()
-            self._debug['on_seam']['end'] = self._io.pos()
-            self._debug['s']['start'] = self._io.pos()
-            self.s = self._io.read_s4le()
-            self._debug['s']['end'] = self._io.pos()
-            self._debug['t']['start'] = self._io.pos()
-            self.t = self._io.read_s4le()
-            self._debug['t']['end'] = self._io.pos()
-
-
-    class MdlHeader(KaitaiStruct):
-        SEQ_FIELDS = ["ident", "version_must_be_6", "scale", "origin", "radius", "eye_position", "num_skins", "skin_width", "skin_height", "num_verts", "num_tris", "num_frames", "synctype", "flags", "size"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['ident']['start'] = self._io.pos()
-            self.ident = self._io.ensure_fixed_contents(b"\x49\x44\x50\x4F")
-            self._debug['ident']['end'] = self._io.pos()
-            self._debug['version_must_be_6']['start'] = self._io.pos()
-            self.version_must_be_6 = self._io.ensure_fixed_contents(b"\x06\x00\x00\x00")
-            self._debug['version_must_be_6']['end'] = self._io.pos()
-            self._debug['scale']['start'] = self._io.pos()
-            self.scale = self._root.Vec3(self._io, self, self._root)
-            self.scale._read()
-            self._debug['scale']['end'] = self._io.pos()
-            self._debug['origin']['start'] = self._io.pos()
-            self.origin = self._root.Vec3(self._io, self, self._root)
-            self.origin._read()
-            self._debug['origin']['end'] = self._io.pos()
-            self._debug['radius']['start'] = self._io.pos()
-            self.radius = self._io.read_f4le()
-            self._debug['radius']['end'] = self._io.pos()
-            self._debug['eye_position']['start'] = self._io.pos()
-            self.eye_position = self._root.Vec3(self._io, self, self._root)
-            self.eye_position._read()
-            self._debug['eye_position']['end'] = self._io.pos()
-            self._debug['num_skins']['start'] = self._io.pos()
-            self.num_skins = self._io.read_s4le()
-            self._debug['num_skins']['end'] = self._io.pos()
-            self._debug['skin_width']['start'] = self._io.pos()
-            self.skin_width = self._io.read_s4le()
-            self._debug['skin_width']['end'] = self._io.pos()
-            self._debug['skin_height']['start'] = self._io.pos()
-            self.skin_height = self._io.read_s4le()
-            self._debug['skin_height']['end'] = self._io.pos()
-            self._debug['num_verts']['start'] = self._io.pos()
-            self.num_verts = self._io.read_s4le()
-            self._debug['num_verts']['end'] = self._io.pos()
-            self._debug['num_tris']['start'] = self._io.pos()
-            self.num_tris = self._io.read_s4le()
-            self._debug['num_tris']['end'] = self._io.pos()
-            self._debug['num_frames']['start'] = self._io.pos()
-            self.num_frames = self._io.read_s4le()
-            self._debug['num_frames']['end'] = self._io.pos()
-            self._debug['synctype']['start'] = self._io.pos()
-            self.synctype = self._io.read_s4le()
-            self._debug['synctype']['end'] = self._io.pos()
-            self._debug['flags']['start'] = self._io.pos()
-            self.flags = self._io.read_s4le()
-            self._debug['flags']['end'] = self._io.pos()
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_f4le()
-            self._debug['size']['end'] = self._io.pos()
-
-        @property
-        def version(self):
-            if hasattr(self, '_m_version'):
-                return self._m_version if hasattr(self, '_m_version') else None
-
-            self._m_version = 6
-            return self._m_version if hasattr(self, '_m_version') else None
-
-        @property
-        def skin_size(self):
-            if hasattr(self, '_m_skin_size'):
-                return self._m_skin_size if hasattr(self, '_m_skin_size') else None
-
-            self._m_skin_size = (self.skin_width * self.skin_height)
-            return self._m_skin_size if hasattr(self, '_m_skin_size') else None
-
-
-    class MdlSkin(KaitaiStruct):
-        SEQ_FIELDS = ["group", "single_texture_data", "num_frames", "frame_times", "group_texture_data"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['group']['start'] = self._io.pos()
-            self.group = self._io.read_s4le()
-            self._debug['group']['end'] = self._io.pos()
-            if self.group == 0:
-                self._debug['single_texture_data']['start'] = self._io.pos()
-                self.single_texture_data = self._io.read_bytes(self._root.header.skin_size)
-                self._debug['single_texture_data']['end'] = self._io.pos()
-
-            if self.group != 0:
-                self._debug['num_frames']['start'] = self._io.pos()
-                self.num_frames = self._io.read_u4le()
-                self._debug['num_frames']['end'] = self._io.pos()
-
-            if self.group != 0:
-                self._debug['frame_times']['start'] = self._io.pos()
-                self.frame_times = [None] * (self.num_frames)
-                for i in range(self.num_frames):
-                    if not 'arr' in self._debug['frame_times']:
-                        self._debug['frame_times']['arr'] = []
-                    self._debug['frame_times']['arr'].append({'start': self._io.pos()})
-                    self.frame_times[i] = self._io.read_f4le()
-                    self._debug['frame_times']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['frame_times']['end'] = self._io.pos()
-
-            if self.group != 0:
-                self._debug['group_texture_data']['start'] = self._io.pos()
-                self.group_texture_data = [None] * (self.num_frames)
-                for i in range(self.num_frames):
-                    if not 'arr' in self._debug['group_texture_data']:
-                        self._debug['group_texture_data']['arr'] = []
-                    self._debug['group_texture_data']['arr'].append({'start': self._io.pos()})
-                    self.group_texture_data[i] = self._io.read_bytes(self._root.header.skin_size)
-                    self._debug['group_texture_data']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['group_texture_data']['end'] = self._io.pos()
-
-
-
-    class MdlFrame(KaitaiStruct):
-        SEQ_FIELDS = ["type", "min", "max", "time", "frames"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['type']['start'] = self._io.pos()
-            self.type = self._io.read_s4le()
-            self._debug['type']['end'] = self._io.pos()
-            if self.type != 0:
-                self._debug['min']['start'] = self._io.pos()
-                self.min = self._root.MdlVertex(self._io, self, self._root)
-                self.min._read()
-                self._debug['min']['end'] = self._io.pos()
-
-            if self.type != 0:
-                self._debug['max']['start'] = self._io.pos()
-                self.max = self._root.MdlVertex(self._io, self, self._root)
-                self.max._read()
-                self._debug['max']['end'] = self._io.pos()
-
-            if self.type != 0:
-                self._debug['time']['start'] = self._io.pos()
-                self.time = [None] * (self.type)
-                for i in range(self.type):
-                    if not 'arr' in self._debug['time']:
-                        self._debug['time']['arr'] = []
-                    self._debug['time']['arr'].append({'start': self._io.pos()})
-                    self.time[i] = self._io.read_f4le()
-                    self._debug['time']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['time']['end'] = self._io.pos()
-
-            self._debug['frames']['start'] = self._io.pos()
-            self.frames = [None] * (self.num_simple_frames)
-            for i in range(self.num_simple_frames):
-                if not 'arr' in self._debug['frames']:
-                    self._debug['frames']['arr'] = []
-                self._debug['frames']['arr'].append({'start': self._io.pos()})
-                _t_frames = self._root.MdlSimpleFrame(self._io, self, self._root)
-                _t_frames._read()
-                self.frames[i] = _t_frames
-                self._debug['frames']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['frames']['end'] = self._io.pos()
-
-        @property
-        def num_simple_frames(self):
-            if hasattr(self, '_m_num_simple_frames'):
-                return self._m_num_simple_frames if hasattr(self, '_m_num_simple_frames') else None
-
-            self._m_num_simple_frames = (1 if self.type == 0 else self.type)
-            return self._m_num_simple_frames if hasattr(self, '_m_num_simple_frames') else None
-
-
-    class MdlSimpleFrame(KaitaiStruct):
-        SEQ_FIELDS = ["bbox_min", "bbox_max", "name", "vertices"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['bbox_min']['start'] = self._io.pos()
-            self.bbox_min = self._root.MdlVertex(self._io, self, self._root)
-            self.bbox_min._read()
-            self._debug['bbox_min']['end'] = self._io.pos()
-            self._debug['bbox_max']['start'] = self._io.pos()
-            self.bbox_max = self._root.MdlVertex(self._io, self, self._root)
-            self.bbox_max._read()
-            self._debug['bbox_max']['end'] = self._io.pos()
-            self._debug['name']['start'] = self._io.pos()
-            self.name = (KaitaiStream.bytes_terminate(KaitaiStream.bytes_strip_right(self._io.read_bytes(16), 0), 0, False)).decode(u"ASCII")
-            self._debug['name']['end'] = self._io.pos()
-            self._debug['vertices']['start'] = self._io.pos()
-            self.vertices = [None] * (self._root.header.num_verts)
-            for i in range(self._root.header.num_verts):
-                if not 'arr' in self._debug['vertices']:
-                    self._debug['vertices']['arr'] = []
-                self._debug['vertices']['arr'].append({'start': self._io.pos()})
-                _t_vertices = self._root.MdlVertex(self._io, self, self._root)
-                _t_vertices._read()
-                self.vertices[i] = _t_vertices
-                self._debug['vertices']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['vertices']['end'] = self._io.pos()
-
-
-    class MdlTriangle(KaitaiStruct):
-        SEQ_FIELDS = ["faces_front", "vertices"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['faces_front']['start'] = self._io.pos()
-            self.faces_front = self._io.read_s4le()
-            self._debug['faces_front']['end'] = self._io.pos()
-            self._debug['vertices']['start'] = self._io.pos()
-            self.vertices = [None] * (3)
-            for i in range(3):
-                if not 'arr' in self._debug['vertices']:
-                    self._debug['vertices']['arr'] = []
-                self._debug['vertices']['arr'].append({'start': self._io.pos()})
-                self.vertices[i] = self._io.read_s4le()
-                self._debug['vertices']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['vertices']['end'] = self._io.pos()
-
-
-    class Vec3(KaitaiStruct):
-        SEQ_FIELDS = ["x", "y", "z"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_f4le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_f4le()
-            self._debug['y']['end'] = self._io.pos()
-            self._debug['z']['start'] = self._io.pos()
-            self.z = self._io.read_f4le()
-            self._debug['z']['end'] = self._io.pos()
-
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/quake_pak.py b/python/examples/kaitai/kaitai_struct_formats/game/quake_pak.py
deleted file mode 100644
index 3b4c0358..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/quake_pak.py
+++ /dev/null
@@ -1,110 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class QuakePak(KaitaiStruct):
-    """
-    .. seealso::
-       Source - https://quakewiki.org/wiki/.pak#Format_specification
-    """
-    SEQ_FIELDS = ["magic", "ofs_index", "len_index"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['magic']['start'] = self._io.pos()
-        self.magic = self._io.ensure_fixed_contents(b"\x50\x41\x43\x4B")
-        self._debug['magic']['end'] = self._io.pos()
-        self._debug['ofs_index']['start'] = self._io.pos()
-        self.ofs_index = self._io.read_u4le()
-        self._debug['ofs_index']['end'] = self._io.pos()
-        self._debug['len_index']['start'] = self._io.pos()
-        self.len_index = self._io.read_u4le()
-        self._debug['len_index']['end'] = self._io.pos()
-
-    class IndexStruct(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.IndexEntry(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class IndexEntry(KaitaiStruct):
-        SEQ_FIELDS = ["name", "ofs", "size"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['name']['start'] = self._io.pos()
-            self.name = (KaitaiStream.bytes_terminate(KaitaiStream.bytes_strip_right(self._io.read_bytes(56), 0), 0, False)).decode(u"UTF-8")
-            self._debug['name']['end'] = self._io.pos()
-            self._debug['ofs']['start'] = self._io.pos()
-            self.ofs = self._io.read_u4le()
-            self._debug['ofs']['end'] = self._io.pos()
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_u4le()
-            self._debug['size']['end'] = self._io.pos()
-
-        @property
-        def body(self):
-            if hasattr(self, '_m_body'):
-                return self._m_body if hasattr(self, '_m_body') else None
-
-            io = self._root._io
-            _pos = io.pos()
-            io.seek(self.ofs)
-            self._debug['_m_body']['start'] = io.pos()
-            self._m_body = io.read_bytes(self.size)
-            self._debug['_m_body']['end'] = io.pos()
-            io.seek(_pos)
-            return self._m_body if hasattr(self, '_m_body') else None
-
-
-    @property
-    def index(self):
-        if hasattr(self, '_m_index'):
-            return self._m_index if hasattr(self, '_m_index') else None
-
-        _pos = self._io.pos()
-        self._io.seek(self.ofs_index)
-        self._debug['_m_index']['start'] = self._io.pos()
-        self._raw__m_index = self._io.read_bytes(self.len_index)
-        io = KaitaiStream(BytesIO(self._raw__m_index))
-        self._m_index = self._root.IndexStruct(io, self, self._root)
-        self._m_index._read()
-        self._debug['_m_index']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_index if hasattr(self, '_m_index') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/renderware_binary_stream.py b/python/examples/kaitai/kaitai_struct_formats/game/renderware_binary_stream.py
deleted file mode 100644
index 5e27c895..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/renderware_binary_stream.py
+++ /dev/null
@@ -1,774 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class RenderwareBinaryStream(KaitaiStruct):
-    """
-    .. seealso::
-       Source - https://www.gtamodding.com/wiki/RenderWare_binary_stream_file
-    """
-
-    class Sections(Enum):
-        struct = 1
-        string = 2
-        extension = 3
-        camera = 5
-        texture = 6
-        material = 7
-        material_list = 8
-        atomic_section = 9
-        plane_section = 10
-        world = 11
-        spline = 12
-        matrix = 13
-        frame_list = 14
-        geometry = 15
-        clump = 16
-        light = 18
-        unicode_string = 19
-        atomic = 20
-        texture_native = 21
-        texture_dictionary = 22
-        animation_database = 23
-        image = 24
-        skin_animation = 25
-        geometry_list = 26
-        anim_animation = 27
-        team = 28
-        crowd = 29
-        delta_morph_animation = 30
-        right_to_render = 31
-        multitexture_effect_native = 32
-        multitexture_effect_dictionary = 33
-        team_dictionary = 34
-        platform_independent_texture_dictionary = 35
-        table_of_contents = 36
-        particle_standard_global_data = 37
-        altpipe = 38
-        platform_independent_peds = 39
-        patch_mesh = 40
-        chunk_group_start = 41
-        chunk_group_end = 42
-        uv_animation_dictionary = 43
-        coll_tree = 44
-        metrics_plg = 257
-        spline_plg = 258
-        stereo_plg = 259
-        vrml_plg = 260
-        morph_plg = 261
-        pvs_plg = 262
-        memory_leak_plg = 263
-        animation_plg = 264
-        gloss_plg = 265
-        logo_plg = 266
-        memory_info_plg = 267
-        random_plg = 268
-        png_image_plg = 269
-        bone_plg = 270
-        vrml_anim_plg = 271
-        sky_mipmap_val = 272
-        mrm_plg = 273
-        lod_atomic_plg = 274
-        me_plg = 275
-        lightmap_plg = 276
-        refine_plg = 277
-        skin_plg = 278
-        label_plg = 279
-        particles_plg = 280
-        geomtx_plg = 281
-        synth_core_plg = 282
-        stqpp_plg = 283
-        part_pp_plg = 284
-        collision_plg = 285
-        hanim_plg = 286
-        user_data_plg = 287
-        material_effects_plg = 288
-        particle_system_plg = 289
-        delta_morph_plg = 290
-        patch_plg = 291
-        team_plg = 292
-        crowd_pp_plg = 293
-        mip_split_plg = 294
-        anisotropy_plg = 295
-        gcn_material_plg = 297
-        geometric_pvs_plg = 298
-        xbox_material_plg = 299
-        multi_texture_plg = 300
-        chain_plg = 301
-        toon_plg = 302
-        ptank_plg = 303
-        particle_standard_plg = 304
-        pds_plg = 305
-        prtadv_plg = 306
-        normal_map_plg = 307
-        adc_plg = 308
-        uv_animation_plg = 309
-        character_set_plg = 384
-        nohs_world_plg = 385
-        import_util_plg = 386
-        slerp_plg = 387
-        optim_plg = 388
-        tl_world_plg = 389
-        database_plg = 390
-        raytrace_plg = 391
-        ray_plg = 392
-        library_plg = 393
-        plg_2d = 400
-        tile_render_plg = 401
-        jpeg_image_plg = 402
-        tga_image_plg = 403
-        gif_image_plg = 404
-        quat_plg = 405
-        spline_pvs_plg = 406
-        mipmap_plg = 407
-        mipmapk_plg = 408
-        font_2d = 409
-        intersection_plg = 410
-        tiff_image_plg = 411
-        pick_plg = 412
-        bmp_image_plg = 413
-        ras_image_plg = 414
-        skin_fx_plg = 415
-        vcat_plg = 416
-        path_2d = 417
-        brush_2d = 418
-        object_2d = 419
-        shape_2d = 420
-        scene_2d = 421
-        pick_region_2d = 422
-        object_string_2d = 423
-        animation_plg_2d = 424
-        animation_2d = 425
-        keyframe_2d = 432
-        maestro_2d = 433
-        barycentric = 434
-        platform_independent_texture_dictionary_tk = 435
-        toc_tk = 436
-        tpl_tk = 437
-        altpipe_tk = 438
-        animation_tk = 439
-        skin_split_tookit = 440
-        compressed_key_tk = 441
-        geometry_conditioning_plg = 442
-        wing_plg = 443
-        generic_pipeline_tk = 444
-        lightmap_conversion_tk = 445
-        filesystem_plg = 446
-        dictionary_tk = 447
-        uv_animation_linear = 448
-        uv_animation_parameter = 449
-        bin_mesh_plg = 1294
-        native_data_plg = 1296
-        zmodeler_lock = 61982
-        atomic_visibility_distance = 39055872
-        clump_visibility_distance = 39055873
-        frame_visibility_distance = 39055874
-        pipeline_set = 39056115
-        unused_5 = 39056116
-        texdictionary_link = 39056117
-        specular_material = 39056118
-        unused_8 = 39056119
-        effect_2d = 39056120
-        extra_vert_colour = 39056121
-        collision_model = 39056122
-        gta_hanim = 39056123
-        reflection_material = 39056124
-        breakable = 39056125
-        frame = 39056126
-        unused_16 = 39056127
-    SEQ_FIELDS = ["code", "size", "version", "body"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['code']['start'] = self._io.pos()
-        self.code = KaitaiStream.resolve_enum(self._root.Sections, self._io.read_u4le())
-        self._debug['code']['end'] = self._io.pos()
-        self._debug['size']['start'] = self._io.pos()
-        self.size = self._io.read_u4le()
-        self._debug['size']['end'] = self._io.pos()
-        self._debug['version']['start'] = self._io.pos()
-        self.version = self._io.read_u4le()
-        self._debug['version']['end'] = self._io.pos()
-        self._debug['body']['start'] = self._io.pos()
-        _on = self.code
-        if _on == self._root.Sections.geometry:
-            self._raw_body = self._io.read_bytes(self.size)
-            io = KaitaiStream(BytesIO(self._raw_body))
-            self.body = self._root.ListWithHeader(io, self, self._root)
-            self.body._read()
-        elif _on == self._root.Sections.texture_dictionary:
-            self._raw_body = self._io.read_bytes(self.size)
-            io = KaitaiStream(BytesIO(self._raw_body))
-            self.body = self._root.ListWithHeader(io, self, self._root)
-            self.body._read()
-        elif _on == self._root.Sections.geometry_list:
-            self._raw_body = self._io.read_bytes(self.size)
-            io = KaitaiStream(BytesIO(self._raw_body))
-            self.body = self._root.ListWithHeader(io, self, self._root)
-            self.body._read()
-        elif _on == self._root.Sections.texture_native:
-            self._raw_body = self._io.read_bytes(self.size)
-            io = KaitaiStream(BytesIO(self._raw_body))
-            self.body = self._root.ListWithHeader(io, self, self._root)
-            self.body._read()
-        elif _on == self._root.Sections.clump:
-            self._raw_body = self._io.read_bytes(self.size)
-            io = KaitaiStream(BytesIO(self._raw_body))
-            self.body = self._root.ListWithHeader(io, self, self._root)
-            self.body._read()
-        elif _on == self._root.Sections.frame_list:
-            self._raw_body = self._io.read_bytes(self.size)
-            io = KaitaiStream(BytesIO(self._raw_body))
-            self.body = self._root.ListWithHeader(io, self, self._root)
-            self.body._read()
-        else:
-            self.body = self._io.read_bytes(self.size)
-        self._debug['body']['end'] = self._io.pos()
-
-    class StructClump(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/RpClump
-        """
-        SEQ_FIELDS = ["num_atomics", "num_lights", "num_cameras"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_atomics']['start'] = self._io.pos()
-            self.num_atomics = self._io.read_u4le()
-            self._debug['num_atomics']['end'] = self._io.pos()
-            if self._parent.version >= 208896:
-                self._debug['num_lights']['start'] = self._io.pos()
-                self.num_lights = self._io.read_u4le()
-                self._debug['num_lights']['end'] = self._io.pos()
-
-            if self._parent.version >= 208896:
-                self._debug['num_cameras']['start'] = self._io.pos()
-                self.num_cameras = self._io.read_u4le()
-                self._debug['num_cameras']['end'] = self._io.pos()
-
-
-
-    class StructGeometry(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/RpGeometry
-        """
-        SEQ_FIELDS = ["format", "num_triangles", "num_vertices", "num_morph_targets", "surf_prop", "geometry", "morph_targets"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['format']['start'] = self._io.pos()
-            self.format = self._io.read_u4le()
-            self._debug['format']['end'] = self._io.pos()
-            self._debug['num_triangles']['start'] = self._io.pos()
-            self.num_triangles = self._io.read_u4le()
-            self._debug['num_triangles']['end'] = self._io.pos()
-            self._debug['num_vertices']['start'] = self._io.pos()
-            self.num_vertices = self._io.read_u4le()
-            self._debug['num_vertices']['end'] = self._io.pos()
-            self._debug['num_morph_targets']['start'] = self._io.pos()
-            self.num_morph_targets = self._io.read_u4le()
-            self._debug['num_morph_targets']['end'] = self._io.pos()
-            if self._parent.version < 212992:
-                self._debug['surf_prop']['start'] = self._io.pos()
-                self.surf_prop = self._root.SurfaceProperties(self._io, self, self._root)
-                self.surf_prop._read()
-                self._debug['surf_prop']['end'] = self._io.pos()
-
-            if not (self.is_native):
-                self._debug['geometry']['start'] = self._io.pos()
-                self.geometry = self._root.GeometryNonNative(self._io, self, self._root)
-                self.geometry._read()
-                self._debug['geometry']['end'] = self._io.pos()
-
-            self._debug['morph_targets']['start'] = self._io.pos()
-            self.morph_targets = [None] * (self.num_morph_targets)
-            for i in range(self.num_morph_targets):
-                if not 'arr' in self._debug['morph_targets']:
-                    self._debug['morph_targets']['arr'] = []
-                self._debug['morph_targets']['arr'].append({'start': self._io.pos()})
-                _t_morph_targets = self._root.MorphTarget(self._io, self, self._root)
-                _t_morph_targets._read()
-                self.morph_targets[i] = _t_morph_targets
-                self._debug['morph_targets']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['morph_targets']['end'] = self._io.pos()
-
-        @property
-        def is_textured(self):
-            if hasattr(self, '_m_is_textured'):
-                return self._m_is_textured if hasattr(self, '_m_is_textured') else None
-
-            self._m_is_textured = (self.format & 4) != 0
-            return self._m_is_textured if hasattr(self, '_m_is_textured') else None
-
-        @property
-        def is_prelit(self):
-            if hasattr(self, '_m_is_prelit'):
-                return self._m_is_prelit if hasattr(self, '_m_is_prelit') else None
-
-            self._m_is_prelit = (self.format & 8) != 0
-            return self._m_is_prelit if hasattr(self, '_m_is_prelit') else None
-
-        @property
-        def is_textured2(self):
-            if hasattr(self, '_m_is_textured2'):
-                return self._m_is_textured2 if hasattr(self, '_m_is_textured2') else None
-
-            self._m_is_textured2 = (self.format & 128) != 0
-            return self._m_is_textured2 if hasattr(self, '_m_is_textured2') else None
-
-        @property
-        def is_native(self):
-            if hasattr(self, '_m_is_native'):
-                return self._m_is_native if hasattr(self, '_m_is_native') else None
-
-            self._m_is_native = (self.format & 16777216) != 0
-            return self._m_is_native if hasattr(self, '_m_is_native') else None
-
-
-    class GeometryNonNative(KaitaiStruct):
-        SEQ_FIELDS = ["prelit_colors", "tex_coords", "triangles"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            if self._parent.is_prelit:
-                self._debug['prelit_colors']['start'] = self._io.pos()
-                self.prelit_colors = [None] * (self._parent.num_vertices)
-                for i in range(self._parent.num_vertices):
-                    if not 'arr' in self._debug['prelit_colors']:
-                        self._debug['prelit_colors']['arr'] = []
-                    self._debug['prelit_colors']['arr'].append({'start': self._io.pos()})
-                    _t_prelit_colors = self._root.Rgba(self._io, self, self._root)
-                    _t_prelit_colors._read()
-                    self.prelit_colors[i] = _t_prelit_colors
-                    self._debug['prelit_colors']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['prelit_colors']['end'] = self._io.pos()
-
-            if  ((self._parent.is_textured) or (self._parent.is_textured2)) :
-                self._debug['tex_coords']['start'] = self._io.pos()
-                self.tex_coords = [None] * (self._parent.num_vertices)
-                for i in range(self._parent.num_vertices):
-                    if not 'arr' in self._debug['tex_coords']:
-                        self._debug['tex_coords']['arr'] = []
-                    self._debug['tex_coords']['arr'].append({'start': self._io.pos()})
-                    _t_tex_coords = self._root.TexCoord(self._io, self, self._root)
-                    _t_tex_coords._read()
-                    self.tex_coords[i] = _t_tex_coords
-                    self._debug['tex_coords']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['tex_coords']['end'] = self._io.pos()
-
-            self._debug['triangles']['start'] = self._io.pos()
-            self.triangles = [None] * (self._parent.num_triangles)
-            for i in range(self._parent.num_triangles):
-                if not 'arr' in self._debug['triangles']:
-                    self._debug['triangles']['arr'] = []
-                self._debug['triangles']['arr'].append({'start': self._io.pos()})
-                _t_triangles = self._root.Triangle(self._io, self, self._root)
-                _t_triangles._read()
-                self.triangles[i] = _t_triangles
-                self._debug['triangles']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['triangles']['end'] = self._io.pos()
-
-
-    class StructGeometryList(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/Geometry_List_(RW_Section)#Structure
-        """
-        SEQ_FIELDS = ["num_geometries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_geometries']['start'] = self._io.pos()
-            self.num_geometries = self._io.read_u4le()
-            self._debug['num_geometries']['end'] = self._io.pos()
-
-
-    class Rgba(KaitaiStruct):
-        SEQ_FIELDS = ["r", "g", "b", "a"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['r']['start'] = self._io.pos()
-            self.r = self._io.read_u1()
-            self._debug['r']['end'] = self._io.pos()
-            self._debug['g']['start'] = self._io.pos()
-            self.g = self._io.read_u1()
-            self._debug['g']['end'] = self._io.pos()
-            self._debug['b']['start'] = self._io.pos()
-            self.b = self._io.read_u1()
-            self._debug['b']['end'] = self._io.pos()
-            self._debug['a']['start'] = self._io.pos()
-            self.a = self._io.read_u1()
-            self._debug['a']['end'] = self._io.pos()
-
-
-    class Sphere(KaitaiStruct):
-        SEQ_FIELDS = ["x", "y", "z", "radius"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_f4le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_f4le()
-            self._debug['y']['end'] = self._io.pos()
-            self._debug['z']['start'] = self._io.pos()
-            self.z = self._io.read_f4le()
-            self._debug['z']['end'] = self._io.pos()
-            self._debug['radius']['start'] = self._io.pos()
-            self.radius = self._io.read_f4le()
-            self._debug['radius']['end'] = self._io.pos()
-
-
-    class MorphTarget(KaitaiStruct):
-        SEQ_FIELDS = ["bounding_sphere", "has_vertices", "has_normals", "vertices", "normals"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['bounding_sphere']['start'] = self._io.pos()
-            self.bounding_sphere = self._root.Sphere(self._io, self, self._root)
-            self.bounding_sphere._read()
-            self._debug['bounding_sphere']['end'] = self._io.pos()
-            self._debug['has_vertices']['start'] = self._io.pos()
-            self.has_vertices = self._io.read_u4le()
-            self._debug['has_vertices']['end'] = self._io.pos()
-            self._debug['has_normals']['start'] = self._io.pos()
-            self.has_normals = self._io.read_u4le()
-            self._debug['has_normals']['end'] = self._io.pos()
-            if self.has_vertices != 0:
-                self._debug['vertices']['start'] = self._io.pos()
-                self.vertices = [None] * (self._parent.num_vertices)
-                for i in range(self._parent.num_vertices):
-                    if not 'arr' in self._debug['vertices']:
-                        self._debug['vertices']['arr'] = []
-                    self._debug['vertices']['arr'].append({'start': self._io.pos()})
-                    _t_vertices = self._root.Vector3d(self._io, self, self._root)
-                    _t_vertices._read()
-                    self.vertices[i] = _t_vertices
-                    self._debug['vertices']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['vertices']['end'] = self._io.pos()
-
-            if self.has_normals != 0:
-                self._debug['normals']['start'] = self._io.pos()
-                self.normals = [None] * (self._parent.num_vertices)
-                for i in range(self._parent.num_vertices):
-                    if not 'arr' in self._debug['normals']:
-                        self._debug['normals']['arr'] = []
-                    self._debug['normals']['arr'].append({'start': self._io.pos()})
-                    _t_normals = self._root.Vector3d(self._io, self, self._root)
-                    _t_normals._read()
-                    self.normals[i] = _t_normals
-                    self._debug['normals']['arr'][i]['end'] = self._io.pos()
-
-                self._debug['normals']['end'] = self._io.pos()
-
-
-
-    class SurfaceProperties(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/RpGeometry
-        """
-        SEQ_FIELDS = ["ambient", "specular", "diffuse"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['ambient']['start'] = self._io.pos()
-            self.ambient = self._io.read_f4le()
-            self._debug['ambient']['end'] = self._io.pos()
-            self._debug['specular']['start'] = self._io.pos()
-            self.specular = self._io.read_f4le()
-            self._debug['specular']['end'] = self._io.pos()
-            self._debug['diffuse']['start'] = self._io.pos()
-            self.diffuse = self._io.read_f4le()
-            self._debug['diffuse']['end'] = self._io.pos()
-
-
-    class StructFrameList(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/Frame_List_(RW_Section)#Structure
-        """
-        SEQ_FIELDS = ["num_frames", "frames"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_frames']['start'] = self._io.pos()
-            self.num_frames = self._io.read_u4le()
-            self._debug['num_frames']['end'] = self._io.pos()
-            self._debug['frames']['start'] = self._io.pos()
-            self.frames = [None] * (self.num_frames)
-            for i in range(self.num_frames):
-                if not 'arr' in self._debug['frames']:
-                    self._debug['frames']['arr'] = []
-                self._debug['frames']['arr'].append({'start': self._io.pos()})
-                _t_frames = self._root.Frame(self._io, self, self._root)
-                _t_frames._read()
-                self.frames[i] = _t_frames
-                self._debug['frames']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['frames']['end'] = self._io.pos()
-
-
-    class Matrix(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/Frame_List_(RW_Section)#Structure
-        """
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = [None] * (3)
-            for i in range(3):
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Vector3d(self._io, self, self._root)
-                _t_entries._read()
-                self.entries[i] = _t_entries
-                self._debug['entries']['arr'][i]['end'] = self._io.pos()
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class Vector3d(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/Frame_List_(RW_Section)#Structure
-        """
-        SEQ_FIELDS = ["x", "y", "z"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_f4le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_f4le()
-            self._debug['y']['end'] = self._io.pos()
-            self._debug['z']['start'] = self._io.pos()
-            self.z = self._io.read_f4le()
-            self._debug['z']['end'] = self._io.pos()
-
-
-    class ListWithHeader(KaitaiStruct):
-        """Typical structure used by many data types in RenderWare binary
-        stream. Substream contains a list of binary stream entries,
-        first entry always has type "struct" and carries some specific
-        binary data it in, determined by the type of parent. All other
-        entries, beside the first one, are normal, self-describing
-        records.
-        """
-        SEQ_FIELDS = ["code", "header_size", "version", "header", "entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['code']['start'] = self._io.pos()
-            self.code = self._io.ensure_fixed_contents(b"\x01\x00\x00\x00")
-            self._debug['code']['end'] = self._io.pos()
-            self._debug['header_size']['start'] = self._io.pos()
-            self.header_size = self._io.read_u4le()
-            self._debug['header_size']['end'] = self._io.pos()
-            self._debug['version']['start'] = self._io.pos()
-            self.version = self._io.read_u4le()
-            self._debug['version']['end'] = self._io.pos()
-            self._debug['header']['start'] = self._io.pos()
-            _on = self._parent.code
-            if _on == self._root.Sections.geometry:
-                self._raw_header = self._io.read_bytes(self.header_size)
-                io = KaitaiStream(BytesIO(self._raw_header))
-                self.header = self._root.StructGeometry(io, self, self._root)
-                self.header._read()
-            elif _on == self._root.Sections.texture_dictionary:
-                self._raw_header = self._io.read_bytes(self.header_size)
-                io = KaitaiStream(BytesIO(self._raw_header))
-                self.header = self._root.StructTextureDictionary(io, self, self._root)
-                self.header._read()
-            elif _on == self._root.Sections.geometry_list:
-                self._raw_header = self._io.read_bytes(self.header_size)
-                io = KaitaiStream(BytesIO(self._raw_header))
-                self.header = self._root.StructGeometryList(io, self, self._root)
-                self.header._read()
-            elif _on == self._root.Sections.clump:
-                self._raw_header = self._io.read_bytes(self.header_size)
-                io = KaitaiStream(BytesIO(self._raw_header))
-                self.header = self._root.StructClump(io, self, self._root)
-                self.header._read()
-            elif _on == self._root.Sections.frame_list:
-                self._raw_header = self._io.read_bytes(self.header_size)
-                io = KaitaiStream(BytesIO(self._raw_header))
-                self.header = self._root.StructFrameList(io, self, self._root)
-                self.header._read()
-            else:
-                self.header = self._io.read_bytes(self.header_size)
-            self._debug['header']['end'] = self._io.pos()
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = RenderwareBinaryStream(self._io)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    class Triangle(KaitaiStruct):
-        SEQ_FIELDS = ["vertex2", "vertex1", "material_id", "vertex3"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['vertex2']['start'] = self._io.pos()
-            self.vertex2 = self._io.read_u2le()
-            self._debug['vertex2']['end'] = self._io.pos()
-            self._debug['vertex1']['start'] = self._io.pos()
-            self.vertex1 = self._io.read_u2le()
-            self._debug['vertex1']['end'] = self._io.pos()
-            self._debug['material_id']['start'] = self._io.pos()
-            self.material_id = self._io.read_u2le()
-            self._debug['material_id']['end'] = self._io.pos()
-            self._debug['vertex3']['start'] = self._io.pos()
-            self.vertex3 = self._io.read_u2le()
-            self._debug['vertex3']['end'] = self._io.pos()
-
-
-    class Frame(KaitaiStruct):
-        """
-        .. seealso::
-           Source - https://www.gtamodding.com/wiki/Frame_List_(RW_Section)#Structure
-        """
-        SEQ_FIELDS = ["rotation_matrix", "position", "cur_frame_idx", "matrix_creation_flags"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['rotation_matrix']['start'] = self._io.pos()
-            self.rotation_matrix = self._root.Matrix(self._io, self, self._root)
-            self.rotation_matrix._read()
-            self._debug['rotation_matrix']['end'] = self._io.pos()
-            self._debug['position']['start'] = self._io.pos()
-            self.position = self._root.Vector3d(self._io, self, self._root)
-            self.position._read()
-            self._debug['position']['end'] = self._io.pos()
-            self._debug['cur_frame_idx']['start'] = self._io.pos()
-            self.cur_frame_idx = self._io.read_s4le()
-            self._debug['cur_frame_idx']['end'] = self._io.pos()
-            self._debug['matrix_creation_flags']['start'] = self._io.pos()
-            self.matrix_creation_flags = self._io.read_u4le()
-            self._debug['matrix_creation_flags']['end'] = self._io.pos()
-
-
-    class TexCoord(KaitaiStruct):
-        SEQ_FIELDS = ["u", "v"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['u']['start'] = self._io.pos()
-            self.u = self._io.read_f4le()
-            self._debug['u']['end'] = self._io.pos()
-            self._debug['v']['start'] = self._io.pos()
-            self.v = self._io.read_f4le()
-            self._debug['v']['end'] = self._io.pos()
-
-
-    class StructTextureDictionary(KaitaiStruct):
-        SEQ_FIELDS = ["num_textures"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['num_textures']['start'] = self._io.pos()
-            self.num_textures = self._io.read_u4le()
-            self._debug['num_textures']['end'] = self._io.pos()
-
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/saints_row_2_vpp_pc.py b/python/examples/kaitai/kaitai_struct_formats/game/saints_row_2_vpp_pc.py
deleted file mode 100644
index 91be64ea..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/saints_row_2_vpp_pc.py
+++ /dev/null
@@ -1,252 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class SaintsRow2VppPc(KaitaiStruct):
-    SEQ_FIELDS = ["magic", "pad1", "num_files", "container_size", "len_offsets", "len_filenames", "len_extensions", "smth5", "smth6", "smth7", "smth8", "smth9"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['magic']['start'] = self._io.pos()
-        self.magic = self._io.ensure_fixed_contents(b"\xCE\x0A\x89\x51\x04")
-        self._debug['magic']['end'] = self._io.pos()
-        self._debug['pad1']['start'] = self._io.pos()
-        self.pad1 = self._io.read_bytes(335)
-        self._debug['pad1']['end'] = self._io.pos()
-        self._debug['num_files']['start'] = self._io.pos()
-        self.num_files = self._io.read_s4le()
-        self._debug['num_files']['end'] = self._io.pos()
-        self._debug['container_size']['start'] = self._io.pos()
-        self.container_size = self._io.read_s4le()
-        self._debug['container_size']['end'] = self._io.pos()
-        self._debug['len_offsets']['start'] = self._io.pos()
-        self.len_offsets = self._io.read_s4le()
-        self._debug['len_offsets']['end'] = self._io.pos()
-        self._debug['len_filenames']['start'] = self._io.pos()
-        self.len_filenames = self._io.read_s4le()
-        self._debug['len_filenames']['end'] = self._io.pos()
-        self._debug['len_extensions']['start'] = self._io.pos()
-        self.len_extensions = self._io.read_s4le()
-        self._debug['len_extensions']['end'] = self._io.pos()
-        self._debug['smth5']['start'] = self._io.pos()
-        self.smth5 = self._io.read_s4le()
-        self._debug['smth5']['end'] = self._io.pos()
-        self._debug['smth6']['start'] = self._io.pos()
-        self.smth6 = self._io.read_s4le()
-        self._debug['smth6']['end'] = self._io.pos()
-        self._debug['smth7']['start'] = self._io.pos()
-        self.smth7 = self._io.read_s4le()
-        self._debug['smth7']['end'] = self._io.pos()
-        self._debug['smth8']['start'] = self._io.pos()
-        self.smth8 = self._io.read_s4le()
-        self._debug['smth8']['end'] = self._io.pos()
-        self._debug['smth9']['start'] = self._io.pos()
-        self.smth9 = self._io.read_s4le()
-        self._debug['smth9']['end'] = self._io.pos()
-
-    class Offsets(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                _t_entries = self._root.Offsets.Offset(self._io, self, self._root)
-                _t_entries._read()
-                self.entries.append(_t_entries)
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-        class Offset(KaitaiStruct):
-            SEQ_FIELDS = ["name_ofs", "ext_ofs", "smth2", "ofs_body", "len_body", "always_minus_1", "always_zero"]
-            def __init__(self, _io, _parent=None, _root=None):
-                self._io = _io
-                self._parent = _parent
-                self._root = _root if _root else self
-                self._debug = collections.defaultdict(dict)
-
-            def _read(self):
-                self._debug['name_ofs']['start'] = self._io.pos()
-                self.name_ofs = self._io.read_u4le()
-                self._debug['name_ofs']['end'] = self._io.pos()
-                self._debug['ext_ofs']['start'] = self._io.pos()
-                self.ext_ofs = self._io.read_u4le()
-                self._debug['ext_ofs']['end'] = self._io.pos()
-                self._debug['smth2']['start'] = self._io.pos()
-                self.smth2 = self._io.read_s4le()
-                self._debug['smth2']['end'] = self._io.pos()
-                self._debug['ofs_body']['start'] = self._io.pos()
-                self.ofs_body = self._io.read_s4le()
-                self._debug['ofs_body']['end'] = self._io.pos()
-                self._debug['len_body']['start'] = self._io.pos()
-                self.len_body = self._io.read_s4le()
-                self._debug['len_body']['end'] = self._io.pos()
-                self._debug['always_minus_1']['start'] = self._io.pos()
-                self.always_minus_1 = self._io.read_s4le()
-                self._debug['always_minus_1']['end'] = self._io.pos()
-                self._debug['always_zero']['start'] = self._io.pos()
-                self.always_zero = self._io.read_s4le()
-                self._debug['always_zero']['end'] = self._io.pos()
-
-            @property
-            def filename(self):
-                if hasattr(self, '_m_filename'):
-                    return self._m_filename if hasattr(self, '_m_filename') else None
-
-                io = self._root.filenames._io
-                _pos = io.pos()
-                io.seek(self.name_ofs)
-                self._debug['_m_filename']['start'] = io.pos()
-                self._m_filename = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
-                self._debug['_m_filename']['end'] = io.pos()
-                io.seek(_pos)
-                return self._m_filename if hasattr(self, '_m_filename') else None
-
-            @property
-            def ext(self):
-                if hasattr(self, '_m_ext'):
-                    return self._m_ext if hasattr(self, '_m_ext') else None
-
-                io = self._root.extensions._io
-                _pos = io.pos()
-                io.seek(self.ext_ofs)
-                self._debug['_m_ext']['start'] = io.pos()
-                self._m_ext = (io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
-                self._debug['_m_ext']['end'] = io.pos()
-                io.seek(_pos)
-                return self._m_ext if hasattr(self, '_m_ext') else None
-
-            @property
-            def body(self):
-                if hasattr(self, '_m_body'):
-                    return self._m_body if hasattr(self, '_m_body') else None
-
-                io = self._root._io
-                _pos = io.pos()
-                io.seek((self._root.data_start + self.ofs_body))
-                self._debug['_m_body']['start'] = io.pos()
-                self._m_body = io.read_bytes(self.len_body)
-                self._debug['_m_body']['end'] = io.pos()
-                io.seek(_pos)
-                return self._m_body if hasattr(self, '_m_body') else None
-
-
-
-    class Strings(KaitaiStruct):
-        SEQ_FIELDS = ["entries"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['entries']['start'] = self._io.pos()
-            self.entries = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['entries']:
-                    self._debug['entries']['arr'] = []
-                self._debug['entries']['arr'].append({'start': self._io.pos()})
-                self.entries.append((self._io.read_bytes_term(0, False, True, True)).decode(u"UTF-8"))
-                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['entries']['end'] = self._io.pos()
-
-
-    @property
-    def filenames(self):
-        if hasattr(self, '_m_filenames'):
-            return self._m_filenames if hasattr(self, '_m_filenames') else None
-
-        _pos = self._io.pos()
-        self._io.seek(self.ofs_filenames)
-        self._debug['_m_filenames']['start'] = self._io.pos()
-        self._raw__m_filenames = self._io.read_bytes(self.len_filenames)
-        io = KaitaiStream(BytesIO(self._raw__m_filenames))
-        self._m_filenames = self._root.Strings(io, self, self._root)
-        self._m_filenames._read()
-        self._debug['_m_filenames']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_filenames if hasattr(self, '_m_filenames') else None
-
-    @property
-    def ofs_extensions(self):
-        if hasattr(self, '_m_ofs_extensions'):
-            return self._m_ofs_extensions if hasattr(self, '_m_ofs_extensions') else None
-
-        self._m_ofs_extensions = (((self.ofs_filenames + self.len_filenames) & 4294965248) + 2048)
-        return self._m_ofs_extensions if hasattr(self, '_m_ofs_extensions') else None
-
-    @property
-    def files(self):
-        if hasattr(self, '_m_files'):
-            return self._m_files if hasattr(self, '_m_files') else None
-
-        _pos = self._io.pos()
-        self._io.seek(2048)
-        self._debug['_m_files']['start'] = self._io.pos()
-        self._raw__m_files = self._io.read_bytes(self.len_offsets)
-        io = KaitaiStream(BytesIO(self._raw__m_files))
-        self._m_files = self._root.Offsets(io, self, self._root)
-        self._m_files._read()
-        self._debug['_m_files']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_files if hasattr(self, '_m_files') else None
-
-    @property
-    def data_start(self):
-        if hasattr(self, '_m_data_start'):
-            return self._m_data_start if hasattr(self, '_m_data_start') else None
-
-        self._m_data_start = (((self.ofs_extensions + self.len_extensions) & 4294965248) + 2048)
-        return self._m_data_start if hasattr(self, '_m_data_start') else None
-
-    @property
-    def extensions(self):
-        if hasattr(self, '_m_extensions'):
-            return self._m_extensions if hasattr(self, '_m_extensions') else None
-
-        _pos = self._io.pos()
-        self._io.seek(self.ofs_extensions)
-        self._debug['_m_extensions']['start'] = self._io.pos()
-        self._raw__m_extensions = self._io.read_bytes(self.len_extensions)
-        io = KaitaiStream(BytesIO(self._raw__m_extensions))
-        self._m_extensions = self._root.Strings(io, self, self._root)
-        self._m_extensions._read()
-        self._debug['_m_extensions']['end'] = self._io.pos()
-        self._io.seek(_pos)
-        return self._m_extensions if hasattr(self, '_m_extensions') else None
-
-    @property
-    def ofs_filenames(self):
-        if hasattr(self, '_m_ofs_filenames'):
-            return self._m_ofs_filenames if hasattr(self, '_m_ofs_filenames') else None
-
-        self._m_ofs_filenames = (((2048 + self.len_offsets) & 4294965248) + 2048)
-        return self._m_ofs_filenames if hasattr(self, '_m_ofs_filenames') else None
-
-
diff --git a/python/examples/kaitai/kaitai_struct_formats/game/warcraft_2_pud.py b/python/examples/kaitai/kaitai_struct_formats/game/warcraft_2_pud.py
deleted file mode 100644
index a76f83d9..00000000
--- a/python/examples/kaitai/kaitai_struct_formats/game/warcraft_2_pud.py
+++ /dev/null
@@ -1,421 +0,0 @@
-from __future__ import absolute_import
-# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
-
-from pkg_resources import parse_version
-from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
-from enum import Enum
-import collections
-
-
-if parse_version(ks_version) < parse_version('0.7'):
-    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
-
-class Warcraft2Pud(KaitaiStruct):
-    """Warcraft II game engine uses this format for map files. External
-    maps can be edited by official Warcraft II map editor and saved in
-    .pud files. Maps supplied with the game (i.e. single player
-    campaign) follow the same format, but are instead embedded inside
-    the game container files.
-    
-    There are two major versions: 0x11 (original one) and 0x13 (roughly
-    corresponds to v1.33 of the game engine, although some of the
-    features got limited support in v1.3).
-    
-    File consists of a sequence of typed sections.
-    
-    .. seealso::
-       Source - http://cade.datamax.bg/war2x/pudspec.html
-    """
-
-    class Controller(Enum):
-        computer = 1
-        passive_computer = 2
-        nobody = 3
-        computer = 4
-        human = 5
-        rescue_passive = 6
-        rescue_active = 7
-
-    class TerrainType(Enum):
-        forest = 0
-        winter = 1
-        wasteland = 2
-        swamp = 3
-
-    class UnitType(Enum):
-        infantry = 0
-        grunt = 1
-        peasant = 2
-        peon = 3
-        ballista = 4
-        catapult = 5
-        knight = 6
-        ogre = 7
-        archer = 8
-        axethrower = 9
-        mage = 10
-        death_knight = 11
-        paladin = 12
-        ogre_mage = 13
-        dwarves = 14
-        goblin_sapper = 15
-        attack_peasant = 16
-        attack_peon = 17
-        ranger = 18
-        berserker = 19
-        alleria = 20
-        teron_gorefiend = 21
-        kurdan_and_sky_ree = 22
-        dentarg = 23
-        khadgar = 24
-        grom_hellscream = 25
-        human_tanker = 26
-        orc_tanker = 27
-        human_transport = 28
-        orc_transport = 29
-        elven_destroyer = 30
-        troll_destroyer = 31
-        battleship = 32
-        juggernaught = 33
-        deathwing = 35
-        gnomish_submarine = 38
-        giant_turtle = 39
-        gnomish_flying_machine = 40
-        goblin_zepplin = 41
-        gryphon_rider = 42
-        dragon = 43
-        turalyon = 44
-        eye_of_kilrogg = 45
-        danath = 46
-        khorgath_bladefist = 47
-        cho_gall = 49
-        lothar = 50
-        gul_dan = 51
-        uther_lightbringer = 52
-        zuljin = 53
-        skeleton = 55
-        daemon = 56
-        critter = 57
-        farm = 58
-        pig_farm = 59
-        human_barracks = 60
-        orc_barracks = 61
-        church = 62
-        altar_of_storms = 63
-        human_scout_tower = 64
-        orc_scout_tower = 65
-        stables = 66
-        ogre_mound = 67
-        gnomish_inventor = 68
-        goblin_alchemist = 69
-        gryphon_aviary = 70
-        dragon_roost = 71
-        human_shipyard = 72
-        orc_shipyard = 73
-        town_hall = 74
-        great_hall = 75
-        elven_lumber_mill = 76
-        troll_lumber_mill = 77
-        human_foundry = 78
-        orc_foundry = 79
-        mage_tower = 80
-        temple_of_the_damned = 81
-        human_blacksmith = 82
-        orc_blacksmith = 83
-        human_refinery = 84
-        orc_refinery = 85
-        human_oil_well = 86
-        orc_oil_well = 87
-        keep = 88
-        stronghold = 89
-        castle = 90
-        fortress = 91
-        gold_mine = 92
-        oil_patch = 93
-        human_start = 94
-        orc_start = 95
-        human_guard_tower = 96
-        orc_guard_tower = 97
-        human_cannon_tower = 98
-        orc_cannon_tower = 99
-        circle_of_power = 100
-        dark_portal = 101
-        runestone = 102
-        human_wall = 103
-        orc_wall = 104
-    SEQ_FIELDS = ["sections"]
-    def __init__(self, _io, _parent=None, _root=None):
-        self._io = _io
-        self._parent = _parent
-        self._root = _root if _root else self
-        self._debug = collections.defaultdict(dict)
-
-    def _read(self):
-        self._debug['sections']['start'] = self._io.pos()
-        self.sections = []
-        i = 0
-        while not self._io.is_eof():
-            if not 'arr' in self._debug['sections']:
-                self._debug['sections']['arr'] = []
-            self._debug['sections']['arr'].append({'start': self._io.pos()})
-            _t_sections = self._root.Section(self._io, self, self._root)
-            _t_sections._read()
-            self.sections.append(_t_sections)
-            self._debug['sections']['arr'][len(self.sections) - 1]['end'] = self._io.pos()
-            i += 1
-
-        self._debug['sections']['end'] = self._io.pos()
-
-    class SectionStartingResource(KaitaiStruct):
-        SEQ_FIELDS = ["resources_by_player"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['resources_by_player']['start'] = self._io.pos()
-            self.resources_by_player = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['resources_by_player']:
-                    self._debug['resources_by_player']['arr'] = []
-                self._debug['resources_by_player']['arr'].append({'start': self._io.pos()})
-                self.resources_by_player.append(self._io.read_u2le())
-                self._debug['resources_by_player']['arr'][len(self.resources_by_player) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['resources_by_player']['end'] = self._io.pos()
-
-
-    class SectionEra(KaitaiStruct):
-        """Section that specifies terrain type for this map."""
-        SEQ_FIELDS = ["terrain"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['terrain']['start'] = self._io.pos()
-            self.terrain = KaitaiStream.resolve_enum(self._root.TerrainType, self._io.read_u2le())
-            self._debug['terrain']['end'] = self._io.pos()
-
-
-    class SectionVer(KaitaiStruct):
-        """Section that specifies format version."""
-        SEQ_FIELDS = ["version"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['version']['start'] = self._io.pos()
-            self.version = self._io.read_u2le()
-            self._debug['version']['end'] = self._io.pos()
-
-
-    class SectionDim(KaitaiStruct):
-        SEQ_FIELDS = ["x", "y"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_u2le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_u2le()
-            self._debug['y']['end'] = self._io.pos()
-
-
-    class SectionType(KaitaiStruct):
-        """Section that confirms that this file is a "map file" by certain
-        magic string and supplies a tag that could be used in
-        multiplayer to check that all player use the same version of the
-        map.
-        """
-        SEQ_FIELDS = ["magic", "unused", "id_tag"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['magic']['start'] = self._io.pos()
-            self.magic = self._io.ensure_fixed_contents(b"\x57\x41\x52\x32\x20\x4D\x41\x50\x00\x00")
-            self._debug['magic']['end'] = self._io.pos()
-            self._debug['unused']['start'] = self._io.pos()
-            self.unused = self._io.read_bytes(2)
-            self._debug['unused']['end'] = self._io.pos()
-            self._debug['id_tag']['start'] = self._io.pos()
-            self.id_tag = self._io.read_u4le()
-            self._debug['id_tag']['end'] = self._io.pos()
-
-
-    class SectionUnit(KaitaiStruct):
-        SEQ_FIELDS = ["units"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['units']['start'] = self._io.pos()
-            self.units = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['units']:
-                    self._debug['units']['arr'] = []
-                self._debug['units']['arr'].append({'start': self._io.pos()})
-                _t_units = self._root.Unit(self._io, self, self._root)
-                _t_units._read()
-                self.units.append(_t_units)
-                self._debug['units']['arr'][len(self.units) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['units']['end'] = self._io.pos()
-
-
-    class Section(KaitaiStruct):
-        SEQ_FIELDS = ["name", "size", "body"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['name']['start'] = self._io.pos()
-            self.name = (self._io.read_bytes(4)).decode(u"ASCII")
-            self._debug['name']['end'] = self._io.pos()
-            self._debug['size']['start'] = self._io.pos()
-            self.size = self._io.read_u4le()
-            self._debug['size']['end'] = self._io.pos()
-            self._debug['body']['start'] = self._io.pos()
-            _on = self.name
-            if _on == u"SLBR":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionStartingResource(io, self, self._root)
-                self.body._read()
-            elif _on == u"ERAX":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionEra(io, self, self._root)
-                self.body._read()
-            elif _on == u"OWNR":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionOwnr(io, self, self._root)
-                self.body._read()
-            elif _on == u"ERA ":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionEra(io, self, self._root)
-                self.body._read()
-            elif _on == u"SGLD":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionStartingResource(io, self, self._root)
-                self.body._read()
-            elif _on == u"VER ":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionVer(io, self, self._root)
-                self.body._read()
-            elif _on == u"SOIL":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionStartingResource(io, self, self._root)
-                self.body._read()
-            elif _on == u"UNIT":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionUnit(io, self, self._root)
-                self.body._read()
-            elif _on == u"DIM ":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionDim(io, self, self._root)
-                self.body._read()
-            elif _on == u"TYPE":
-                self._raw_body = self._io.read_bytes(self.size)
-                io = KaitaiStream(BytesIO(self._raw_body))
-                self.body = self._root.SectionType(io, self, self._root)
-                self.body._read()
-            else:
-                self.body = self._io.read_bytes(self.size)
-            self._debug['body']['end'] = self._io.pos()
-
-
-    class SectionOwnr(KaitaiStruct):
-        """Section that specifies who controls each player."""
-        SEQ_FIELDS = ["controller_by_player"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['controller_by_player']['start'] = self._io.pos()
-            self.controller_by_player = []
-            i = 0
-            while not self._io.is_eof():
-                if not 'arr' in self._debug['controller_by_player']:
-                    self._debug['controller_by_player']['arr'] = []
-                self._debug['controller_by_player']['arr'].append({'start': self._io.pos()})
-                self.controller_by_player.append(KaitaiStream.resolve_enum(self._root.Controller, self._io.read_u1()))
-                self._debug['controller_by_player']['arr'][len(self.controller_by_player) - 1]['end'] = self._io.pos()
-                i += 1
-
-            self._debug['controller_by_player']['end'] = self._io.pos()
-
-
-    class Unit(KaitaiStruct):
-        SEQ_FIELDS = ["x", "y", "u_type", "owner", "options"]
-        def __init__(self, _io, _parent=None, _root=None):
-            self._io = _io
-            self._parent = _parent
-            self._root = _root if _root else self
-            self._debug = collections.defaultdict(dict)
-
-        def _read(self):
-            self._debug['x']['start'] = self._io.pos()
-            self.x = self._io.read_u2le()
-            self._debug['x']['end'] = self._io.pos()
-            self._debug['y']['start'] = self._io.pos()
-            self.y = self._io.read_u2le()
-            self._debug['y']['end'] = self._io.pos()
-            self._debug['u_type']['start'] = self._io.pos()
-            self.u_type = KaitaiStream.resolve_enum(self._root.UnitType, self._io.read_u1())
-            self._debug['u_type']['end'] = self._io.pos()
-            self._debug['owner']['start'] = self._io.pos()
-            self.owner = self._io.read_u1()
-            self._debug['owner']['end'] = self._io.pos()
-            self._debug['options']['start'] = self._io.pos()
-            self.options = self._io.read_u2le()
-            self._debug['options']['end'] = self._io.pos()
-
-        @property
-        def resource(self):
-            if hasattr(self, '_m_resource'):
-                return self._m_resource if hasattr(self, '_m_resource') else None
-
-            if  ((self.u_type == self._root.UnitType.gold_mine) or (self.u_type == self._root.UnitType.human_oil_well) or (self.u_type == self._root.UnitType.orc_oil_well) or (self.u_type == self._root.UnitType.oil_patch)) :
-                self._m_resource = (self.options * 2500)
-
-            return self._m_resource if hasattr(self, '_m_resource') else None
-
-
-