Python: start and end are read from positions in different BytesIO objects
In the following code, generated from elf.ksv, the `self._debug['_m_body']['start'] = io.pos()` uses the initial BytesIO object from self._root._io.

After making an endian determination, it sets io to a brand new BytesIO object, like at the line `io = KaitaiStream(BytesIO(self._raw__m_body))`.

```python
            @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_body)
                self._debug['_m_body']['start'] = io.pos()
                if self._is_le:
                    _on = self.type
                    if _on == self._root.ShType.strtab:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.StringsStruct(io, self, self._root, self._is_le)
                        self._m_body._read()
                    elif _on == self._root.ShType.dynamic:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.DynamicSection(io, self, self._root, self._is_le)
                        self._m_body._read()
                    elif _on == self._root.ShType.dynsym:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.DynsymSection(io, self, self._root, self._is_le)
                        self._m_body._read()
                    elif _on == self._root.ShType.dynstr:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.StringsStruct(io, self, self._root, self._is_le)
                        self._m_body._read()
                    else:
                        self._m_body = io.read_bytes(self.len_body)
                else:
                    _on = self.type
                    if _on == self._root.ShType.strtab:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.StringsStruct(io, self, self._root, self._is_le)
                        self._m_body._read()
                    elif _on == self._root.ShType.dynamic:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.DynamicSection(io, self, self._root, self._is_le)
                        self._m_body._read()
                    elif _on == self._root.ShType.dynsym:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.DynsymSection(io, self, self._root, self._is_le)
                        self._m_body._read()
                    elif _on == self._root.ShType.dynstr:
                        self._raw__m_body = io.read_bytes(self.len_body)
                        io = KaitaiStream(BytesIO(self._raw__m_body))
                        self._m_body = self._root.EndianElf.StringsStruct(io, self, self._root, self._is_le)
                        self._m_body._read()
                    else:
                        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
```

So start and end no longer have a meaningful relationship between each other. Here's a dump of the data structure returned by Kaitai, and you can see `._m_body: <elf.StringsStruct> [300,38)` has a "backwards" range. 

```python
        ._m_section_headers[6]:
            <elf.SectionHeader>
            .ofs_name:
                <type 'int'> 86 [0,4)
            .type:
                <enum 'ShType'> <ShType.strtab: 3> [4,8)
            .flags:
                <type 'int'> 2 [8,10)
            .addr:
                <type 'int'> 4195072 [10,18)
            .ofs_body:
                <type 'int'> 768 [18,20)
            .len_body:
                <type 'int'> 56 [20,28)
            .linked_section_idx:
                <type 'int'> 0 [28,2C)
            .info:
                <type 'str'> '\x00\x00\x00\x00' [2C,30)
            .align:
                <type 'int'> 1 [30,38)
            .entry_size:
                <type 'int'> 0 [38,40)
            ._m_flags_obj:
                <elf.SectionHeaderFlags> [40,40)
            ._m_name:
                <type 'unicode'> u'.dynstr' [56,5E)
            ._m_body:
                <elf.StringsStruct> [300,38)
                .entries:
                    <type 'list'> [0,38)
                    .entries[0]:
                        <type 'unicode'> u''
                    .entries[1]:
                        <type 'unicode'> u'libc.so.6'
                    .entries[2]:
                        <type 'unicode'> u'__libc_start_main'
                    .entries[3]:
                        <type 'unicode'> u'__gmon_start__'
                    .entries[4]:
                        <type 'unicode'> u'GLIBC_2.2.5'
```