e.g. BGI 1.64. Like [[BGI (old)]] but with a different operation encoding. Used in Nursery Rhyme.

{{{#!python
#!/usr/bin/env python

from sys import argv, exit, stdout
from mmap import mmap, ACCESS_COPY, ACCESS_READ
from struct import unpack, iter_unpack

def print(s, end="\n"):
    stdout.buffer.write((str(s) + end).encode("utf-8"))

def uint(f):
    return unpack("<I", f.read(4))[0]
def ushort(f):
    return unpack("<H", f.read(2))[0]
def byte(f):
    return unpack("<B", f.read(1))[0]
def char(f):
    return unpack("<c", f.read(1))[0]
def string(f):
    mystr = bytes()
    c = char(f)
    while c[0] != 0:
        mystr += c
        c = char(f)
    return mystr

def short(x):
    return "0x%04X" % x
def long(x):
    return "0x%08X" % x

if len(argv) < 2:
    print("No input given")
    exit()

for fn in argv[1:]:
    with open(fn, "rb") as f:
        lowest_string_addr = -1
        nullonly = False
        string_addrs = []
        while 1:
            addr = f.tell()
            if lowest_string_addr >= 0 and addr+1 >= lowest_string_addr:
                #print(f"entered string table at {lowest_string_addr:08X} in {fn}")
                break
            try:
                op = ushort(f)
            except:
                break
            #print(f"\nop_{op:04X}")
            if   op in [0x0000]: # means we're in padding, not a NOP
                nullonly = True
                pass
            elif nullonly:
                #print(f"non-null command at {f.tell()-2:08X} after seeing null command")
                #print(f"lowest_string_addr is {lowest_string_addr:08X}")
                break
            elif   op in [0xFEFE]:
                pass
            elif op in [
                 0x0011,
                 0x001D,
                 0x0020,
                 0x0021,
                 0x0082,
                 0x0083, # ?
                 0x00C9,
                 0x00B8,
                 ]:
                 pass
            elif op in [
                 0x0040,
                 0x0041,
                 ]:
                num = uint(f)
                num = uint(f)
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f)
                num = uint(f)
            elif op in [
                 0x0042,
                 0x0043,
                 0x0044,
                 0x0045,
                 ]:
                num = uint(f)
                num = uint(f)
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f)
            elif op in [
                 0x0028,
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x002B,
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f)
            elif op in [
                 0x0050,
                 0x0053,
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f) # not var
            elif op in [
                 0x0080,
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f)
            elif op in [
                 0x0046,
                 0x0047,
                 0x0070,
                 0x0074,
                 ]:
                num = uint(f) # not var?
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f) # not var?
            elif op in [
                 0x0014,
                 0x0085,
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
            elif op in [
                 0x00C8, # command text?
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
            elif op in [
                 0x00C0, # jump to another script (and don't come back?)
                 0x00C1, # jump to another script (and come back?)
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
            elif op in [
                 0x00C2, # often comes after 0x00C0
                 ]:
                pass
            elif op in [
                 0x0010,
                 ]:
                num = uint(f)
                #print(f"{num}")
                if num != 0: exit()
                num = uint(f)
                num = uint(f)
                #print(f"{num}") # content text address
                if lowest_string_addr == -1 or num < lowest_string_addr:
                    lowest_string_addr = num
                string_addrs += [num]
            elif op in [
                 0x006D,
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
                if num != 256: exit()
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0072,
                 0x0076,
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0048,
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0049,
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0035,
                 0x003D,
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x00A3, # some kind of test/jump?
                 0x00A4, # some kind of test/jump?
                 0x00A5, # some kind of test/jump?
                 0x00A7, # some kind of test/jump?
                 0x00A8, # some kind of test/jump?
                 ]:
                num = ushort(f)
                #print(f"{num}")
                num = ushort(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x00A1, # some kind of test/jump?
                 0x00A2, # some kind of test/jump?
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x00AE, # unconditional?
                 ]:
                num = uint(f)
            elif op in [
                 0x002A,
                 0x0052,
                 0x0067,
                 0x0068,
                 0x0069,
                 0x006A,
                 0x006C,
                 0x006F,
                 0x0071,
                 0x0075,
                 0x008C,
                 0x008D,
                 0x008E,
                 0x0090,
                 0x0092,
                 0x00A0,
                 0x00BA,
                 0x00C4,
                 ]:
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0066,
                 ]:
                num = uint(f)
                #print(f"{num}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0029,
                 0x0051,
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                num = uint(f)
                #print(f"{num}")
            elif op in [
                 0x0012, # furigana mapper?
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
            elif op in [
                 0x0013, # reuse furigana mapping?
                 ]:
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
            elif op in [
                 0x00D4,
                 0x00D8,
                 0x00DA,
                 0x00DB,
                 0x00DC,
                 ]:
                uint(f)
            elif op in [
                 0x0098,
                 0x0099,
                 ]:
                ushort(f)
                ushort(f)
                ushort(f)
                ushort(f)
            elif op in [
                 0x00B9,
                 ]:
                ushort(f)
                ushort(f)
            elif op in [
                 0x00B0,
                 ]:
                num = uint(f)
                #print(f"{num}")
                for i in range(num):
                    x = string(f)
                    #print(f"{x.decode('shift-jis')}")
            elif op in [
                 0x00A9,
                 ]:
                num = uint(f)
                #print(f"{num}")
                for i in range(num):
                    uint(f)
            elif op in [
                 0x0034, # effect related
                 ]:
                uint(f)
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                for i in range(5):
                    uint(f)
            elif op in [
                 0x0036, # ?
                 0x016E, # ???
                 ]:
                for i in range(6):
                    uint(f)
            elif op in [
                 0x013A,
                 0x0139,
                 ]:
                uint(f)
            elif op in [
                 0x0138,
                 ]:
                uint(f)
                uint(f)
            elif op in [
                 0x0137, # some kind of cut effect
                 ]:
                uint(f)
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                uint(f)
                uint(f)
                uint(f)
            elif op in [
                 0x002c, # background related (pan and zoom?)
                 ]:
                
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
                
                for i in range(8):
                    uint(f)
            elif op in [
                 0x0018,
                 0x001C,
                 0x002D, # background related (pan and zoom?)
                 ]:
                
                for i in range(5):
                    uint(f)
            elif op in [
                 0x001A,
                 0x001E,
                 ]:
                
                uint(f)
                uint(f)
                uint(f)
            elif op in [
                 0x001B,
                 ]:
                
                x = string(f)
                
                for i in range(7):
                    uint(f)
            elif op in [
                 0x0088, # play movie or something
                 ]:
                
                x = string(f)
                #print(f"{x.decode('shift-jis')}")
            else:
                print(f"unknown op {op:04X} at {f.tell()-2:08X} in {fn}")
                exit(0)
        if len(string_addrs) > 0:
            if True: # the right way to do it
                for addr in string_addrs:
                    f.seek(addr)
                    x = string(f)
                    print(f"{x.decode('shift-jis')}")
            else: # the wrong way, but validates that we captured all the text
                f.seek(lowest_string_addr)
                while True:
                    try:
                        x = string(f)
                        print(f"{x.decode('shift-jis')}")
                    except:
                        break
            print("\n\n")
        
}}}