diff options
Diffstat (limited to 'redtools/analyze_texts.py')
| -rw-r--r-- | redtools/analyze_texts.py | 716 |
1 files changed, 716 insertions, 0 deletions
diff --git a/redtools/analyze_texts.py b/redtools/analyze_texts.py new file mode 100644 index 0000000..08b8ab0 --- /dev/null +++ b/redtools/analyze_texts.py @@ -0,0 +1,716 @@ +#author: Bryan Bishop <kanzure@gmail.com> +#date: 2012-01-06 +#analyze texts, how many commands are unknown? +import extract_maps +import analyze_incbins #for asm +try: + from pretty_map_headers import map_name_cleaner, txt_bytes, spacing, constant_abbreviation_bytes +except Exception, exc: pass +from operator import itemgetter +import sys +debug = False #set to True to increase logging output + +#how many times is each command byte called? +totals = {} +total_text_commands = 0 +should_be_total = 0 + +def get_text_pointer(texts_pointer, text_id): + if type(texts_pointer) == str: texts_pointer = int(texts_pointer, 16) + if type(text_id) == str: text_id = int(text_id) + + byte1 = ord(extract_maps.rom[texts_pointer + ((text_id - 1) * 2)]) + byte2 = ord(extract_maps.rom[texts_pointer + ((text_id - 1) * 2) + 1]) + pointer = (byte1 + (byte2 << 8)) + + return pointer + +def how_many_until(byte, starting): + index = extract_maps.rom.find(byte, starting) + return index-starting + +def print_command_debug_info(command_byte, text_id, text_pointer, map_id): + if debug: + print "byte is " + str(command_byte) + " on text #" + str(text_id) + " at " + hex(text_pointer) + " on map " + str(map_id) + " (" + extract_maps.map_headers[map_id]["name"] + ")" + +def add_command_byte_to_totals(byte): + global totals + if not byte in totals.keys(): totals[byte] = 1 + else: totals[byte] += 1 + +def process_00_subcommands(start_address, end_address): + """split this text up into multiple lines + based on subcommands ending each line""" + lines = {} + subsection = extract_maps.rom[start_address:end_address+1] + + line_count = 0 + current_line = [] + for pbyte in subsection: + byte = ord(pbyte) + current_line.append(byte) + if byte == 0x4f or byte == 0x51 or byte == 0x55: + lines[line_count] = current_line + current_line = [] + line_count += 1 + + #don't forget the last line + lines[line_count] = current_line + line_count += 1 + return lines + +def parse_text_script(text_pointer, text_id, map_id, txfar=False): + global total_text_commands + offset = text_pointer + commands = {} + command_counter = 0 + + if extract_maps.rom == None: + extract_maps.load_rom() + + end = False + while not end: + command = {} + command_byte = ord(extract_maps.rom[offset]) + + print_command_debug_info(command_byte, text_id, text_pointer, map_id) + if command_byte == 0: + #read until $57, $50 or $58 + jump57 = how_many_until(chr(0x57), offset) + jump50 = how_many_until(chr(0x50), offset) + jump58 = how_many_until(chr(0x58), offset) + + #whichever command comes first + jump = min([jump57, jump50, jump58]) + + end_address = offset + jump - 1 #we want the address before $57 + + command = {"type": command_byte, + "start_address": offset, + "end_address": end_address, + "size": jump, + "lines": process_00_subcommands(offset+1, end_address), + } + + offset += jump + elif command_byte == 0x17: + #TX_FAR [pointer][bank] + pointer_byte1 = ord(extract_maps.rom[offset+1]) + pointer_byte2 = ord(extract_maps.rom[offset+2]) + pointer_bank = ord(extract_maps.rom[offset+3]) + + pointer = (pointer_byte1 + (pointer_byte2 << 8)) + pointer = extract_maps.calculate_pointer(pointer, pointer_bank) + + command = {"type": command_byte, + "start_address": offset, + "end_address": offset + 3, #last byte belonging to this command + "pointer": pointer, #parameter + } + + offset += 3 + 1 + elif command_byte == 0x50 or command_byte == 0x57 or command_byte == 0x58: #end text + command = {"type": command_byte, + "start_address": offset, + "end_address": offset, + } + + #this byte simply indicates to end the script + end = True + + #this byte simply indicates to end the script + if command_byte == 0x50 and ord(extract_maps.rom[offset+1]) == 0x50: #$50$50 means end completely + end = True + commands[command_counter+1] = command + + #also save the next byte, before we quit + commands[command_counter+1]["start_address"] += 1 + commands[command_counter+1]["end_address"] += 1 + add_command_byte_to_totals(command_byte) + elif command_byte == 0x50: #only end if we started with $0 + if len(commands.keys()) > 0: + if commands[0]["type"] == 0x0: end = True + elif command_byte == 0x57 or command_byte == 0x58: #end completely + end = True + offset += 1 #go past this 0x50 + elif command_byte == 0x1: + #01 = text from RAM. [01][2-byte pointer] + size = 3 #total size, including the command byte + pointer_byte1 = ord(extract_maps.rom[offset+1]) + pointer_byte2 = ord(extract_maps.rom[offset+2]) + + command = {"type": command_byte, + "start_address": offset+1, + "end_address": offset+2, #last byte belonging to this command + "pointer": [pointer_byte1, pointer_byte2], #RAM pointer + } + + #view near these bytes + #subsection = extract_maps.rom[offset:offset+size+1] #peak ahead + #for x in subsection: + # print hex(ord(x)) + #print "--" + + offset += 2 + 1 #go to the next byte + + #use this to look at the surrounding bytes + if debug: + print "next command is: " + hex(ord(extract_maps.rom[offset])) + " ... we are at command number: " + str(command_counter) + " near " + hex(offset) + " on map_id=" + str(map_id) + " for text_id=" + str(text_id) + " and txfar(recursion)=" + str(txfar) + elif command_byte == 0x7: + #07 = shift texts 1 row above (2nd line becomes 1st line); address for next text = 2nd line. [07] + size = 1 + command = {"type": command_byte, + "start_address": offset, + "end_address": offset, + } + offset += 1 + elif command_byte == 0x3: + #03 = set new address in RAM for text. [03][2-byte RAM address] + size = 3 + command = {"type": command_byte, "start_address": offset, "end_address": offset+2} + offset += size + elif command_byte == 0x4: #draw box + #04 = draw box. [04][2-Byte pointer][height Y][width X] + size = 5 #including the command + command = { + "type": command_byte, + "start_address": offset, + "end_address": offset + size, + "pointer_bytes": [ord(extract_maps.rom[offset+1]), ord(extract_maps.rom[offset+2])], + "y": ord(extract_maps.rom[offset+3]), + "x": ord(extract_maps.rom[offset+4]), + } + offset += size + 1 + elif command_byte == 0x5: + #05 = write text starting at 2nd line of text-box. [05][text][ending command] + #read until $57, $50 or $58 + jump57 = how_many_until(chr(0x57), offset) + jump50 = how_many_until(chr(0x50), offset) + jump58 = how_many_until(chr(0x58), offset) + + #whichever command comes first + jump = min([jump57, jump50, jump58]) + + end_address = offset + jump - 1 #we want the address before $57 + + command = {"type": command_byte, + "start_address": offset, + "end_address": end_address, + "size": jump, + "lines": process_00_subcommands(offset+1, end_address), + } + offset = end_address + 1 + elif command_byte == 0x6: + #06 = wait for keypress A or B (put blinking arrow in textbox). [06] + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x7: + #07 = shift texts 1 row above (2nd line becomes 1st line); address for next text = 2nd line. [07] + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x8: + #08 = asm until whenever + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + end = True + elif command_byte == 0x9: + #09 = write hex-to-dec number from RAM to textbox [09][2-byte RAM address][byte bbbbcccc] + # bbbb = how many bytes to read (read number is big-endian) + # cccc = how many digits display (decimal) + #(note: max of decimal digits is 7,i.e. max number correctly displayable is 9999999) + ram_address_byte1 = ord(extract_maps.rom[offset+1]) + ram_address_byte2 = ord(extract_maps.rom[offset+2]) + read_byte = ord(extract_maps.rom[offset+3]) + + command = { + "type": command_byte, + "address": [ram_address_byte1, ram_address_byte2], + "read_byte": read_byte, #split this up when we make a macro for this + } + + offset += 4 + elif command_byte == 0xB: + #0B = sound_86 (Hiro obtains ITEM)[same as 0F] + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xE: + #0E = sound_91 (learnt something) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xF: + #0F = sound_86 (given rare candy)[same as 0B] + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x10: + #10 = sound_89 (PKMN successfully caught) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x11: + #11 = sound_94 (Hiro gives OAK the PARCEL) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x12: + #12 = sound_9A (successfully caught) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x13: + #13 = sound_98 (song heard when "new data will be added for..") + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x14: + #14 = MonCry (Nidorina) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x15: + #14 = MonCry (Pidgeot) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x16: + #14 = MonCry (Dewgong) + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x19: + #19 = play a 'bump' noise + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x1F: + #1F = play some pokemon's roar, don't know which.. + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x20: + #20 = oddish roar? + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x3F: + #3F = some other roar + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x9D: + #9D = a roar or some other sound, four times in quick succession + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0x76: + #76 = another roar + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xCA: + #CA = stop music, start this other song that i can't name + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xF6: + #F6 = play a 'blurp blurp' noise.. like something is increasing + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xFA: + #FA = change music to champion song? + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xFE: + #FE = another roar, kinda glitchy? + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + elif command_byte == 0xFF: + #FF = change music to a specific song that i don't know the name of + command = {"type": command_byte, "start_address": offset, "end_address": offset} + offset += 1 + else: + #if len(commands) > 0: + # print "Unknown text command " + hex(command_byte) + " at " + hex(offset) + ", script began with " + hex(commands[0]["type"]) + if debug: + print "Unknown text command at " + hex(offset) + " - command: " + hex(ord(extract_maps.rom[offset])) + " on map_id=" + str(map_id) + " text_id=" + str(text_id) + + #end at the first unknown command + end = True + add_command_byte_to_totals(command_byte) + + commands[command_counter] = command + command_counter += 1 + total_text_commands += len(commands) + return commands + +def analyze_texts(): + global should_be_total + + texts = {} + for map_id in extract_maps.map_headers: + if map_id in extract_maps.bad_maps: continue #skip + map2 = extract_maps.map_headers[map_id] + map2["texts"] = {} + referenced_texts = map2["referenced_texts"] + should_be_total += len(referenced_texts) + texts_pointer = int(map2["texts_pointer"], 16) + + #print "Checking texts on... map_id=" + str(map_id) + " and len(referenced_texts)=" + str(len(referenced_texts)) + for text_id in referenced_texts: + text_pointer = get_text_pointer(texts_pointer, text_id) + if 0x4000 <= text_pointer <= 0x7fff: #only care about bank when it's between 4000-7fff + text_pointer = extract_maps.calculate_pointer(text_pointer, int(map2["bank"], 16)) + #print "Working on map id=" + str(map2["id"]) + " and text id=" + str(text_id) + #print "for map_id=" + str(map_id) + " texts_pointer=" + hex(texts_pointer) + " text_id=" + str(text_id) + " the pointer=" + hex(text_pointer) + commands = parse_text_script(text_pointer, text_id, map_id) + + #process TX_FARs + for command_id in commands: + #skip commands starting with an unknown command byte + if len(commands[command_id]) == 0: continue + + if commands[command_id]["type"] == 0x17: + TX_FAR = parse_text_script(commands[command_id]["pointer"], text_id, map_id, txfar=True) + if debug: + if len(TX_FAR.keys()) > 0: + #print "TX_FAR object: " + str(TX_FAR) + print "processing a TX_FAR at " + hex(commands[command_id]["pointer"]) + "... first byte is: " + str(ord(extract_maps.rom[commands[command_id]["pointer"]])) + " .. offset: " + hex(commands[command_id]["pointer"]) + ##sys.exit(0) + + commands[command_id]["TX_FAR"] = TX_FAR + #map2["texts"][text_id][command_id]["TX_FAR"] = parse_text_script(command["pointer"], text_id, map_id) + map2["texts"][text_id] = commands + + texts[map_id] = map2["texts"] + extract_maps.map_headers[map_id]["texts"] = map2["texts"] + return texts + +def find_missing_08s(all_texts): + """determines which $08s have yet to be inserted + based on their start addresses""" + missing_08s = 0 + for map_id in all_texts.keys(): + for text_id in all_texts[map_id].keys(): + for line_id in all_texts[map_id][text_id].keys(): + if not line_id == 0: + current_line = all_texts[map_id][text_id][line_id] + if "type" in current_line.keys(): + if current_line["type"] == 0x8: + missing_08s += 1 + print "missing $08 on map_id=" + str(map_id) + " text_id=" + str(text_id) + " line_id=" + str(line_id) + " at " + hex(current_line["start_address"]) + return missing_08s + +def text_pretty_printer_at(start_address, label="SomeLabel"): + commands = parse_text_script(start_address, None, None) + needs_to_begin_with_0 = True #how should this be determined? + + #wanted_command = None + #if needs_to_begin_with_0: + # wanted_command = None + # for command_id in commands: + # command = commands[command_id] + # if command["type"] == 0: + # wanted_command = command_id + # + # if wanted_command == None: + # raise "error: address did not start with a $0 text" + + #start with zero please + byte_count = 0 + + output = "" + had_text_end_byte = False + had_text_end_byte_57_58 = False + had_db_last = False + first_line = True + for this_command in commands.keys(): + if not "lines" in commands[this_command].keys(): + command = commands[this_command] + if not "type" in command.keys(): + print "ERROR in command: " + str(command) + continue #dunno what to do here? + + if command["type"] == 0x1: #TX_RAM + if first_line: + output = "\n" + output += label + ": ; " + hex(start_address) + first_line = False + p1 = command["pointer"][0] + p2 = command["pointer"][1] + + #remember to account for big endian -> little endian + output += "\n" + spacing + "TX_RAM $%.2x%.2x" %(p2, p1) + byte_count += 3 + had_db_last = False + elif command["type"] == 0x17: #TX_FAR + if first_line: + output = "\n" + output += label + ": ; " + hex(start_address) + first_line = False + #p1 = command["pointer"][0] + #p2 = command["pointer"][1] + output += "\n" + spacing + "TX_FAR _" + label + " ; " + hex(command["pointer"]) + byte_count += 4 #$17, bank, address word + had_db_last = False + elif command["type"] == 0x9: #TX_RAM_HEX2DEC + if first_line: + output = "\n" + label + ": ; " + hex(start_address) + first_line = False + #address, read_byte + output += "\n" + spacing + "TX_NUM $%.2x%.2x, $%.2x" % (command["address"][1], command["address"][0], command["read_byte"]) + had_db_last = False + byte_count += 4 + elif command["type"] == 0x50 and not had_text_end_byte: + #had_text_end_byte helps us avoid repeating $50s + if first_line: + output = "\n" + label + ": ; " + hex(start_address) + first_line = False + if had_db_last: + output += ", $50" + else: + output += "\n" + spacing + "db $50" + byte_count += 1 + had_db_last = True + elif command["type"] in [0x57, 0x58] and not had_text_end_byte_57_58: + if first_line: #shouldn't happen, really + output = "\n" + label + ": ; " + hex(start_address) + first_line = False + if had_db_last: + output += ", $%.2x" % (command["type"]) + else: + output += "\n" + spacing + "db $%.2x" % (command["type"]) + byte_count += 1 + had_db_last = True + elif command["type"] in [0x57, 0x58] and had_text_end_byte_57_58: + pass #this is ok + elif command["type"] == 0x50 and had_text_end_byte: + pass #this is also ok + elif command["type"] == 0x0b: + if first_line: + output = "\n" + label + ": ; " + hex(start_address) + first_line = False + if had_db_last: + output += ", $0b" + else: + output += "\n" + spacing + "db $0B" + byte_count += 1 + had_db_last = True + elif command["type"] == 0x11: + if first_line: + output = "\n" + label + ": ; " + hex(start_address) + first_line = False + if had_db_last: + output += ", $11" + else: + output += "\n" + spacing + "db $11" + byte_count += 1 + had_db_last = True + elif command["type"] == 0x6: #wait for keypress + if first_line: + output = "\n" + label + ": ; " + hex(start_address) + first_line = False + if had_db_last: + output += ", $6" + else: + output += "\n" + spacing + "db $6" + byte_count += 1 + had_db_last = True + else: + print "ERROR in command: " + hex(command["type"]) + had_db_last = False + + #everything else is for $0s, really + continue + lines = commands[this_command]["lines"] + + #reset this in case we have non-$0s later + had_db_last = False + + #add the ending byte to the last line- always seems $57 + #this should already be in there, but it's not because of a bug in the text parser + lines[len(lines.keys())-1].append(commands[len(commands.keys())-1]["type"]) + + if first_line: + output = "\n" + output += label + ": ; " + hex(start_address) + "\n" + first_line = False + else: + output += "\n" + + first = True #first byte + for line_id in lines: + line = lines[line_id] + output += spacing + "db " + if first and needs_to_begin_with_0: + output += "$0, " + first = False + byte_count += 1 + + quotes_open = False + first_byte = True + was_byte = False + for byte in line: + if byte == 0x50: + had_text_end_byte = True #don't repeat it + if byte in [0x58, 0x57]: + had_text_end_byte_57_58 = True + + if byte in txt_bytes: + if not quotes_open and not first_byte: #start text + output += ", \"" + quotes_open = True + first_byte = False + if not quotes_open and first_byte: #start text + output += "\"" + quotes_open = True + output += txt_bytes[byte] + elif byte in constant_abbreviation_bytes: + if quotes_open: + output += "\"" + quotes_open = False + if not first_byte: + output += ", " + output += constant_abbreviation_bytes[byte] + else: + if quotes_open: + output += "\"" + quotes_open = False + + #if you want the ending byte on the last line + #if not (byte == 0x57 or byte == 0x50 or byte == 0x58): + if not first_byte: + output += ", " + + output += "$" + hex(byte)[2:] + was_byte = True + + #add a comma unless it's the end of the line + #if byte_count+1 != len(line): + # output += ", " + + first_byte = False + byte_count += 1 + #close final quotes + if quotes_open: + output += "\"" + quotes_open = False + + output += "\n" + include_newline = "\n" + if len(output)!=0 and output[-1] == "\n": + include_newline = "" + output += include_newline + "; " + hex(start_address) + " + " + str(byte_count) + " bytes = " + hex(start_address + byte_count) + print output + return (output, byte_count) + +def is_label_in_asm(label): + for line in analyze_incbins.asm: + if label in line: + if line[0:len(label)] == label: + return True + return False + +def find_undone_texts(): + usable_table = {} + if analyze_incbins.asm == None: + analyze_incbins.load_asm() + + for map_id in extract_maps.map_headers: + #skip bad maps + if map_id in extract_maps.bad_maps: continue + + map2 = extract_maps.map_headers[map_id] + name = map_name_cleaner(map2["name"], None)[:-2] + "Text" + + for text_id in map2["referenced_texts"]: + label = name + str(text_id) + + if len(extract_maps.map_headers[map_id]["texts"][text_id].keys()) == 0: continue + if len(extract_maps.map_headers[map_id]["texts"][text_id][0].keys()) == 0: continue + + try: + address = extract_maps.map_headers[map_id]["texts"][text_id][0]["start_address"] + except: + address = extract_maps.map_headers[map_id]["texts"][text_id][1]["start_address"] + + if not is_label_in_asm(label): + print label + " map_id=" + str(map_id) + " text_id=" + str(text_id) + " at " + hex(address) + " byte is: " + hex(ord(extract_maps.rom[address])) + if not address in usable_table.keys(): + usable_table[address] = 1 + else: + usable_table[address] += 1 + + print "\n\n which ones are priority?" + sorted_results = sorted(usable_table.iteritems(), key=itemgetter(1), reverse=True) + for result in sorted_results: + print str(result[1]) + " times: " + hex(result[0]) + +def scan_rom_for_tx_fars(printer=True): + """find TX_FARs + search only addresses that are INCBINed + keep only TX_FARs that are valid + + returns a list of [TX_FAR target address, TX_FAR address]""" + rom = extract_maps.rom + + analyze_incbins.load_asm() + analyze_incbins.isolate_incbins() + analyze_incbins.process_incbins() + + possible_tx_fars = [] + possible_tx_far_targets = [] + + for incbin_line_number in analyze_incbins.processed_incbins.keys(): + incbin = analyze_incbins.processed_incbins[incbin_line_number] + start_address = incbin["start"] + end_address = incbin["end"] + if incbin["interval"] == 0: continue #skip this one + + subrom = rom[start_address:end_address] + for address in range(start_address, end_address): + current_byte = ord(rom[address]) + if current_byte == 0x17: + if ord(rom[address+4]) == 0x50: + byte1 = ord(rom[address+1]) + byte2 = ord(rom[address+2]) + address2 = byte1 + (byte2 << 8) + if address2 > 0x3fff: + address2 = extract_maps.calculate_pointer(address2, ord(rom[address+3])) + #print "possible TX_FAR at " + hex(address) + " to " + hex(address2) + + possible_tx_fars.append(address) + possible_tx_far_targets.append([address2, address]) + + if printer: + pre_handled = [] + #address_bundle is [TX_FAR target address, TX_FAR address] + for address_bundle in possible_tx_far_targets: + if address_bundle[0] in [0xa82f8, 0xa8315]: + continue #bad + if address_bundle[0] in pre_handled: + continue #already did this + + print "-------" + print "TX_FAR is at: " + hex(address_bundle[1]) + + #let's try printing out the TX_FAR? + text_pretty_printer_at(address_bundle[1], "blah") + + text_pretty_printer_at(address_bundle[0], "_blah") + print "-------" + pre_handled.append(address_bundle[0]) + return possible_tx_far_targets + +if __name__ == "__main__": + extract_maps.load_rom() + extract_maps.load_map_pointers() + extract_maps.read_all_map_headers() + #text_output = analyze_texts() + #print text_output + + #these aren't really "missing", just a certain type that was + #known to be missed on a first pass. + #missing_08s = find_missing_08s(text_output) + + #print "\n\n---- stats ----\n\n" + + #popular_text_commands = sorted(totals.iteritems(), key=itemgetter(1), reverse=True) + #convert the first values (command byte) to hex + #for popular_item in popular_text_commands: + # print hex(popular_item[0]) + " was used " + str(popular_item[1]) + " times." + #print "popular text commands: " + str(popular_text_commands) + + #print "total text commands: " + str(total_text_commands) + #print "total text scripts: " + str(should_be_total) + #print "missing 08s: " + str(missing_08s) + #print "\n\n" + + #text_pretty_printer_at(0x800b1) + #find_undone_texts() + + scan_rom_for_tx_fars() |