FlashGBX 3.37__py3-none-any.whl → 4.0.1__py3-none-any.whl

FlashGBX/RomFileAGB.py

@@ -2,9 +2,15 @@
 # FlashGBX
 # Author: Lesserkuma (github.com/lesserkuma)
 
-import hashlib, re, zlib, string, os, json, copy
+import hashlib, re, zlib, string, os, json, copy, struct
 from . import Util
 
+try:
+	Image = None
+	from PIL import Image
+except:
+	pass
+
 class RomFileAGB:
 	ROMFILE_PATH = None
 	ROMFILE = bytearray()
@@ -41,6 +47,77 @@ class RomFileAGB:
 		self.CalcChecksumHeader(True)
 		return self.ROMFILE[0:0x200]
 	
+	def LogoToImage(self, data, valid=True):
+		if Image is None: return False
+		if data in (bytearray([0] * len(data)), bytearray([0xFF] * len(data))): return False
+		
+		# HuffUnComp function provided by Winter1760, thank you!
+		def HuffUnComp(data):
+			bits = data[0] & 15
+			out_size = int.from_bytes(data[1:4], "little") & 0xFFFF
+			i = 6 + data[4] * 2
+			node_offs = 5
+			out_units = 0
+			out_ready = 0
+			out = b""
+			while len(out) < out_size:
+				in_unit = int.from_bytes(data[i:i+2], "little") | int.from_bytes(data[i^2:(i^2)+2], "little") << 16
+				i += 4
+				for b in range(31, -1, -1):
+					node = data[node_offs]
+					node_offs &= ~1
+					node_offs += (node & 0x3F) * 2 + 2 + (in_unit >> b & 1)
+					if node << (in_unit >> b & 1) & 0x80:
+						out_ready >>= bits
+						out_ready |= data[node_offs] << 32 - bits
+						out_ready &= 0xFFFFFFFF
+						out_units += 1
+						if out_units == bits % 8 + 4:
+							out += out_ready.to_bytes(4, "little")
+							if len(out) >= out_size:
+								return out
+							out_units = 0
+							out_ready = 0
+						node_offs = 5
+			return out
+		
+		def Diff16BitUnFilter(data):
+			header = struct.unpack("I", data[0:4])[0]
+			out_size = (header >> 8) & 0xFFFF
+			pos = 4
+			prev = 0
+			dest = bytearray()
+			while pos < out_size:
+				if pos+2 > len(data): break
+				temp = (struct.unpack("H", data[pos:pos+2])[0] + prev) & 0xFFFF
+				dest += struct.pack("H", temp)
+				pos += 2
+				prev = temp
+			return dest
+		
+		temp = bytearray.fromhex("09050A060B07C20DC2020E08C30483018303C30C830F8382828101000000400F0000D424")
+		temp.reverse()
+		data = temp + data
+		data = HuffUnComp(data)
+		data = Diff16BitUnFilter(data)
+
+		img = Image.new(mode='P', size=(104, 16))
+		img.info["transparency"] = 0
+		img.putpalette([ 255, 255, 255, 0, 0, 0 ])
+		pixels = img.load()
+
+		for tile_row in range(0, 2):
+			for tile_w in range(0, 13):
+				for tile_h in range(0, 8):
+					for bit in range(0, 8):
+						pos = (tile_row * 13 * 8) + (tile_w * 8) + tile_h
+						if pos >= len(data): break
+						pixel = (data[pos] >> bit) & 1
+						x = tile_w * 8 + bit
+						y = tile_row * 8 + tile_h
+						pixels[x, y] = pixel
+		return img
+	
 	def GetHeader(self, unchanged=False):
 		buffer = bytearray(self.ROMFILE)
 		data = {}
@@ -50,15 +127,23 @@ class RomFileAGB:
 		nocart_hashes.append(bytearray([ 0xA5, 0x03, 0xA1, 0xB5, 0xF5, 0xDD, 0xBE, 0xFC, 0x87, 0xC7, 0x9B, 0x13, 0x59, 0xF7, 0xE1, 0xA5, 0xCF, 0xE0, 0xAC, 0x9F ])) # Method 1
 		nocart_hashes.append(bytearray([ 0x46, 0x86, 0xE3, 0x81, 0xB2, 0x4A, 0x2D, 0xB0, 0x7D, 0xE8, 0x3D, 0x45, 0x2F, 0xA3, 0x1E, 0x8A, 0x04, 0x4B, 0x3A, 0x50 ])) # Method 2
 		data["empty_nocart"] = hash in nocart_hashes
+		if not data["empty_nocart"]:
+			nocart_hashes.append(bytearray([ 0x2B, 0xDC, 0x7D, 0xEF, 0x6C, 0x48, 0x1F, 0xBF, 0xEE, 0xB8, 0x80, 0xB1, 0xD0, 0xFD, 0xF6, 0x57, 0x5D, 0x6A, 0x39, 0xBE ]))
+			nocart_hashes.append(bytearray([ 0x09, 0xB9, 0x0E, 0x53, 0x5E, 0x85, 0x50, 0xF8, 0x90, 0xA4, 0xF4, 0x77, 0x13, 0x7E, 0x45, 0x59, 0xA5, 0xC0, 0xA4, 0x45 ]))
+			data["empty_nocart"] = hashlib.sha1(buffer[0x10:0x50]).digest() in nocart_hashes
+		
 		data["empty"] = (buffer[0x04:0xA0] == bytearray([buffer[0x04]] * 0x9C)) or data["empty_nocart"]
 		if data["empty_nocart"]: buffer = bytearray([0x00] * len(buffer))
 		data["logo_correct"] = hashlib.sha1(buffer[0x04:0xA0]).digest() == bytearray([ 0x17, 0xDA, 0xA0, 0xFE, 0xC0, 0x2F, 0xC3, 0x3C, 0x0F, 0x6A, 0xBB, 0x54, 0x9A, 0x8B, 0x80, 0xB6, 0x61, 0x3B, 0x48, 0xEE ])
+		temp = self.LogoToImage(buffer[0x04:0xA0], data["logo_correct"])
+		if temp is not False and not data["empty"]: data["logo"] = temp
+
 		data["game_title_raw"] = bytearray(buffer[0xA0:0xAC]).decode("ascii", "replace")
 		game_title = data["game_title_raw"]
 		game_title = re.sub(r"(\x00+)$", "", game_title)
 		game_title = re.sub(r"((_)_+|(\x00)\x00+|(\s)\s+)", "\\2\\3\\4", game_title).replace("\x00", "_")
 		game_title = ''.join(filter(lambda x: x in set(string.printable), game_title))
-		data["game_title"] = game_title
+		data["game_title"] = game_title.replace("\n", "")
 		data["game_code_raw"] = bytearray(buffer[0xAC:0xB0]).decode("ascii", "replace")
 		game_code = data["game_code_raw"]
 		game_code = re.sub(r"(\x00+)$", "", game_code)
@@ -85,6 +170,11 @@ class RomFileAGB:
 		data["save_type"] = None
 		data["save_size"] = 0
 
+		# Vast Fame (unlicensed protected carts)
+		data["vast_fame"] = False
+		if buffer[0x15C:0x16C] == bytearray([ 0xB4, 0x00, 0x9F, 0xE5, 0x99, 0x10, 0xA0, 0xE3, 0x00, 0x10, 0xC0, 0xE5, 0xAC, 0x00, 0x9F, 0xE5 ]): # Initialization code always present in Vast Fame carts
+			data["vast_fame"] = True
+
 		# 8M FLASH DACS
 		data["dacs_8m"] = False
 		if (data["game_title"] == "NGC-HIKARU3" and data["game_code"] == "GHTJ" and data["header_checksum"] == 0xB3):

FlashGBX/RomFileDMG.py

@@ -196,7 +196,7 @@ class RomFileDMG:
 				data["mapper_raw"] = 0x0B
 			
 			# Unlicensed 256M Mapper
-			elif (data["game_title"].upper() == "GB HICOL" and data["header_checksum"] in (0x4A, 0x49, 0xE9)) or \
+			elif (data["game_title"].upper() == "GB HICOL" and data["header_checksum"] in (0x4A, 0x49, 0xE8, 0xE9)) or \
 			(data["game_title"] == "BennVenn" and data["header_checksum"] == 0x48):
 				data["rom_size_raw"] = 0x0A
 				data["ram_size_raw"] = 0x201

FlashGBX/UserInputDialog.py

@@ -18,6 +18,8 @@ class UserInputDialog(QtWidgets.QDialog):
 
 		self.lblIntro = QtWidgets.QLabel(args["intro"])
 		self.lblIntro.setStyleSheet("margin-bottom: 4px")
+		self.lblIntro.setMaximumWidth(350)
+		self.lblIntro.setWordWrap(True)
 		self.btnOK = QtWidgets.QPushButton("&OK")
 		self.btnCancel = QtWidgets.QPushButton("&Cancel")
 		
@@ -42,6 +44,24 @@ class UserInputDialog(QtWidgets.QDialog):
 				grid_layout.addWidget(lbl, grid_rows, 0, 1, 1)
 				grid_layout.addWidget(cmb, grid_rows, 1, 1, 1)
 			
+			elif param[1] in ("spb"):
+				lbl = QtWidgets.QLabel(param[2])
+				spb = QtWidgets.QSpinBox()
+				spb.setRange(param[3][0], param[3][1])
+				spb.setValue(param[4])
+				self.paramWidgets[param[0]] = spb
+				grid_layout.addWidget(lbl, grid_rows, 0, 1, 1)
+				grid_layout.addWidget(spb, grid_rows, 1, 1, 1)
+
+			elif param[1] in ("chk"):
+				#lbl = QtWidgets.QLabel(param[2])
+				chk = QtWidgets.QCheckBox()
+				chk.setChecked(param[4])
+				chk.setText(param[2])
+				self.paramWidgets[param[0]] = chk
+				#grid_layout.addWidget(lbl, grid_rows, 0, 1, 1)
+				grid_layout.addWidget(chk, grid_rows, 0, 1, 2)
+
 			else:
 				continue
 			

FlashGBX/Util.py

@@ -2,21 +2,22 @@
 # FlashGBX
 # Author: Lesserkuma (github.com/lesserkuma)
 
-import math, time, datetime, copy, configparser, threading, statistics, os, platform, traceback, io, struct, re
+import math, time, datetime, copy, configparser, threading, os, platform, traceback, io, struct, re, statistics, random
+from io import StringIO
 from enum import Enum
 
 # Common constants
 APPNAME = "FlashGBX"
-VERSION_PEP440 = "3.37"
+VERSION_PEP440 = "4.0.1"
 VERSION = "v{:s}".format(VERSION_PEP440)
-VERSION_TIMESTAMP = 1709318129
+VERSION_TIMESTAMP = 1719742346
 DEBUG = False
 DEBUG_LOG = []
 APP_PATH = ""
 CONFIG_PATH = ""
 
-AGB_Header_ROM_Sizes = [ "64 KiB", "128 KiB", "256 KiB", "512 KiB", "1 MiB", "2 MiB", "4 MiB", "8 MiB", "16 MiB", "32 MiB", "64 MiB", "128 MiB", "256 MiB", "512 MiB" ]
-AGB_Header_ROM_Sizes_Map = [ 0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0x10000000, 0x20000000 ]
+AGB_Header_ROM_Sizes = [ "32 KiB", "64 KiB", "128 KiB", "256 KiB", "512 KiB", "1 MiB", "2 MiB", "4 MiB", "8 MiB", "16 MiB", "32 MiB", "64 MiB", "128 MiB", "256 MiB", "512 MiB" ]
+AGB_Header_ROM_Sizes_Map = [ 0x8000, 0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0x10000000, 0x20000000 ]
 AGB_Header_Save_Types = [ "None", "4K EEPROM (512 Bytes)", "64K EEPROM (8 KiB)", "256K SRAM/FRAM (32 KiB)", "512K FLASH (64 KiB)", "1M FLASH (128 KiB)", "8M DACS (1 MiB)", "Unlicensed 512K SRAM (64 KiB)", "Unlicensed 1M SRAM (128 KiB)", "Unlicensed Batteryless SRAM" ]
 AGB_Header_Save_Sizes = [ 0, 512, 8192, 32768, 65536, 131072, 1048576, 65536, 131072, 0 ]
 AGB_Flash_Save_Chips = { 0xBFD4:"SST 39VF512", 0x1F3D:"Atmel AT29LV512", 0xC21C:"Macronix MX29L512", 0x321B:"Panasonic MN63F805MNP", 0xC209:"Macronix MX29L010", 0x6213:"SANYO LE26FV10N1TS", 0xBF5B:"Unlicensed SST49LF080A", 0xFFFF:"Unlicensed 0xFFFF" }
@@ -110,21 +111,42 @@ class IniSettings():
 		if self.FILENAME is not False:
 			with open(self.FILENAME, "w", encoding="UTF-8") as f:
 				self.SETTINGS.write(f)
+	
+	def GetString(self):
+		output = StringIO()
+		self.SETTINGS.write(output)
+		return(output.getvalue())
 
 class Progress():
 	MUTEX = threading.Lock()
 	PROGRESS = {}
 	UPDATER = None
+	WAITER = None
 	
-	def __init__(self, updater):
+	def __init__(self, updater, waiter):
 		self.UPDATER = updater
+		self.WAITER = waiter
 	
+	def IsOutlier(self, speeds, new_number, threshold):
+		if not speeds: return False
+		mean = sum(speeds) / len(speeds)
+		std_deviation = (sum((x - mean) ** 2 for x in speeds) / len(speeds)) ** 0.5
+		lower_bound = mean - threshold * std_deviation
+		upper_bound = mean + threshold * std_deviation
+		if new_number < lower_bound or new_number > upper_bound:
+			return True
+		else:
+			return False
+
 	def SetProgress(self, args):
 		self.MUTEX.acquire(1)
 		try:
 			if not "method" in self.PROGRESS: self.PROGRESS = {}
 			now = time.time()
-			if args["action"] == "INITIALIZE":
+			if args["action"] == "USER_ACTION":
+				self.WAITER(args)
+
+			elif args["action"] == "INITIALIZE":
 				self.PROGRESS["action"] = args["action"]
 				self.PROGRESS["method"] = args["method"]
 				if "flash_offset" in args:
@@ -139,6 +161,10 @@ class Progress():
 					self.PROGRESS["pos"] = args["pos"] - self.PROGRESS["flash_offset"]
 				else:
 					self.PROGRESS["pos"] = 0
+				if "sector_count" in args:
+					self.PROGRESS["sector_count"] = args["sector_count"]
+				else:
+					self.PROGRESS["sector_count"] = 1
 				if "time_start" in args:
 					self.PROGRESS["time_start"] = args["time_start"]
 				else:
@@ -149,6 +175,7 @@ class Progress():
 				self.PROGRESS["speed"] = 0
 				self.PROGRESS["speeds"] = []
 				self.PROGRESS["bytes_last_update_speed"] = 0
+				self.PROGRESS["sector_erase_time"] = 0
 				self.UPDATER(self.PROGRESS)
 			
 			if args["action"] == "ABORT":
@@ -166,41 +193,51 @@ class Progress():
 			
 			elif self.PROGRESS == {}:
 				return
-			
-			elif args["action"] == "UPDATE_POS":
-				self.PROGRESS["pos"] = args["pos"] - self.PROGRESS["flash_offset"]
-				self.PROGRESS["action"] = "PROGRESS"
-				if "time_start" in self.PROGRESS:
-					self.PROGRESS["time_elapsed"] = now - self.PROGRESS["time_start"]
-				
-				try:
-					total_speed = statistics.mean(self.PROGRESS["speeds"])
-					self.PROGRESS["time_left"] = (self.PROGRESS["size"] - self.PROGRESS["pos"]) / 1024 / total_speed
-				except:
-					pass
-				if "abortable" in args: self.PROGRESS["abortable"] = args["abortable"]
-				self.UPDATER(self.PROGRESS)
-			
-			elif args["action"] in ("READ", "WRITE"):
+
+			elif args["action"] in ("READ", "WRITE", "UPDATE_POS"):
 				if "method" not in self.PROGRESS: return
-				elif args["action"] in ("READ") and self.PROGRESS["method"] in ("SAVE_WRITE", "ROM_WRITE"): return
-				elif args["action"] in ("WRITE") and self.PROGRESS["method"] in ("SAVE_READ", "ROM_READ", "ROM_WRITE_VERIFY"): return
-				if self.PROGRESS["pos"] >= self.PROGRESS["size"]: return
-				
+				elif args["action"] == "READ" and self.PROGRESS["method"] in ("SAVE_WRITE", "ROM_WRITE"): return
+				elif args["action"] == "WRITE" and self.PROGRESS["method"] in ("SAVE_READ", "ROM_READ", "ROM_WRITE_VERIFY"): return
+				if self.PROGRESS["pos"] > self.PROGRESS["size"]: return
+				skip_speed = False
 				self.PROGRESS["action"] = "PROGRESS"
-				self.PROGRESS["pos"] += args["bytes_added"]
-				if (now - self.PROGRESS["time_last_emit"]) > 0.05:
+				if args["action"] in ("READ", "WRITE"):
+					self.PROGRESS["pos"] += args["bytes_added"]
+				elif args["action"] == "UPDATE_POS":
+					# print(self.PROGRESS["pos"], args["pos"] - self.PROGRESS["flash_offset"])
+					if self.PROGRESS["pos"] == args["pos"] - self.PROGRESS["flash_offset"]:
+						skip_speed = True
+					self.PROGRESS["pos"] = args["pos"] - self.PROGRESS["flash_offset"]
+					if "sector_erase_time" in args:
+						if "sector_erase_time" in self.PROGRESS:
+							self.PROGRESS["sector_erase_time"] = (self.PROGRESS["sector_erase_time"] + args["sector_erase_time"]) / 2
+						else:
+							self.PROGRESS["sector_erase_time"] = args["sector_erase_time"]
+					if "sector_pos" in args:
+						if "sector_erase_time" not in args: self.PROGRESS["sector_erase_time"] = 0
+						self.PROGRESS["sector_pos"] = args["sector_pos"]
+					if "abortable" in args:
+						self.PROGRESS["abortable"] = args["abortable"]
+				
+				if ((now - self.PROGRESS["time_last_emit"]) > 0.06) or "force_update" in args and args["force_update"] is True:
 					self.PROGRESS["time_elapsed"] = now - self.PROGRESS["time_start"]
-					if (now - self.PROGRESS["time_last_update_speed"]) > 0.25:
-						time_delta = now - self.PROGRESS["time_last_update_speed"]
-						pos_delta = self.PROGRESS["pos"] - self.PROGRESS["bytes_last_update_speed"]
-						if time_delta > 0:
-							speed = (pos_delta / time_delta) / 1024
-							self.PROGRESS["speeds"].append(speed)
-							if len(self.PROGRESS["speeds"]) > 256: self.PROGRESS["speeds"].pop(0)
-							self.PROGRESS["speed"] = statistics.median(self.PROGRESS["speeds"])
-						self.PROGRESS["time_last_update_speed"] = now
-						self.PROGRESS["bytes_last_update_speed"] = self.PROGRESS["pos"]
+					time_delta = now - self.PROGRESS["time_last_update_speed"]
+					pos_delta = self.PROGRESS["pos"] - self.PROGRESS["bytes_last_update_speed"]
+					if time_delta > 0 and (time.time() - self.PROGRESS["time_start"] > 2) and "sector_erase_time" not in args:
+						speed = (pos_delta / time_delta) / 1024
+						if speed > 0 and not skip_speed:
+							if len(self.PROGRESS["speeds"]) < 40 or not self.IsOutlier(speeds=self.PROGRESS["speeds"], new_number=speed, threshold=25):
+								self.PROGRESS["speeds"].append(speed)
+							if len(self.PROGRESS["speeds"]) > 50: self.PROGRESS["speeds"].pop(0)
+							if len(self.PROGRESS["speeds"]) > 1 and random.randint(0, 10) == 0: self.PROGRESS["speeds"].pop(0)
+							# print(len(self.PROGRESS["speeds"]), pos_delta, end="  \r", flush=True)
+						if len(self.PROGRESS["speeds"]) > 0:
+							# print(self.PROGRESS["speeds"])
+							self.PROGRESS["speed"] = statistics.mean(self.PROGRESS["speeds"])
+						else:
+							self.PROGRESS["speed"] = 0
+					self.PROGRESS["time_last_update_speed"] = now
+					self.PROGRESS["bytes_last_update_speed"] = self.PROGRESS["pos"]
 					
 					if "skipping" in args and args["skipping"] is True:
 						self.PROGRESS["speed"] = 0
@@ -208,9 +245,11 @@ class Progress():
 					else:
 						self.PROGRESS["skipping"] = False
 					
-					if self.PROGRESS["speed"] > 0:
-						total_speed = statistics.mean(self.PROGRESS["speeds"])
+					if self.PROGRESS["speed"] > 0 and len(self.PROGRESS["speeds"]) > 0:
+						total_speed = self.PROGRESS["speed"] #statistics.mean(self.PROGRESS["speeds"])
 						self.PROGRESS["time_left"] = (self.PROGRESS["size"] - self.PROGRESS["pos"]) / 1024 / total_speed
+						if self.PROGRESS["sector_erase_time"] > 0:
+							self.PROGRESS["time_left"] += self.PROGRESS["sector_erase_time"] * (self.PROGRESS["sector_count"] - self.PROGRESS["sector_pos"])
 					
 					self.UPDATER(self.PROGRESS)
 					self.PROGRESS["time_last_emit"] = now
@@ -235,9 +274,10 @@ class Progress():
 				
 				self.UPDATER(self.PROGRESS)
 				del(self.PROGRESS["method"])
-		
+
 		finally:
 			self.MUTEX.release()
+
 	
 class TAMA5_CMD(Enum):
 	RAM_WRITE = 0x0
@@ -332,7 +372,7 @@ def formatProgressTime(seconds, asFloat=False):
 		s += ", "
 	if sec >= 1 or seconds < 60:
 		s += "{:d} second".format(int(sec))
-		if sec != 1: s += "s"
+		if int(sec) != 1: s += "s"
 		s += ", "
 	return s[:-2]
 
@@ -535,14 +575,16 @@ def GetDumpReport(di, device):
 			"* ROM Size:        {rom_size:s}\n" \
 			"* Mapper Type:     {mapper_type:s}\n" \
 			"* Cartridge Type:  {cart_type:s}\n" \
-		.format(system=di["system"], rom_size=di["rom_size"], mapper_type=di["mapper_type"], cart_type=di["cart_type"])
+			"* Read Method:     {read_method:s}\n" \
+		.format(system=di["system"], rom_size=di["rom_size"], mapper_type=di["mapper_type"], cart_type=di["cart_type"], read_method=di["dmg_read_method"])
 	elif mode == "AGB":
 		s += "" \
 			"\n== Dumping Settings ==\n" \
 			"* Mode:            {system:s}\n" \
 			"* ROM Size:        {rom_size:s}\n" \
 			"* Cartridge Type:  {cart_type:s}\n" \
-		.format(system=di["system"], rom_size=di["rom_size"], cart_type=di["cart_type"])
+			"* Read Method:     {read_method:s}\n" \
+		.format(system=di["system"], rom_size=di["rom_size"], cart_type=di["cart_type"], read_method=di["agb_read_method"])
 
 	di["hdr_logo"] = "OK" if header["logo_correct"] else "Invalid"
 	header["game_title_raw"] = header["game_title_raw"].replace("\0", "␀")
@@ -734,6 +776,11 @@ def GetDumpReport(di, device):
 		if "eeprom_data" in di:
 			s += "* EEPROM area:     {:s}…\n".format(''.join(format(x, '02X') for x in di["eeprom_data"]))
 
+		if di["cart_type"] == "Vast Fame":
+			s += "\n== Vast Fame Protection Information ==\n"
+			s += "* Address Reordering: {:s}\n".format(str(di["vf_addr_reorder"]))
+			s += "* Value Reordering: {:s}\n".format(str(di["vf_value_reorder"]))
+
 		if header["db"] is not None and header["db"]["rc"] == di["hash_crc32"]:
 			db = header["db"]
 			s += "\n== Database Match ==\n"
@@ -787,6 +834,7 @@ def GenerateFileName(mode, header, settings=None):
 			path = path.replace("%TITLE%", path_title.strip())
 			path = path.replace("%CODE%", path_code.strip())
 			path = path.replace("%REVISION%", path_revision)
+			path = path.replace("%MAPPER%", get_mbc_name(header["mapper_raw"]))
 			path = re.sub(r"[<>:\"/\\|\?\*]", "_", path)
 			if get_mbc_name(header["mapper_raw"]) == "G-MMC1":
 				if "gbmem_parsed" in header:
@@ -864,12 +912,12 @@ def find_size(data, max_size, min_size=0x20):
 	return offset
 
 def dprint(*args, **kwargs):
-	global DEBUG_LOG
 	stack = traceback.extract_stack()
 	stack = stack[len(stack)-2]
+
 	msg = "[{:s}] [{:s}:{:d}] {:s}(): {:s}".format(datetime.datetime.now().astimezone().replace(microsecond=0).isoformat(), os.path.split(stack.filename)[1], stack.lineno, stack.name, " ".join(map(str, args)), **kwargs)
 	DEBUG_LOG.append(msg)
-	DEBUG_LOG = DEBUG_LOG[-32768:]
+	if len(DEBUG_LOG) > 64*1024: DEBUG_LOG.pop(0)
 	if DEBUG:
 		msg = "{:s}{:s}".format(ANSI.CLEAR_LINE, msg)
 		print(msg)