ZSIJ Running dASM

80025C00	inception point
	8006B780[0:0xB4C50] = repeat(0, 0xB4C50)
	SP = 800B1A60
	goto 8003A940()
80025C60	V0 = 80113110[0]
80025C6C	Thread: game
	call 80047068(0)	# initialize Aleck
	call 8004742C(800ADBC8)	# write Aleck hardware handles to A0
	call 80029170(800ADBC8)	# read Aleck IO using handles A0 to manager at 80112968
	800AEE78+0 = 0
	800AEE78+4 = 0
	80112A2C[0] = 0
	8007D8E4[0] = 0
	call 8003CA30()	# ???; sets up framebuffers and display processing threads
	call 8003CB80()
	call 8003C8A0()	# create E/PI Thread and handle
	call 80029CF0()	# redirect to 8003DBB0: add SI callback for 80066D94
	call 8003EF10()
	8007DAEC = 0x20000
	call 80053E50(8007DB30, 0x20000)	# initialize A1 bytes at A0
	call 800341E0(8007DB30, @8007DAEC)	# create memory manager for A1 bytes at A0
	call 8002623C(0)	# set screen resolution A0: 320x240
	call 8003C900(0x46B80, 801203D0, 0x64580 - 0x46B80)	# load A2 bytes from hardware A0 to rdram A1
	dl = 80118390
	801182C0 = 80118390+8	# cur p->DL
	dl.append(E9000000, 00000000)
	801182C0 = 80118390+10
	dl.append(DF000000, 00000000)
	80117620 = 0
	80117624 = 0
	80064FE0 = 0
	80064FB4 = 0
	80064FE0 = 1
	# 80025DB0
	while True:
		800AEE78+0 = 0
		800AEE78+4 = 0
		80113110[0] = 0
		80112A2C[0] = 0
		8007D8E4[0] = 0
		call 80029170(800ADBC8)	# read Aleck IO using handles A0 to manager at 80112968
		call 80037990(800ADBC8)
		for i in range(2):
			8007D8E8+(i<<2) = 3
			8007D900[i*5] = 0
			v = 0xC + (i << 1)
			8007D8E8[v:v+2] = 0
		# 80025E40
		8007D890[0:2] = 0
		8007DAE8[0:2] = 0
		8007D8A8[0:2] = 0
		800B2680[0:2] = 0
		800ADC3C[0:2] = 0
		call 800374F0()
		call 80028D90()
		call 80028DC8(0, 8002A7E8)	# link context function A1 in index A0
		call 8003C580(80025EC0)	# set 80066DA0 to function pointer A0
		call 8003C870()	# 800AE9F8 = 0x80
		while True:
			if not call 80025C60():	# V0 = 80113110[0]
				break
80025EC0
	80117624 += 1
	80117620 += (@80117624 < 1)
	8006B780 += 1
	if not 80118300[6:8]:
		call 80029424()
	elif 80118300[6:8] == 1:
		800ADC3C[0:2] = 0
		800B2680[0:2] = 0
		call 800293D4()	# update 80112978 with current Aleck switch state
	else:
		call 800293D4()	# update 80112978 with current Aleck switch state
	call 80037C70()
	if @800D26B8 or @80064FB4:
		return
	# 80025F7C
	...

8002622C	unconditional return
	accepts: A0
80026234	NERFed! display string A1; unconditional return
	accepts: A0=palette?, A1=p->string
8002623C	set screen resolution A0
	accepts: A0=resolution (0:320x240, 1:640x480)
	call 8003C5E0()	# wait while @800D26B8 nonzero
	if not A0:
		if not @80064FB0 & 0x40:
			return
		80064FBC = 0x140
		80064FC0 = 0xF0
		call 80055850(80068740)	# use VI settings at A0
		call 8003C830()	# disable display and blackout
		call 8003C630(80064FC4, 3)	# register A1 framebuffers starting at rdram A0
		800ADBB0 = 80000400
		call 8003C870()	# 800AE9F8 = 0x80
		80064FB0 &= ~0x40
	elif A0 == 1:
		# 800262CC
		if @80064FB0 & 0x40:
			return
		80064FBC = 0x280
		80064FC0 = 0x1E0
		call 80055850(80068790)	# use VI settings at A0
		call 8003C830()	# disable display and blackout
		call 8003C630(80064FD0, 1)	# register A1 framebuffers starting at rdram A0
		800ADBB0 = 80000400
		call 8003C870()	# 800AE9F8 = 0x80
		80064FB0 |= 0x40
80026360	unconditional return
80026368

80028A5C	set A1 words at A0 to previous address & 0xFFFFFF
	accepts: A0=p->target, A1=words
	A1 <<= 2
	for i in (A0+A1, A0, -4):
		i+0 = (i - 4) & 0xFFFFFF
	A0+0 = 0
80028A9C	append list of display list pointers at A0
	accepts: A0=p->list of DL pointers
	v = @A0+0
	while v:
		if (v>>24) == 0:
			v &= 0xFFFFFF
			v = @80000000+v
		elif (v>>24) == 1:
			v = (v & 0xFFFFFF) - 80000000
			dl = @801182C0
			dl.append(DE000000, @v+4)
			801182C0 += 8
			v = @v+0
80028B1C
	accepts: A0, A1, A2, A3, SP+10, SP+14
	v = @800AEED4
	800AEED4 += 0x48
	v+44 = v + 0x48
	i = (0 - @80064FC0) << 1
	j = @80064FBC + (@80064FBC >> 31)
	j >>= 1
	k = @80064FC0 + (@80064FC0 >> 31)
	k >>= 1
	v[0:2] = A0 + A3 - j
	v[2:4] = k - (A1 + @SP+10)
	v[4:6] = i
	v[C] = (@SP+14 >> 16) & 0xFF
	v[D] = (@SP+14 >> 8) & 0xFF
	v[E] = @SP+14 & 0xFF
	v[12:14] = k - (A1 + @SP+10)
	v[14:16] = i
	v[20:22] = A0 + A3 - j
	v[22:24] = k - (A0 + j)
	v[24:26] = i
	v[30:32] = j
	v[32:34] = k - (A0 + j)
	v[34:36] = i
	v+40 = 0
	v+48.append(DA380003, @801203A8 + 80000080)
	v+50.append(01004008, v)
	v+58.append(E7000000, 00000000)
	v+60.append(E3000A01, 00000000)
	v+68.append(FC327E64, FFFFF7FB)
	v+70.append(D9000000, 00000000)
	v+78.append(D9FFFFFF, 00000404)
	if not @80064FE4:
		v+80.append(E200001C, 00552008)
		v+88.append(FA000101, FFFFFFFF)
	else:
		if @80064FE4 == 1:
			v+80.append(E200001C, 005041C8)
		else:
			v+80.append(E200001C, 005A41C8)
		v+88.append(FA000101, FFFFFF00 | 80064FE8[3])
	# 80028CFC
	v+90.append(06000402, 00000604)
	v+98.append(DF000000, 00000000)
	800AEED4 = v + 0xA0
	A2 = min(0xFFF, A2)
	A2 &= (~A2 >> 31)
	A2 <<= 2
	A3+0 = @80113490+A2
	80113490+A2 = 01000000 + (A3 & 0xFFFFFF)
80028D90
	call 8005C620(800AEF50, 0, 0x840)	# V0=p->A2 bytes at A0 filled with value A1
	800AEF4C = 0
	80117490 = 0
80028DC8	link context function A1 in index A0
	accepts: A0=index, A1=p->function
	v = 800AEF50 + (A0 * 0x84)
	call 8005C620(v, 0, 0x84)	# V0=p->A2 bytes at A0 filled with value A1
	v+78 = 8009EBB0 + (A0 * 0x1000)
	v+0 = 1
	v+80 = A1
	i = 1 << A0
	80117490 = @80117490 | i
	800AEF4C = @800AEF4C & ~i
	v+44 = S0
	v+48 = S1
	v+4C = S2
	v+50 = S3
	v+54 = S4
	v+58 = S5
	v+5C = S6
	v+60 = S7
	v+6C = K0
	v+70 = K1
	v+74 = GP
	v+7C = S8
80028EA8	stop and unlink registered context function A0
	accepts: A0=flag index
	v = 1 << A0
	80117490 &= ~v
	800AEF4C &= ~v
80028EE0	set context flag A0 at 800AEF4C
	accepts: A0=flag index
	v = 1 << A0
	800AEF4C |= v
80028F00	unset context flag A0 at 800AEF4C
	accepts: A0=flag index
	v = 1 << A0
	800AEF4C &= ~v
80028F24	V0 = True if context function A0 linked else False
	accepts: A0=flag index
	v = 1 << A0
	return @80117490 & v
80028F3C
	800D26C8+40 = S0
	800D26C8+44 = S1
	800D26C8+48 = S2
	800D26C8+4C = S3
	800D26C8+50 = S4
	800D26C8+54 = S5
	800D26C8+58 = S6
	800D26C8+5C = S7
	800D26C8+68 = K0
	800D26C8+6C = K1
	mask = 1
	i = 800AEF50
	# 80028F9C
	for j in range(0x10):
		if (@80117490 & mask) and (@800AEF4C & mask):
			i -= 1
			if not @i:
				800D26C8+8 = V0
				800D26C8+C = V1
				800D26C8+10 = A0
				800D26C8+14 = A1
				800D26C8+18 = A2
				800D26C8+1C = A3
				800D26C8+3C = T7
				800D26C8+70 = GP
				800D26C8+74 = SP
				800D26C8+78 = S8
				800D26C8+7C = RA
				# 80028FF8
				S0 = @i+44
				S1 = @i+48
				S2 = @i+4C
				S3 = @i+50
				S4 = @i+54
				S5 = @i+58
				S6 = @i+5C
				S7 = @i+60
				K0 = @i+6C
				K1 = @i+70
				GP = @i+74
				SP = @i+78
				S8 = @i+7C
				800D26C8+80 = 80029084
				call @i+80()
				# 80029040
				v = @800D26C8+14 NOR @800D26C8+14
				80117490 = @800D26C8+18 & v
				800AEF4C = @800D26C8+3C & v
				# 80029084: restores context
				T7 = @800D26C8+3C
				GP = @800D26C8+70
				SP = @800D26C8+74
				S8 = @800D26C8+78
				RA = @800D26C8+7C
		i = @800D26C8+1C + 0x84
		mask <<= 1
	# 800290D0
	S0 = @800D26C8+40
	S1 = @800D26C8+44
	S2 = @800D26C8+48
	S3 = @800D26C8+4C
	S4 = @800D26C8+50
	S5 = @800D26C8+54
	S6 = @800D26C8+58
	S7 = @800D26C8+5C
	K0 = @800D26C8+68
	K1 = @800D26C8+6C
800290FC	run assigned context function A0 times
	v = @800D26C8+1C
	v+0 = A0
	v+44 = S0
	v+48 = S1
	v+4C = S2
	v+50 = S3
	v+54 = S4
	v+58 = S5
	v+5C = S6
	v+60 = S7
	v+6C = K0
	v+70 = K1
	v+74 = GP
	v+78 = SP
	v+7C = S8
	v+80 = RA
	goto @800D26C8+80
8002915C	unconditional return
80029170	read Aleck IO using handles A0 to manager at 80112968
	accepts: A0=p->Aleck hardware handles
	80112968+0 = @A0+8	# E0800000
	80112968+4 = @A0+8 + 2
	80112968+8 = @A0+8 + 4
	80112988[20:22] = 0
	80112988[22:24] = 0
	80112988[24:26] = 0
	80112988[26:28] = 0
	80112988[28:2A] = 0
	80112988[2A:2C] = 0
	80112988[2C:2E] = 0
	80112988[2E:30] = 0
	80112988[30:32] = 0
	80112968+C = @A0+8 + 0xA
	for i in range(4):
		v = @80112968+(i<<2)
		80112968+18[i<<1:i<<1 + 2] = ~(v[0:2])
		80112968+10[i<<1:i<<1 + 2] = ~(v[0:2])
80029244
	v = (80118300[2:4] - 80118378[2:4]) / @80118358
	return 0 - (v < 1)
80029288
800293D4	update 80112978 with current Aleck switch state
	for i in range(4):
		j = i << 1
		80112980[j:j+2] = 80112978[j:j+2]
		v = @80112968+(i<<2)
		80112978[j:j+2] = ~v
80029424
	call 800293D4()	# update 80112978 with current Aleck switch state
	call 80029498()
	call 800295F0()
	call 80029710()
	call 80029C78()	# unconditional return
	if not 80118300[6:8]:
		call 80029870()
		call 80029AE4()
	else:
		800ADC3C[0:2] = 0
		800B2680[0:2] = 0
80029498
	v = 80112978[4:6]
	if not v & 4:	# coin slot 1
		if 80118300[E:10] & 1:
			80118300[E:10] &= ~1
			if not 80118300[E:10]:
				call 8003A2D0(2)
			80112980[A:C] = 0
		# 800294E0
		if 80112980[A:C] < 2:
			80112980[A:C] = 0
			return
		elif 80112980[A:C] >= 0x1E:
			return
		80112980[A:C] = 0
		8007D8A8[0:2] += 1
		if 8007D8E4[0]:
			# 8002952C
			80118300[4:6] += 1
			80118318[0:2] += 1
			call 8003A6BC()
			80118310[0:2] = 1
			if 80118300[2:4] > 0x270F:
				80118300[2:4] = 0x270F
		else:
			# 80029584
			80118384 += 1
	else:
		# 8002959C
		80112980[A:C] += 1
		if 80112980[A:C] < 0x1F:
			return
		if not 80118300[E:10] & 1:	# set error after timeout!
			80118300[E:10] |= 1
			call 8003A2D0(1)
800295F0
	if not @800652A0 and 80112A2C[0]:
		v = 80112978[4:6]
		if (v & 0x10) and not (801182F0[4:6] & 2):	# service button
			801182F0[4:6] |= 2
			call 8003A760(1)
			800652A0 += 1
	else:
		# 80039664
		v &= v ^ 80112980[4:6]
		if not v & 0x10:	# service button pressed
			return
		if 8007D8E4[0]:
			80118300[4:6] += 1
			80118318[0:2] += 1
			call 8003A6BC()
			80118310[0:2] = 1
			if 80128300[2:4] > 0x270F:
				80128300[2:4] = 0x270F
		else:
			80118384 += 1
80029710
	if 80118300[6:8]:
		8006C890 = 0
		return
	v = 80112978[4:6]
	if not v & 0x20:	# test button
		8006C890 = 0
		return
	8006C890 += 1
	80118300+8 = 0
	if @8006C890 < 0xB5:
		return
	# 80029760
	8006C890 = 0
	80118388 = 0
	v = 80118378[2:4] - 80118330[6:8]
	if v < 0:
		v = 0
	i = v - 80118300[2:4]
	8007DAE8[0:2] += i / @80118358
	if (@80118370 & 0) or (@80118374 & 0x80):
		80118300[2:4] = v
		80118330[6:8] = 80118378[2:4] - v
	else:
		80118300[2:4] = i - (i / @80118358 * @80118358)
80029870
	800ADC3C[0:2] = 1
	# if @80112954 >= 7: return	# error mode #
	# call @8006A518(@80112954<<2)()
	if @80112954 in (0, 1):
		# 800298B0
		if not @800AEE78 and @800AEE7C < 0x5B:
			return
		v = 80118300[2:4] + 80118330[6:8]
		if v < 0x2328:
			if 801182FC[2:4] or 80118378[2:4] or 80118318[2:4]:
				return
			if call 80029244():
				return
		# 80029940
		v = @80118300 / @80118358
		i = 80112978[4:6] & (80112978[4:6] ^ 80112980[4:6])
		if not (@80118344 + @8011834C) and (i & 1):
			# 80029A88: pressed P1 Start
			80118300+8 = 0
			if v <= 0:
				return
			call 80029288(v)
		else:
			# 80029AA4
			i = (@80118344 + @8011834C) < 1
			i &= 0 < v
			if i:
				800ADC3C[0:2] = 0
	elif @80112954 == 3:
		# 800299A8
		if not @800AEE78 and @800AEE7C < 0x5B:
			return
		v = 80118300[2:4] + 80118330[6:8]
		if v < 0x2328:
			if 801182FC[2:4] or 80118378[2:4]:
				return
			if call 80029244():
				return
		# 80029A28
		v = @80118300 / @80118358
		i = 80112978[4:6] & (80112978[4:6] ^ 80112980[4:6])
		if not (@80118344 + @8011834C) and (i & 1):
			# 80029A88: pressed P1 Start
			80118300+8 = 0
			if v <= 0:
				return
			call 80029288(v)
		else:
			# 80029AA4
			i = (@80118344 + @8011834C) < 1
			i &= 0 < v
			if i:
				800ADC3C[0:2] = 0
	elif @80112954 == 4:
		# 80029ACC
		800ADC3C[0:2] = 0
80029AE4

80029C78	unconditional return
80029C80	V0 = nonzero if coin slot 1 triggered
	v = @80112970	# E0800004
	return v[0:2] & 4
80029C98	V0 = 1 service button pressed else -1
	v = @80112970	# E0800004
	i = ~v[0:2]
	v = i & (i ^ 80112990[2:4])
	if v & 0x10:
		return 1
	80112990[2:4] = i
	return -1
80029CDC	V0 = True if P1 start else False
	v = @80112970	# E0800004
	return v[0:2] & 1
80029CF0	redirect to 8003DBB0: add SI callback for 80066D94
80029D0C
	accepts: A0
	for i in range(8):
		SP[18] = 0	# not a typo; they set the same value 8 times!
	v = call 8003DD30()	# V0 = eeprom type or -1
	if v < 0:
		return
	for i in range(7):
		SP[17-i] = 0
	call 8003DCA8(0, SP+10, 8)	# write A2 bytes of data A1 to eeprom address A0
	call 8003DC20(0, SP+10, 8)	# read A2 bytes of data from eeprom address A0 to A1
	for i in (SP+10[0:8]):
		if not i:
			break
		call 80053F80(800AED38, 8006A558)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " ==  EEPROM ERROR == NOT INIT != 0 \n"
		call 80026234(0, 800AED38)	# NERFed! display string A1
	for i in range(7):
		SP[17-i] = 0xFF
	call 8003DCA8(0, SP+10, 8)	# write A2 bytes of data A1 to eeprom address A0
	call 8003DC20(0, SP+10, 8)	# read A2 bytes of data from eeprom address A0 to A1
	for i in (SP+10[0:8]):
		if i == 0xFF:
			break
		while True:
			call 80053F80(800AED38, 8006A580)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " ==  EEPROM ERROR == NOT INIT != 0xFF \n"
			call 80026234(0, 800AED38)	# NERFed! display string A1
	800D2750[0] = 0
	800D2750[3] = 6
	800D2750[2] = 4
	800D2750[10] = 4
	800D2750[1] = 3
	800D2750+8 = 0
	800D2750+C = 4
	800D2750[12] = call 8005C6F0()
	800D2750[13] = 0
	800D2750[14] = 0
	v, j = 0
	for i in range(0x18):
		v ^= 800D2750[i]
		v += i
	800D2750[14] = v
	call 80029EF4()
80029EF4
	if call 8003DD30() <= 0:	# V0 = eeprom type or -1
		return
	v = call 8005C6F0()
	if v < 0:
		v += 0xFF
	800D2750[14] = 0
	800D2750[12] = v
	v = 0
	for i in range(0x18):
		v ^= 800D2750[i]
		v += i
	800D2750[14] = v
	call 8003DCA8(0, 800D2750, 0x18)	# write A2 bytes of data A1 to eeprom address A0
80029F90
	if call 8003DD30() <= 0:	# V0 = eeprom type or -1
		return
	for i in range(3):
		call 8003DC20(0, SP+10, 0x18)	# read A2 bytes of data from eeprom address A0 to A1
		v = 0
		for j in range(0x18):
			v ^= SP[10+j]
			v += j
		if SP[24] == v:
			800D2750[0:18] = SP[10:18]
			call 8005C724(800D2750[12])	# 8007D880 = A0
			call 80029EF4()
	call 80029D0C(0)
	80128300[6:8] = 1
8002A080
8002A33C
	accepts: A0
	A0 &= 0xFFF
	if A0 < 0x401:
		v = A0 << 1
		return 80065AB4[v:v+2]
	if A0 < 0x801:
		v = (0x800 - A0) << 1
		return 80065AB4[v:v+2]
	if A0 < 0xC01:
		v = A0 << 1
		return 0 - 80064AB4[v:v+2]
	v = (0x1000 - A0) << 1
	return 0 - 80065AB4[v:v+2]
8002A3C4
8002A450
	80118300+8 = 0
	if 80118300[4:6] <= 0:
		return
	v = 80112978[0:2]	# DIP switches
	if v & 0x200:
		80118330[6:8] += (80118300[4:6] * 8011835C[0:2])
		if 80118330[6:8] > 0x270F:
			80118330[6:8] = 0x270F
	else:
		# 8002A4E4
		80118330[2:4] += (80118300[4:6] * 8011835C[0:2])
		if 80118330[2:4] > 0x270F:
			80118330[2:4] = 0x270F
	# 8002A530
	call 8003A79C(80118300[2:4])
	call 8003A3E0(80118330[6:8])
	80118300[4:6] = 0
	80118318[0:2] = 0
	call 8003A6BC()
	80118388[0:2] = 0
8002A580
8002A7E8
	80112954 = 1
	80066A54 = 0x14
	80117494 = 0
	call 8002685C()
	80118300[6:8] = 2
	call 800290FC(0x1E)	# run assigned context function A0 times
	call 8003A2D0(2)
	call 8003A7B8()	# call 80039A48(0xC)
	call 800290FC(1)	# run assigned context function A0 times
	v = 80112978[0:2]	# DIP switches
	if v & 1:
		80118300[6:8] = 2
		call 8003A358(1)
		call 80028DC8(0xA, 800308BC)	# link context function A1 in index A0: button switch test
		while True:
			call 800290FC(1)	# run assigned context function A0 times
	# 8002A8A4
	if v & 2:
		call 80029D0C(0)	# initializes eeprom?  Some kind of eeprom test
		80118300[6:8] = 1
	# 8002A8D0
	v = @80112970	# E0800004
	v = v[0:2]	# Aleck switches
	80118300[6:8] = True if v & 0x20 else False	# test button
	call 80029F90()
	call 800290FC(1)	# run assigned context function A0 times
	80112A2C[0] = 1
	if 80118300[6:8] == 1:
		call 8003A358(1)
		call 80028DC8(0xA, 8002E664)	# link context function A1 in index A0: test mode
		while call 80028F24(0xA):	# V0 = True if context function A0 linked else False
			call 8002651C()
			call 800290FC(1)	# run assigned context function A0 times
	else:
		call 8003A358(2)
	# 8002A9A4
	80118300[2:4] = 0
	call 8002DEA4()
	call 8003A358(2)
	call 8003A7B8()	# call 80039A48(0xC)
	call 8002A580()
	# 8002A9C8
	while True:
		call 8003CBE0(8006C8A0, 0)	# copy controller A1 button input to A0
		call 8002B370()	# toggle display of errors
		# if @80112954 < 8:
		#  call @8006A5C0+(@80112954<<2)()
		if @80112954 == 0:
			# 8002AA2C
			if 80118310[0:2] or 801182F0[E:10]:
				80118300+8 = 0
				call 80028EA8(0xA)	# stop and unlink registered context function A0
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				call 80028EA8(0xC)	# stop and unlink registered context function A0
				800ADC30[E] = 0
				80112954 = 1
			# 8002AA88
			80066A50[4:6] = 0x14
			8007D8E8 = 5
			8007D8EC = 5
			8007D8F0[0:2] = 7
			8007D8F0[2:4] = 7
			call 80031140(0, 0, 0, 0)
		elif @80112954 == 1:
			# 8002AAE0
			...
		elif @80112954 == 2:
			# 8002AFCC
			80118300+8 = 0
			if not call 80028F24(0xA):	# V0 = True if context function A0 linked else False
				call 8003A7B8()
				800ADC30[E] = 0
				call 80028DC8(0xA, 8002B430)	# link context function A1 in index A0: run context functions
				80118318[2:4] = 0
				call 8002A450()
				80112954 = 1
		elif @80112954 == 3:
			# 8002AE78
			80118300+8 = 0
			if not call 80028F24(0xA):	# V0 = True if context function A0 linked else False
				if 801182F0[6:8] & 2:
					call 80028EA8(0xA)	# stop and unlink registered context function A0
					call 80028EA8(0xB)	# stop and unlink registered context function A0
					call 80028DC8(0xA, 8002D4C0)	# link context function A1 in index A0
					call 8003A7B8()
					80112954 = 3
				elif 801182F0[6:8] & 4:
					# 8002AEE0
					call 80028EA8(0xA)	# stop and unlink registered context function A0
					call 80028EA8(0xB)	# stop and unlink registered context function A0
					call 80028DC8(0xA, 8002D840)	# link context function A1 in index A0
					call 8003A7B8()
					80112954 = 3
				elif 801182F0[6:8] & 8:
					# 8002AF30
					call 80028EA8(0xA)	# stop and unlink registered context function A0
					call 80028EA8(0xB)	# stop and unlink registered context function A0
					call 80028DC8(0xA, 8002DA34)	# link context function A1 in index A0
					call 8003A7B8()
					80112954 = 3
				else:
					# 8002AF80
					call 80028EA8(0xB)	# stop and unlink registered context function A0
					800ADC30[E] = 0
					call 80028DC8(0xA, 8002B430)	# link context function A1 in index A0: run context functions
					call 8003A7B8()
					80112954 = 1
			# 8002AFB4
			call 8002A450()
			call 8002A580()
		elif @80112954 == 4:
			# 8002B024
			80118300+8 = 0
			if 80118300[2:4] > 0 or 80118330[6:8] > 0:
				# 8002B054
				8011831C = 1
				call 80028EA8(0xA)	# stop and unlink registered context function A0
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				800ADC30[E] = 0
				call 8003A7D4()
				call 80028DC8(0xA, 8002CCC8)	# link context function A1 in index A0
				80112954 = 2
			elif not call 80028F24(0xA):
				# 8002B09C
				8011831C = 0
				call 80028DC8(0xA, 8002B478)	# link context function A1 in index A0
			elif @8011831C == 1:
				# 8002B130
				call 80028EA8(0xA)	# stop and unlink registered context function A0
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				800ADC30[E] = 0
				call 80028DC8(0xA, 8002CCC8)	# link context function A1 in index A0
				80112954 = 2
			elif @8011831C == 2:
				# 8002B16C
				call 80028EA8(0xA)	# stop and unlink registered context function A0
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				800ADC30[E] = 0
				call 80039A48(6)
				call 80028DC8(0xA, 8002BEB8)	# link context function A1 in index A0
				80112954 = 5
			elif @8011831C == 3:
				# 8002B1B0
				call 80028EA8(0xA)	# stop and unlink registered context function A0
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				800ADC30[E] = 0
				call 8003A7B8()
				call 80028DC8(0xA, 8002C27C)	# link context function A1 in index A0
				call 80039A48(7)
				80112954 = 6
			elif @8011831C == 4:
				# 8002B1F4
				call 80028EA8(0xA)	# stop and unlink registered context function A0
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				800ADC30[E] = 0
				call 8003A7B8()
				call 80028DC8(0xA, 8002C648)	# link context function A1 in index A0
				call 80039A48(0xD)
				80112954 = 7
		elif @80112954 == 5:
			# 8002B248
			80118300+8 = 0
			if not call 80028F24(0xA):	# V0 = True if context function A0 linked else False
				80118318[2:4] = 0
				call 8003A7B8()
				80112954 = 1
		elif @80112954 == 6:
			# 8002B280
			80118300+8 = 0
			if not call 80028F24(0xA):	# V0 = True if context function A0 linked else False
				80118318[2:4] = 0
				call 8003A7B8()
				80112954 = 1
		elif @80112954 == 7:
			# 8002B2B8
			80118300+8 = 0
			if not call 80028F24(0xA):	# V0 = True if context function A0 linked else False
				80118318[2:4] = 0
				call 8003A7B8()
				80112954 = 1
		else:
			# 8002B2F0
			80118300+8 = 0
			call 80053F80(800AED38, 8006A5A8, @80112954)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "error mode No=%d\n"
			call 80026234(0, 800AED38)	# NERFed! display string A1
		# 8002B32C: pointless jump to next opcode
		call 8005C6F0()
		if not 80118300[C:E]:	# major error code
			pass
		call 8002651C()
		call 800290FC(1)	# run assigned context function A0 times
8002B370	toggle display of errors
	if not @8006641C:
		if not 80118300[C:E]:	# no major error code detected
			return
		call 80028EE0(0xA)	# set context flag A0 at 800AEF4C
		call 80028EE0(0xB)	# set context flag A0 at 800AEF4C
		call 80028EE0(0xC)	# set context flag A0 at 800AEF4C
		call 80028DC8(0xF, 80030C28)	# link context function A1 in index A0: error display
		8006641C = 1
	else:
		# 8002B3DC
		if 80118300[C:E]:	# continue displaying major error code
			return
		call 80028EA8(0xF)	# stop and unlink registered context function A0
		800B1A60 = 0
		call 80028F00(0xA)	# unset context flag A0 at 800AEF4C
		call 80028F00(0xB)	# unset context flag A0 at 800AEF4C
		call 80028F00(0xC)	# unset context flag A0 at 800AEF4C
		8006641C = 0
8002B430	run context functions
	while True:
		call 800290FC(1)	# run assigned context function A0 times
8002B478
8002BEB8
8002C27C

8002C648

8002CA14
8002CCC8
	SP[10] = 3
	SP[11] = 5
	SP[18:1F] = 8006A654[0:7]	# 00010204060809
	SP+24 = 0
	SP+28 = 0
	SP+30 = 0
	SP+28 = 0	# not a typo
	v = 80112978[0:2]	# DIP switches
	if not (v & 0x100) or not 800D2750[3]:
		80118318[0:2] = 0
		return
	# 8002CD68
	...
	# 8002CE18
	while True:
		...
		# 8002CFA0
		SP+34 = @80118360
		call 80053F80(800AED38, 8006A65C, @SP+34)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " BIG PST = %d\n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		call 80053F80(800AED38, 8006A66C, 801182F0[A:C])	# V0 = p->C-string A1 expanded and Null-terminated to A0: " SLOT_TYPE = %x\n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		# 8002D004
		...
		# 8002D21C
		call 80039A48(5)
		call 80053F80(800AED38, 8006A680)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " GET SMALL \n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		# 8002D248
		...
		# 8002D2C0
		call 80053F80(800AED38, 8006A690, @SP+20)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " GET SMALL \n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		SP+24 = 4
		goto 8002D390
		# 8002D2F4
		...
		# 8002D390
		call 80031140(0, 0, 0, 0)
		call 80053F80(800AED38, 8006A6A0, @SP+2C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Service Game Last = %d\n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		80064FF4 = 0xFF
		80064FF0 = 0xFF
		80064FEC = 0xFF
		SP+30 += 1
		call 800290FC(1)	# run assigned context function A0 times
8002D424	display "+ CT START +\n" 60 times
	for i in range(0x3D):
		call 80053F80(800AED38, 8006A6D0)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "+ CT START +\n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		call 800290FC(1)	# run assigned context function A0 times
	call 80028EA8(0xB)	# stop and unlink registered context function A0
8002D4C0
	SP+10 = 0
	SP+14 = 0
	SP+18 = 0
	SP+1C = 0
	call 80028DC8(0xB, 8002DC24)	# link context function A1 in index A0: display "++ BIG START ++\n" 60 times
	while True:
		# if @SP+10 < 8: call @8006A6E0+(@SP+10<<2)()
		if @SP+10 == 0:
			# 8002D534
			if not call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				8006C8A8 = 0
				call 80028DC8(0xB, 8002DCC0)	# link context function A1 in index A0: display "BIG PLAY!! \n"
				SP+1C = 0
				SP+18 = 1
			if 801182F0[E:10] == 3:
				call 8003A7B8()
		elif @SP+10 == 1:
			# 8002D58C
			v = 801182F0[C:E]
			if v & 2:
				SP+10 =2
		elif @SP+10 == 2:
			# 8002D5B4
			v = 801182F0[C:E]
			if v & 2:
				# 8002D608
				if 801182F0[E:10] == 3:
					call 8003A7B8()
			else:
				# 8002D5CC
				801182F0[4:6] &= 2	# untoggle service button pressed flag
				801182F0[6:8] &= 2
				SP+10 += 1
		elif @SP+10 == 3:
			# 8002D62C
			if 801182F0[4:6] & 0x20:
				801182F0[4:6] &= 0x20
				801182F0[6:8] &= 0x20
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				SP+14 = 0
				call 80028DC8(0xB, 8002D424)	# link context function A1 in index A0: display "+ CT START +\n" 60 times
				SP+10 += 1
			else:
				# 8002D69C
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				call 80028DC8(0xB, 8002DD3C)	# link context function A1 in index A0: run context function 0x1F times
				SP+14 = 2
				SP+10 = 7
		elif @SP+10 == 4:
			# 8002D6CC
			if call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				# 8002D714
				if 801182F0[E:10] == 3:
					call 8003A7B8()
			else:
				# 8002D6DC
				SP+14 = 1
				8006C8A8 = 2
				call 80028DC8(0xB, 8002DCC0)	# link context function A1 in index A0: display "BIG PLAY!! \n"
				SP+10 += 1
		elif @SP+10 == 5:
			# 8002D738
			if 801182F0[C:E] & 0x20:
				call 8003A7B8()
				SP+1C = 0
				SP+10 += 1
		elif @SP+10 == 6:
			# 8002D774
			if not 801182F0[C:E] & 0x20:
				call 80028EA8(0xB)	# stop and unlink registered context function A0
				call 80028DC8(0xB, 8002DD3C)	# link context function A1 in index A0: run context function 0x1F times
				SP+14 = 2
				SP+10 += 1
			# 8002D7BC
			if 801182F0[E:10] == 3:
				call 8003A7B8()
		elif @SP+10 == 7:
			# 8002D7E0
			if not call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				80118318[2:4] = 0
				return
		# 8002D80C
		SP+18 += 1
		call 800290FC(1)	# run assigned context function A0 times
8002D840
	SP+10 = 0
	SP+14 = 0
	SP+18 = 0
	call 80028DC8(0xB, 8002DC24)	# link context function A1 in index A0: display "++ BIG START ++\n" 60 times
	# 8002D87C
	while True:
		if @SP+10 == 0:
			# 8002D8C8
			if not call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				8006C8A8 = 1
				call 80028DC8(0xB, 8002DCC0)	# link context function A1 in index A0: display "BIG PLAY!! \n"
				SP+10 += 1
			# 8002D904
			if 801182F0[E:10] == 3:
				call 8003A7B8()
		elif @SP+10 == 1:
			# 8002D928
			if 801182F0[C:E] & 4:
				SP+10 = 2
		elif @SP+10 == 2:
			# 8002D950
			if 801182F0[C:E] & 4:
				# 8002D9B4
				if 801182F0[E:10] == 3:
					call 8003A7B8()
			else:
				# 8002D968
				801182F0[4:6] &= 4
				801182F0[6:8] &= 4
				call 80028DC8(0xB, 8002DD3C)	# link context function A1 in index A0: run context function 0x1F times
				SP+10 += 1
		elif @SP+10 == 3:
			# 8002D9D8
			if not call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				call 8003A7B8()
				return
		# 8002DA00
		SP+14 += 1
		call 800290FC(1)	# run assigned context function A0 times
8002DA34
	SP+10 = 0
	SP+14 = 0
	call 80028DC8(0xB, 8002DC24)	# link context function A1 in index A0: display "++ BIG START ++\n" 60 times
	# 8002DA6C
	while True:
		if @SP+10 == 0:
			# 8002DAB8
			if not call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				8006C8A8 = 1
				call 80028DC8(0xB, 8002DCC0)	# link context function A1 in index A0: display "BIG PLAY!! \n"
				SP+10 += 1
			# 8002DAF4
			if 801182F0[E:10] == 3:
				call 8003A7B8()
		elif @SP+10 == 1:
			# 8002DB18
			if 801182F0[C:E] & 8:
				SP+10 = 2
		elif @SP+10 == 2:
			# 8002DB40
			if 801182F0[C:E] & 8:
				if 801182F0[E:10] == 3:
					call 8003A7B8()
			else:
				801182F0[4:6] & 8
				801182F0[6:8] & 8
				call 80028DC8(0xB, 8002DD3C)	# link context function A1 in index A0: run context function 0x1F times
				SP+10 += 1
		elif @SP+10 == 3:
			# 8002DBC8
			if not call 80028F24(0xB):	# V0 = True if context function A0 linked else False
				call 8003A7B8()
				return
		# 8002DBF0
		SP+14 += 1
		call 800290FC(1)	# run assigned context function A0 times
8002DC24	display "++ BIG START ++\n" 60 times
	for i in range(0x3D):
		call 80053F80(800AED38, 8006A700)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "++ BIG START ++\n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		call 800290FC(1)	# run assigned context function A0 times
	call 80028EA8(0xB)	# stop and unlink registered context function A0
8002DCC0	display "BIG PLAY!! \n"
	i = 0
	while True:
		i += 1
		call 80053F80(800AED38, 8006A714)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "BIG PLAY!! \n"
		call 80026234(1, 800AED38)	# NERFed! display string A1
		call 800290FC(1)	# run assigned context function A0 times
8002DD3C	run context function 0x1F times
	for i in range(0x1F):
		call 800290FC(1)	# run assigned context function A0 times
8002DDAC	V0 = p->string A0 for DIP switch index A1
	accepts: A0=p->target, A1=index
	if A1+1 < 0xA:
		return call 80053F80(A0, 8006A724, A1+1)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "S-0%d"
	else:
		return call 80053F80(A0, 8006A72C, A1+1)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "S-%d"
8002DE38	V0 = p->string A0 "On" if A1 else "Off"
	accepts: A0=p->target, A1=state
	if A1:
		return call 80053F80(A0, 8006A734)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "On"
	else:
		return call 80053F80(A0, 8006A738)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Off"
8002DEA4
	...
	# 8002E0D0
	i = 0
	while not 801182F0[A:C]:
		call 800290FC(1)	# run assigned context function A0 times
		i += 1
		8007D8E8 = 3
		call 80053F80(8007D900, 8006A73C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "----"
		8007D8EC = 3
		call 80053F80(8007D905, 8006A73C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "----"
		# 8002E140: this looks like a programming error.  When the counter runs out nothing happens.
		if i >= 0x12D:
			pass
	# 8002E158
	# 8002E15C
	while 800ADE10[6:8] > 0:
		8007D8E8 = 3
		call 80053F80(8007D900, 8006A744)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "=--="
		8007D8EC = 3
		call 80053F80(8007D905, 8006A744)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "=--="
		call 800290FC(1)	# run assigned context function A0 times
	# 8002E1C4
	# 8002E1C8
	for i in range(0x78):
		8007D8E8 = 3
		call 80053F80(8007D900, 8006A74C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "===="
		8007D8EC = 3
		call 80053F80(8007D905, 8006A74C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "===="
		call 800290FC(1)	# run assigned context function A0 times
	# 8002E240
	...
8002E664	test mode [nonterminating?]
	...
	# 8002EA64
	while True:
		v = 80112978[4:6]	# Aleck switches
		if (v & 1) and not ((v & 1) & 80112980[4:6]):
			# 8002EAB0: pressed P1 Start
			SP+18 += 1
			v = 80112978[0:2]	# DIP switches
			if v & 0x100:
				if @SP+18 >= 0x10:
					SP+18 = 0
			else:
				if @SP+18 >= 0xF:
					SP+18 = 0
		# 8002EB08
		SP+1C = 0
		if (v & 2) and not ((v & 2) & 80112980[4:6]):
			# 8002EB48: pressed P2 Start
			SP+1C = 1
		# 8002EB50
		call 800312C8()
		# if @SP+18 >= 0x10: return
		# call @8006A7F0[@SP+18 << 2]()
		if @SP+18 == 0:
			# 8002EB8C
			...
			# 8002ECEC
			call 80026234(1, 8007D900)	# NERFed! display string A1
			call 80053F80(800AED38, 8006A754, 8007D8F0[2:4])	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  %4d\n"
			call 80026234(1, 800AED38)	# NERFed! display string A1
		elif @SP+18 == 1:
			# 8002ED34
			...
		elif @SP+18 == 2:
			# 8002EFB4
			...
		elif @SP+18 == 3:
			# 8002F118
			...
		elif @SP+18 == 4:
			# 8002F270
			...
		elif @SP+18 == 5:
			# 8002F3C8
			...
		elif @SP+18 == 6:
			# 8002F520
			...
		elif @SP+18 == 7:
			# 8002F678
			...
		elif @SP+18 == 8:
			# 8002F7D0
			...
		elif @SP+18 == 9:
			# 8002F934
			...
		elif @SP+18 == 0xA:
			# 8002FA8C
			...
		elif @SP+18 == 0xB:
			# 8002FBE4
			...
		elif @SP+18 == 0xC:
			# 8002FD48
			...
		elif @SP+18 == 0xD:
			# 8002FEA0
			...
		elif @SP+18 == 0xE:
			# 8002FFF8
			...
		elif @SP+18 == 0xF:
			# 80030150
			...
		else:
			# 8003029C
			SP+18 = 0
		# 800302A4
		call 80053F80(800AED38, 8006A76C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " ----- Test Mode -----\n"
		call 80026234(0, 800AED38)	# NERFed! display string A1
		v = @SP+18 << 3
		SP+10 = @v+18
		SP+14 = @v+1C
		call 80053F80(800AED38, 8006A784, @SP+18)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Mode Select No=%2d , Mode Count=%llu\n"
		call 80026234(0, 800AED38)	# NERFed! display string A1
		if call 8003DD30() <= 0:	# V0 = eeprom type or -1
			call 80053F80(800AED38, 8006A7AC)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " == EEPROM ERROR == \n"
			call 80026234(0, 800AED38)	# NERFed! display string A1
		elif call 8003DD30() == 1:	# V0 = eeprom type or -1
			call 80053F80(800AED38, 8006A7C4)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  EEPROM = 4K Bit \n"
			call 80026234(0, 800AED38)	# NERFed! display string A1
		elif call 8003DD30() == 2:	# V0 = eeprom type or -1
			call 80053F80(800AED38, 8006A7D8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  EEPROM = 16K Bit \n"
			call 80026234(0, 800AED38)	# NERFed! display string A1
		# 800303CC
		call 80031094(2)	# NERFed!; SP+8 = A0
		v = 80112978[4:6]	# Aleck switches
		if v & 0x20 and not (v & 0x20 & 80112980[4:6]):	# test button pressed
			800D2750[0] = SP[27]
			800D2750[1] = SP[2F]
			800D2750[2] = SP[27]
			800D2758 = 0
			800D275C = 0
			if @SP+38 or @SP+3C:
				800D2758 |= 0
				800D275C |= 1
			# 8003049C
			if @SP+40 or @SP+44:
				800D2758 |= 0
				800D275C |= 2
			# 800304EC
			if @SP+48 or @SP+4C:
				800D2758 |= 0
				800D275C |= 4
			# 8003053C
			if @SP+50 or @SP+54:
				800D2758 |= 0
				800D275C |= 8
			# 8003058C
			if @SP+58 or @SP+5C:
				800D2758 |= 0
				800D275C |= 0x10
			# 800305DC
			800D2760[0] = SP[67]
			if @SP+68 or @SP+6C:
				800D2758 |= 0
				800D275C |= 0x20
			# 80030638
			if @SP+70 or @SP+74:
				800D2758 |= 0
				800D275C |= 0x40
			# 80030688
			800D2760[1] = SP[7F]
			if @SP+80 or @SP+84:
				800D2758 |= 0
				800D275C |= 0x80
			# 800306E4
			if @SP+88 or @SP+8C:
				800D2758 |= 0
				800D275C |= 0x100
			# 80030734
			if @SP+90 or @SP+94:
				800D2758 |= 0
				800D275C |= 0x200
			# 80030784
			800D2750[3] = SP[9F]
			if not (800D2758 & 0) and not (800D275C & 1) ...
				and not (800D2758 & 0) and not (800D275C & 2) ...
				and not (800D2758 & 0) and not (800D275C & 4) ...
				and not (800D2758 & 0) and not (800D275C & 0x100):
					800D2758 |= 0
					800D275C |= 1
			# 80030870
			80118300[6:8] = 0
			call 80029EF4()
		# 80030884
		call 80031140(0, 0, 0, 0)
		call 800290FC(1)	# run assigned context function A0 times
800308BC	button switch test [nonterminating]
	i, j = 0, 0
	8007D8E8 = 9
	8007D8EC = 9
	8007D900[0] = 0
	8007D900[5] = 0
	while True:
		# 8003090C
		if i == 0:
			if 8007D900[0] == 2:
				pass
			i = 1
			call 800290FC(1)	# run assigned context function A0 times
			continue
		if i != 1:
			pass
		call 80053F80(800AED38, 8006A830)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "BUTTON SWITCH TEST "
		call 80026234(j, 800AED38)	# NERFed! display string A1
		8007D8E8 = 3
		call 80053F80(8007D900, 8006A844)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " SCH"
		8007D8EC = 3
		call 80053F80(8007D905, 8006A634)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "    "
		# 800309B4
		v = 80112978[4:6]	# Aleck switches
		if v & 0x10:	# service button
			call 80053F80(800AED38, 8006A84C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "ON = SERVICE SWITCH "
			call 80026234(j, 800AED38)	# NERFed! display string A1
			8007D8EC = 3
			call 80053F80(8007D905, 8006A864)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " C-1"
		elif v & 2:	# P2 start
			# 80030A20
			call 80053F80(800AED38, 8006A86C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "ON = CREDIT TRANCE "
			call 80026234(j, 800AED38)	# NERFed! display string A1
			8007D8EC = 3
			call 80053F80(8007D905, 8006A880)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " C-2"
		elif v & 1:	# P1 start
			# 80030A80
			call 80053F80(800AED38, 8006A888)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "ON = CREDIT CREAR "
			call 80026234(j, 800AED38)	# NERFed! display string A1
			8007D8EC = 3
			call 80053F80(8007D905, 8006A89C)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " C-3"
		elif v & 4:	# coin slot 1
			# 80030AE0
			call 80053F80(800AED38, 8006A8A4)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "ON = COIN IN "
			call 80026234(j, 800AED38)	# NERFed! display string A1
			8007D8EC = 3
			call 80053F80(8007D905, 8006A8B4)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " C-4"
		elif v & 0x20:	# test button
			# 80030B40
			call 80053F80(800AED38, 8006A8BC)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "ON = TEST SWITCH "
			call 80026234(j, 800AED38)	# NERFed! display string A1
			8007D8EC = 3
			call 80053F80(8007D905, 8006A8D0)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " C-5"
		# 80030B98
		800ADC3C[0:2] = 0
		800B2680[0:2] = 0
		if v & 2:
			800B2680[0:2] = 1
		if v & 1:
			800ADC3C[0:2] = 1
		call 80031140(1, 0x14, 0, 0)
		# 80030C04
		call 800290FC(1)	# run assigned context function A0 times
80030C28	error display [nonterminating?]
	i = 0
	800B1A60 = 1
	# 80030C58
	while True:
		call 80053F80(800AED38, 8006A8D8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "ERROR "
		call 80026234(i, 800AED38)	# NERFed! display string A1
		801129A0 = 3
		call 80053F80(801129B8, 8006A8E0)	# V0 = p->C-string A1 expanded and Null-terminated to A0: " Err"
		801129A4 = 3
		call 80053F80(801129BD, 8006A634)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "    "
		v = 80118300[C:E]	# major error code
		if v & 1:
			# 80030CD8
			call 80053F80(800AED38, 8006A8E8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = CE ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A900)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  CE"
		elif v & 2:
			# 80030D24
			call 80053F80(800AED38, 8006A908)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = CJ ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A920)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  CJ"
		elif v & 4:
			# 80030D8C
			call 80053F80(800AED38, 8006A928)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = CO ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A940)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  CO"
		elif v & 8:
			# 80030DF4
			call 80053F80(800AED38, 8006A948)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = CR ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A960)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  Cr"
		elif v & 0x10:
			# 80030E5C
			call 80053F80(800AED38, 8006A968)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = HE ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A980)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  HE"
		elif v & 0x20:
			# 80030EC4
			call 80053F80(800AED38, 8006A988)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = HJ ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A9A0)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  HJ"
		elif v & 0x40:
			# 80030F2C
			call 80053F80(800AED38, 8006A9A8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = EE ERROR "
			call 80026234(i, 800AED38)	# NERFed! display string A1
			801129A4 = 3
			call 80053F80(801129BD, 8006A9C0)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  EE"
		elif v & 0x80:
			# 80030F94
			if 80118300[E:10] & 1:
				call 80053F80(800AED38, 8006A9C8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = 6E_COIN ERROR "
				call 80026234(i, 800AED38)	# NERFed! display string A1
				801129A4 = 3
				call 80053F80(801129BD, 8006A9E8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  6E"
			if 80118300[E:10] & 2:
				call 80053F80(800AED38, 8006A9F0)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "Aleck Error = 6E_FULL ERROR "
				call 80026234(i, 800AED38)	# NERFed! display string A1
				801129A4 = 3
				call 80053F80(801129BD, 8006A9E8)	# V0 = p->C-string A1 expanded and Null-terminated to A0: "  6E"
		# 80031070
		call 800290FC(1)	# run assigned context function A0 times
80031094	NERFed!; SP+8 = A0
800310B4	NERFed!; SP+8 = A0; unlinked
800310D4	NERFed!; SP+8 = A0; unlinked
800310F4	NERFed!; SP+8 = A0; unlinked
80031114	NERFed!; SP+8 = A0; unlinked
80031140
800312C8
80031374
80031440
8003152C	redirect to 8003C900: load A2 bytes from hardware A0 to rdram A1
	accepts: A0, A1, A2
	call 8003C900(A0, A1, A2)	# load A2 bytes from hardware A0 to rdram A1
8003156C

800341E0	create memory manager for A1 bytes at A0
	accepts: A0=p->target, A1=size
	A0+10 = A0
	A0+0 = A0
	A0+4 = 0
	call 80034248(A0, A0+20, A1 - 0x20)
80034248	initialize memory manager entries for data A1 using table A0
	accepts: A0=p->table, A1=p->data, A2=length of data
	A1+0 = ~A1
	A1+4 = A2 >> 4
	call 800343EC(A0, A1+10)	# initialize memory manager entries for data A1 using table A0
800342B4	also allocate entry of size A1 in memory manager A0?
	accepts: A0=p->table, A1=size
800343EC	initialize memory manager entries for data A1 using table A0
	accepts: A0=p->table, A1=p->data
800345DC	allocate entry of size A1 in memory manager A0
	accepts: A0=p->table, A1=size
8003473C
800347D4
80034880	V0 = p->loaded and decompressed file from hardware A0 using method A2, opt. writing size to A1
	accepts: A0=hardware offset, A1=p->length or None, A2=allocation method (0, 1)
	SP+130 = SP+30
	call 8003152C(A0, SP+30, 0x100)	# redirect to 8003C900: load A2 bytes from hardware A0 to rdram A1
	A0 += 0x100
	SP+1C = SP[30]
	SP+1C |= SP[31] << 8
	SP+1C |= SP[32] << 16
	SP+1C |= SP[33] << 24
	if A2:
		# 80034944
		SP+14 = call 800342B4(8007DB30, @SP+1C)
	else:
		# 8003495C
		SP+14 = call 800345DC(8007DB30, @SP+1C)	# allocate entry of size A1 in memory manager A0
	# 80034970
	if not @SP+14:
		return 0
	SP+10 = @SP+14
	SP+28 = 0
	SP+2C = 0
	i, j = 0, 4
	# 8003499C
	while i < @SP+1C:
		if not @SP+2C:
			j += 1
			SP+28 = SP[30+(j&0xFF)]
			if not j & 0xFF:
				call 8003152C(A0, SP+30, 0x100)	# redirect to 8003C900: load A2 bytes from hardware A0 to rdram A1
				A0 += 0x100
				SP+2C = 8
		# 80034A10
		SP+2C -= 1
		SP+28 <<= 1
		if not @SP+28 & 0x100:
			# 80034A3C
			j += 1
			SP+134 = SP[30+(j&0xFF)]
			if not j & 0xFF:
				call 8003152C(A0, SP+30, 0x100)	# redirect to 8003C900: load A2 bytes from hardware A0 to rdram A1
				A0 += 0x100
			j += 1
			SP+135 = SP[30+(j&0xFF)]
			if not j & 0xFF:
				call 8003152C(A0, SP+30, 0x100)	# redirect to 8003C900: load A2 bytes from hardware A0 to rdram A1
				A0 += 0x100
			SP+20 = (SP[134] >> 4) + 3
			SP+24 = (SP[134] & 0xF) << 8
			SP+24 |= SP[135]
			SP+24 += 1
			v = @SP+10
			for k in range(@SP+20):
				v[i] = v[i - @SP+24]
				i += 1
		else:
			# 80034B64
			v = @SP+10
			v[i] = SP[30+(j&0xFF)]
			i += 1
			j += 1
			if not j & 0xFF:
				call 8003152C(A0, SP+30, 0x100)	# redirect to 8003C900: load A2 bytes from hardware A0 to rdram A1
				A0 += 0x100
	# 80034BC0
	if A1:
		A1+0 = @SP+1C
	return @SP+14
80034BFC
80034F08	V0 = p->loaded and decompressed file from hardware A0 using method 0, opt. writing size to A1
	accepts: A0=hardware offset, A1=p->target or None
	return call 80034880(A0, A1, 0)	# V0 = p->loaded and decompressed file from hardware A0 using method A2, opt. writing size to A1
80034F50	V0 = p->loaded and decompressed file from hardware A0 using method 1, opt. writing size to A1
	accepts: A0=hardware offset, A1=p->target or None
	return call 80034880(A0, A1, 1)	# V0 = p->loaded and decompressed file from hardware A0 using method A2, opt. writing size to A1
80034FA0
8003501C

80035474
800354E8
800355AC
800356D0	V0 = A0 + 1
80035700	V0 = 16bit random number
	v = @8006C9F8 * 2100005341
	v += 1
	8006C9F8 = v
	return (v >> 0x10) & 0xFFFF
80035758

800359DC	write ASCII string A1 converted to character mappings to A0 using mode A2
	accepts: A0=p->target, A1=p->string, A2=mode
	for i in range(4):
		v = A1[0]
		A1 += 1
		if not i:
			A1 -= 1
		v = 80066994[v] if v < 0x80 else 0
		if A2:
			if A2[0]:
				v |= 0x80
			A2 += 1
		A0[0] = v & 0xFF
		A0 += 1
80035ADC
	...
			# 80035EB8
			v = @SP+3C
			SP+2C = @v+8 * 0x66666667
			v = (@SP+2C >> 5) - (@v+8 >> 31)
			v &= 3
			call 800359DC(@SP+38, @800667BC+(v<<2), 0)	# write ASCII string A1 converted to character mappings to A0 using mode A2: ("Slot", "In", "Coin", "PLAY")[v]
		else:
			# 80035F10
			call 800359DC(@SP+38, 8006AA48, 0)	# write ASCII string A1 converted to character mappings to A0 using mode A2: "    "
		# 80035F30
		...
	# 800360C4
	...
8003659C

800374F0
	call 8005C620(8006C8C0, 0, 0x2C)	# V0=p->A2 bytes at A0 filled with value A1
	call 8005C620(8006C8F0, 0, 0x2C)	# V0=p->A2 bytes at A0 filled with value A1
	call 8005C620(8006C99C, 0, 8)	# V0=p->A2 bytes at A0 filled with value A1
	call 8005C620(8006C928, 0, 0x38)	# V0=p->A2 bytes at A0 filled with value A1
	call 8005C620(8006C9A8, 0, 0x50)	# V0=p->A2 bytes at A0 filled with value A1
	call 8005C620(8006CA08, 0, 0xC)	# V0=p->A2 bytes at A0 filled with value A1
	8006C944[2:4] = 1
	u, l = call 80054E80()	# V0, V1 = Count plus timer base (@800AEE70, @800AEE78)
	8006C9F8 = l	# set seed
	for i in range(2):
		for j in range(0xA):
			SP[20+j] = j
		# 800375F0
		for j in range(1, 4):
			k = call 80035700()	# V0 = 16bit random number
			k *= 0xA - j
			k >>= 0x10
			v = i * 0x1C
			8006C93C[v + j] = SP[20 + k]
			SP[20 + k] = SP[29 - j]
	# 800376C0
	call 80053F54(8006C960, 8006C928, 0x38)	# copy A2 bytes from A1 to A0
	800667A0 = 0
800376F4
	if @800667A0:
		call 800374F0()
	8006C8F4 = 0
	8006C8F0 = 0
	8006C8C4 = 0
	8006C8C0 = 0
	call 800377C8()
80037754
	accepts: A0=flags
	80112994[2:4] &= ~(A0 & 0xFFFF)
80037790
	accepts: A0=flags
	80112994[2:4] |= A0
800377C8
	if @800667A0:
		call 800374F0()
	if @800B1A60:
		8006C998 = 8006C960
		8006C91C = 8006C8F0
		8006C920 = 801129A0
	else:
		8006C998 = 8006C928
		8006C91C = 8006C8C0
		8006C920 = 8007D8E8
	call 80036ADC()
	call 80036CE8()
	call 80037790(3)
	if @800667B4:
		call 80037754(1)
	for i in range(0x50):
		if 8006C9A8[i]:
			call 80037754(4)
		else:
			call 80037790(4)
		call 80037790(8)
		call 8003748C()
		call 800373F4()
		call 80037754(8)
		call 8003748C()
		call 800373F4()
	# 8003792C
	call 80037790(0xC)
	call 8003748C()
	call 800373F4()
	call 80037754(2)
	call 8003748C()
	call 800373F4()
	call 80037790(2)
	call 8003748C()
	800667B4 = 0
	return 0
80037990
	accepts: A0=p->Aleck hardware handles
	8011831C+0 = 0
	8011831C+4 = 0
	8011831C+8 = 0
	8011831C+C = 0
	8011831C+10 = 0
	8011831C[14:18] = (0x20, 0x20, 0x20, 0x20)
	8011831C[1A:1C] = 0
	8011831C[1C:1E] = 0
	8011831C+20 = 0
	8011831C+24 = 0
	8011831C+28 = 0
	8011831C+2C = 0
	8011831C+30 = 0
	8011831C+34 = 0
	8011831C+38 = 0
	8011831C+3C = 1.0
	8011831C[40:42] = 0
	8011831C+44 = -1
	8011831C+48 = -1
	8011831C+4C = -1
	8011831C[50:52] = 0
	8011831C+54 = 0
	8011831C+58 = 0
	8011831C[5E:60] = 0
	8011831C+64 = 0
	8011831C+68 = 0
	8011831C+6C = 0
	801182F0+0 = 0
	801182F0[4:6] = 0
	801182F0[6:8] = 0
	801182F0[8:A] = 0
	801182F0[A:C] = 0
	801182F0[C:E] = 0
	801182F0[E:10] = 0
	801182F0[10:12] = 0
	801182F0[12:14] = 0
	801182F0[14:16] = 0
	801182F0[18:1A] = 0
	801182F0[1C:1E] = 0
	801182F0[1E:20] = 0
	801182F0[20:22] = 0
	801182F0[22:24] = 0
	801182F0[26:28] = 0
	801182F0[28:2A] = 0
	801182F0[2A:2C] = 0
	# 80037B34
	v = @A0+8	# E0800000
	801182E8 = v+8
	8007D8B0+0 = 0
	8007D8B0[4:6] = 0
	8007D8B0[6:8] = 0
	8007D8B0[8:A] = 0
	8007D8B0[A:C] = 0
	801182EC = v+A
	800ADE10+0 = 0
	800ADE10[4:6] = 0
	800ADE10[6:8] = 0
	800ADE10[8:A] = 0
	800ADE10[A:C] = 0
	800D269C[0:2] = 0
	call 80037F00()
80037BBC
	if @80118344 <= 0:
		return
	if call 80039B30():
		return
	80118344 = 0
	800AEE78 = 0
	800AEE7C = 0
80037C18
	if not 80118310[0:2]:
		if not 801182F0[C:E] & 0x800:
			call 80039A48(8)
	elif 801182F0[C:E] & 0x800:
		call 80039A48(9)
80037C70
80037F00
	v = @801182EC	# E080000A
	v[0:2] = (800D269C[0:2] & 0xFF00) | 80112997[0]
80037F28
	while True:
		u1, l1 = call 80054E80()	# V0, V1 = Count plus timer base (@800AEE70, @800AEE78)
		v = @801182E8	# E0800008
		8007D8B8[0:2] = v[1]
		while True:
			u2, l2 = call 80054E80()	# V0, V1 = Count plus timer base (@800AEE70, @800AEE78)
			u2 -= u1 - (l2 < l1)
			l2 -= l1
			if u2 or l2 >= 0x578:
				break
		if 8007D8B8[0:2] == v[1]:
			break
	# 80037FA8
	80117494 = @8007D8B0
	if v[1] == 0xFF:
		8007D8B0+0 = 0xB
	v = @8007D8B0
	if v < 0xC:
		# v <<= 2
		# call @8006AAC8+v()
		if v == 0:
			# 80037FF0
			if 8007D8B8[0:2] != 0xFE:
				80118300[0:2] = 0
			elif 8007D8B8[2:4] == 8007D8B8[0:2]:
				80118300[0:2] = 0
			else:
				800D269C[0:2] = 0xFC00
				80066B80+0 = 0
				8007D8B0+0 += 1
			8007D8B8[2:4] = 8007D8B8[0:2]
		elif v == 1:
			# 80038040
			if not 8007D8B8[0:2] and 8007D8B8[2:4]:
				8007D8B0 += 1
				800D269C[0:2] = 0
				80066B80+0 = 0
			8007D8B8[2:4] = 8007D8B8[0:2]
		elif v == 2:
			# 80038088
			if 8007D8B8[0:2] and 8007D8B8[0:2] != 8007D8B8[2:4]:
				8007D8B4[0:2] = 8007D8B8[0:2]
				800D269C[0:2] = 0xFC00
				80066B80+0 = 0
				8007D8B0+0 += 1
			8007D8B8[2:4] = 8007D8B8[0:2]
		elif v == 3:
			# 800380D4
			if not 8007D8B8[0:2] and 8007D8B8[2:4]:
				v = 8007D8B4[0:2] << 2
				v = @80066A60+v
				800D269C[0:2] = 0
				80066B80+0 = 0
				if 8007D8B8[2:4] < v:
					# 80038210
					8007D8B0 = 4
				else:
					# 8003821C
					80118300[0:2] = 0
					call 8003A7F0(8007D8B0)
					8007D8B0 = 0
					8007D8B4[2:4] = 0
					80066B80 = 0
			8007D8B8[2:4] = 8007D8B8[0:2]
		elif v == 4:
			# 8003813C
			if 8007D8B8[0:2] and 8007D8B8[0:2] != 8007D8B8[2:4]:
				v = (8007D8B4[2:4] << 0x10) >> 0xE
				8007D8B4[2:4] += 1
				8007D8B8[v+4:v+6] = 8007D8B8[0:2] & 0xFF
				80066B80+0 = 0
				800D269C[0:2] = 0
				8007D8B0 += 1
			8007D8B8[2:4] = 8007D8B8[0:2]
		elif v == 5:
			# 800381BC
			800D269C[0:2] = 0
			if not 8007D8B8[0:2] and 8007D8B8[2:4]:
				v = 8007D8B4[0:2] << 2
				v = @80066A60+v
				if 8007D8B8[2:4] < v:
					# 80038210
					8007D8B0 = 4
				else:
					# 8003821C
					80118300[0:2] = 0
					call 8003A7F0(8007D8B0)
					8007D8B0 = 0
					8007D8B4[2:4] = 0
					80066B80 = 0
			8007D8B8[2:4] = 8007D8B8[0:2]
		elif v == 0xA:
			# 80038254
			800D269C[0:2] = 0xFF00
			8007D8B0 += 1
		elif v == 0xB:
			# 80038278
			800D269C[0:2] = 0
			8007D8B8[2:4] = 0
			8007D8B0 = 0
			8007D8B4[0:2] = 0
			8007D8B4[2:4] = 0
800382B4
	800ADE10[6:8] = 0
	800ADE10+0 = 0
	800ADE10[4:6] = 0
	80118300[0:2] = 0
800382DC

80038658	set slot type to A0; 801182F0[A:C] = @A0+0
	accepts: A0
80038668
	accepts: A0

80038984
	accepts: A0

80038C38
	accepts: A0

80038DDC
	accepts: A0

800391C4	unconditional return
	accepts: A0
800391CC
	accepts: A0
	v = @A0+0
	if not v & 0x20:
		return
	v &= 0xF
	# they do a number of silly tests, so important one here is...
	if v != 4:
		return
	v = 80118300[2:4] / @80118358
	80118344 += v
	8011834C += v
	if (@80118370 & 0) or (@80118374 & 0x20):
		80118300[2:4] = 0
		80118334[2:4] = 0
	else:
		v *= @80118358
		v = 80118300[2:4] - v
		80118300[2:4] = v
	if not call 80039B30(80118344):
		80118344 = 0
	80118388 = 0
800392EC	80118378[2:4] = @A0+0
	accepts: A0
800392FC
	accepts: A0
	80118310[2:4] = @A0+0
	call 80039960(80118354[0:2], 800D2750[1] + 1)
80039334
	accepts: A0
800394A4	???; add credit up to 99 credits?
	accepts: A0
	8011833C += 1
	80118340 += 1
	8007D890[0:2] += 1
	80118300[2:4] += 80118354[0:2]
	80118338[2:4] += 80118354[0:2]
	if 80118338[2:4] > 0x63:
		80118338[2:4] = 0x63
	if 80118338[2:4] < 0:
		80118338[2:4] = 0
8003954C
	accepts: A0
800396BC
	accepts: A0
	8011834C -= 1
	if @8011834C < 0:
		8011834C = 0
	8007DAE8 += 1
	800AEE78 = 0
	800AEE7C = 0
80039708
	accepts: A0
	v = @8011834C * @80118358
	v += 80118300[2:4]
	8011834C = 0
	80118300[2:4] = v
	call 8003A79C(v)
80039774
	accepts: A0
80039868
	accepts: A0
8003990C	80118300[4:6] -= 1 within range (0, 200)
	80118300[4:6] -= 1
	if 80118300[4:6] < 0:
		80118300[4:6] = 0
	if 80118300[4:6] > 0xC8:
		80118300[4:6] = 0xC8
80039948	80113110[0] = 1; rerun code at 80025DB0
80039958	unconditional return
80039960
	accepts: A0, A1
	v = 800ADE10[6:8]
	if v < 0xFA:
		v <<= 1
		800ADE10[v+C:v+E] = 0x100
		v = 800ADE10[6:8] * 0xA
		800AE010[v:v+2] = A0 << 8
		800AE010[v+2:v+4] = A1 << 8
		800ADE10[6:8] += 1
800399DC
	v = 800ADE10[6:8]
	if v < 0xFA:
		v <<= 1
		800ADE10[v+C:v+E] = 0x200
		v = 800ADE10[6:8] * 0xA
		A0 += 1
		800AE010[v:v+2] = A0 << 8
		800ADE10[6:8] += 1
80039A48
	accepts: A0
	v = 800ADE10[6:8]
	if v < 0xFA:
		v <<= 1
		800ADE10[v+C:v+E] = 0x300
		v = 800ADE10[6:8] * 0xA
		800AE010[v:v+2] = A0 << 8
		800ADE10[6:8] += 1
80039AA4
	v = 800ADE10[6:8]
	if v < 0xFA:
		v <<= 1
		800ADE10[v+C:v+E] = 0x400
		80118338[0:2] = 0
		800ADE10[6:8] += 1
80039AE8
	v = 800ADE10[6:8]
	if v < 0xFA:
		v <<= 1
		800ADE10[v+C:v+E] = 0x500
		80118338[0:2] = 0
		800ADE10[6:8] += 1
80039B30
80039FF4
8003A294
	if 800ADE10[6:8] < 0xFA:
		v = 800ADE10[6:8] << 1
		800ADE10[v+C:v+E] = 0x700
		800ADE10[6:8] += 1
8003A2D0
	if 800ADE10[6:8] < 0xFA:
		v = 800ADE10[6:8] << 1
		800ADE10[v+C:v+E] = 0x800
		v = 800ADE10[6:8] * 0xA
		800AE010[v:v+2] = 0x8000 if A0 == 1 else 0x4000
		800ADE10[6:8] += 1
8003A358
	if 800ADE10[6:8] < 0xFA:
		v = 800ADE10[6:8] << 1
		800ADE10[v+C:v+E] = 0x900
		v = 800ADE10[6:8] * 0xA
		800AE010[v:v+2] = 0x8000 if A0 == 1 else 0x4000
		800ADE10[6:8] += 1
8003A3E0
8003A680
	if 800ADE10[6:8] < 0xFA:
		v = 800ADE10[6:8] << 1
		800ADE10[v+C:v+E] = 0xB00
		800ADE10[6:8] += 1
8003A6BC
	if 800ADE10[6:8] < 0xFA:
		v = 800ADE10[6:8] << 1
		800ADE10[v+C:v+E] = 0xC00
		v = 800ADE10[6:8] * 0xA
		800AE010[v:v+2] = 80118300[4:6] << 8
		800ADE10[6:8] += 1
8003A724
	if 800ADE10[6:8] < 0xFA:
		v = 800ADE10[6:8] << 1
		800ADE10[v+C:v+E] = 0xD00
		800ADE10[6:8] += 1
8003A760
	accepts: A0=mode
	if A0 == 1:
		call 80039A48(1)
	elif A0 == 2:
		call 80039A48(3)
8003A79C	redirect to 80039FF4()
8003A7B8	call 80039A48(0xC)
8003A7D4	call 80039A48(0xB)
8003A7F0
	accepts: A0	[8007D8B0]
	# if A0[4:6] >= 0x13: return
	# call @8006ACA8+(A0[4:6]<<2)(A0)
	if A0[4:6] == 1:
		call 80038658(A0+C)	# set slot type to A0; 801182F0[A:C] = @A0+0
	elif A0[4:6] == 2:
		call 80038668(A0+C)
	elif A0[4:6] == 3:
		call 80038984(A0+C)
	elif A0[4:6] == 4:
		call 80038C38(A0+C)
	elif A0[4:6] == 5:
		call 80038DDC(A0+C)
	elif A0[4:6] == 6:
		call 800391C4(A0+C)	# unconditional return
	elif A0[4:6] == 7:
		call 800391CC(A0+C)
	elif A0[4:6] == 8:
		call 800392EC(A0+C)
	elif A0[4:6] == 9:
		call 800392FC(A0+C)
	elif A0[4:6] == 0xA:
		call 80039334(A0+C)
	elif A0[4:6] == 0xB:
		call 800394A4(A0+C)
	elif A0[4:6] == 0xC:
		call 8003954C(A0+C)
	elif A0[4:6] == 0xD:
		call 800396BC(A0+C)
	elif A0[4:6] == 0xE:
		call 80039708(A0+C)
	elif A0[4:6] == 0xF:
		call 80039774(A0+C)
	elif A0[4:6] == 0x10:
		call 80039868(A0+C)
	elif A0[4:6] == 0x11:
		call 8003990C(A0+C)	# 80118300[4:6] -= 1 within range (0, 200)
	elif A0[4:6] == 0x12:
		call 80039948(A0+C)	# 80113110[0] = 1; rerun code at 80025DB0
8003A940	Thread: boot
	call 80058D28()	# initialize system
	call 80059000()	# unconditional return
	call 80054970(8006CA20, 1, 8003A9A4, 0, 8006ED80, 0xA)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(8006CA20)	# start thread A0
8003A9A4	Thread: main
	801127C8 = None
	call 8003C8A0()	# create E/PI Thread and handle
	call 8003AA50(2, 1)	# create and initialize display using VI setting #A0
	call 800558A0(0x5A)	# set VI manager settings based on flags A0
	call 80054970(8006CBD0, 3, 80025C6C, 0, 800B1A60, 0xA)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(8006CBD0)	# start thread A0
	call 80054B40(8006CA20, 0)	# change priority of thread A0 or current thread to A1
	while True:
		if @801127C8:
			call @801127C8()
8003AA50	create and initialize display using VI setting #A0
	accepts: A0=VI settings index, A1
	801180DC = 0
	801180E0 = 0
	801180E4 = 0
	801180D8 = 0
	80117A70[0:2] = 1
	80117A70[2:4] = 2
	801180E8 = A1
	801180ED[0] = 2
	801180EC[0] = 0x32 if not @80000300 else 0x3C
	8007D892[0] = 0
	80074D80 = 80112A30
	80112A30+0 = 0
	80112A30+4 = 0
	80112A30[59] = 0
	80112A30[58] = 0
	8007D918 = 80112A30
	call 800544C0(0x3C0)	# A410000C = A0; set DP Status to A0
	call 80054040(80117AE4, 80117AFC, 8)	# create message queue A0 with A2 messages at A1
	call 80054040(80117B1C, 80117B34, 8)	# create message queue A0 with A2 messages at A1
	call 80054040(80117B54, 80117B6C, 8)	# create message queue A0 with A2 messages at A1
	call 80054040(80117AAC, 80117AC4, 8)	# create message queue A0 with A2 messages at A1
	call 80054040(80117A74, 80117A8C, 8)	# create message queue A0 with A2 messages at A1
	call 80054040(80117B8C, 80117BA4, 8)	# create message queue A0 with A2 messages at A1
	call 800554B0(0xFE)	# create and start VI thread with priority A0
	call 80055850(800675C0 + (A0 * 0x50))	# use VI settings at A0
	call 80055DC0(1)	# blackout screen if A0
	call 800557F0(80117AE4, 0x29A, A1)	# set VI interrupt callback to queue A0, msg A1, mode A2
	call 80054410(4, 80117B1C, 0x29B)	# create callback for event A0, sending msg A2 to queue A1: SP task complete
	call 80054410(9, 80117B54, 0x29C)	# create callback for event A0, sending msg A2 to queue A1: DP full sync
	call 80054410(0xE, 80117AE4, 0x29D)	# create callback for event A0, sending msg A2 to queue A1: preNMI
	call 80054970(80117BC8, 0x13, 8003AE04, 80117A70, 80070D80, 0x78)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(80117BC8)	# start thread A0
	call 80054970(80117D78, 0x12, 8003B2CC, 80117A70, 80072D80, 0x6E)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(80117D78)	# start thread A0
	call 80054970(80117F28, 0x11, 8003B658, 80117A70, 80074D80, 0x64)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(80117F28)	# start thread A0
8003ADA4	V0 = 80117A74
8003ADD4	V0 = 80117AAC
8003AE04	Thread
	accepts: A0
8003B028
	accepts: A0=p->target, A1=p->queue, A2=flags
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	A0+4 = A1
	A0+0 = @801180D8
	A0[8:A] = A2
	801180D8 = A0
	if A2 & 2 and 8007D892[0]:
		call 800542E0(A1, 80117A72, False)	# send or jam (A2) msg A1 to queue A0
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003B0F8
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	A0[8:A] = A1
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003B15C
	accepts: A0
8003B230
8003B2CC	Thread
	accepts: A0
8003B658	Thread
	accepts: A0
8003BCA8
8003BD70	801180ED[0] = A0
	accepts: A0
8003BDA4	V0 = 801180EC[0]
8003BDE0	Thread
	call 80054040(801182C8, 80076F50, 8)	# create queue A0 with A2 messages at A1
	# 8003BE20
	while True:
		call 800541B0(801182C8, SP+14, True)	# read or wait (A2) to write message from queue A0 to A1
		v = @SP+14
		v = @v+54
		if v[0:2] == 4:
			# 8003BE70
			if @80066BCC:
				call @80066BCC(@SP+14)
			if @800AE9F8 & 0x80:
				call 80055DC0(0)
				800AE9F8 = 1
			flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
			800D26B8 -= 1
			@800D26B8	# not an error; read and thrown away, probably to push out of cache
			call 8004C4A0(flag)	# V0 = flags after masking Status with A0
		elif v[0:2] == 8:
			# 8003BF00
			if @80066BD0:
				call @80066BD0(@SP+14)
			flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
			800D26B8 -= 1
			@800D26B8	# not an error; read and thrown away, probably to push out of cache
			call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003BF84
	80074D94[0:2] = 8
	80074D94[2:4] = 4
	800D26B8 = 0
	call 8003C830()	# disable display and blackout
	call 80054970(80074D98, 5, 8003BDE0, 0, 80076F50, 0x3C)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(80074D98)	# start thread A0
	for i in range(0xA):
		v = i * 0x58
		80113118+v = 80113170 + v
		80113168+v = 801182C8
		80113128+v = 1
		8011312C+v = 0
		80113130+v = 8005DA50
		80113134+v = 8005DB20 - 8005DA50	# 0xD0
		8011313C+v = 0x1000
		80113144+v = 0x800
		80113148+v = 80117670
		8011314C+v = 0x400
		80113160+v = 800B1A70
		80113164+v = 0xC10
	# 8003C284
	80113430 = 80113118
	80074D90 = 80113118
8003C2BC	start graphics task with display list A0, length A1
	accepts: A0=p->dl, A1=length, A2, A3
8003C580	set 80066DA0 to function pointer A0
	accepts: A0=p->function
	call 8003C5E0()	# wait while @800D26B8 nonzero
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	80066DA0 = A0
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003C5E0	wait while @800D26B8 nonzero
	while @800D26B8:
		pass
8003C630	register A1 framebuffers starting at rdram A0
	accepts: A0=p->target, A1=num
	80117618 = A0
	80066BC0 = A1
	800ADC44 = 0
	v = @80117618
	80117598 = @v+0
	call 8003E0F0(1)	# ???; wait A0 frames?
	call 8003BD70(A1 & 0xFF)	# 801180ED[0] = A0
	if A1 < 2:
		return
	for i in range(A1-1):
		v = @80117618+0 + (i << 2)
		if @v+0 != @v+4:
			break
	# 8003C730
	if i == (A1-1):
		call 8003BD70(1)	# 801180ED[0] = A0
		return
	for i in range(A1):
		call 80055420()
		v = @80117618+0 + (i << 2)
		if @v+0 != @80117618:
			800ADC44 = i
			80117598 = @v+0
			break
	# 8003C7F4
	if i == A1:
		call 80054018(8006AD44)	# NERFed! print debug message A0: "nuGfxSetCfb: FrameBuffer Addres Error!!\n"
8003C830	disable display and blackout
	800AE9F8 = 0
	call 80055DC0(1)	# blackout screen if A0
8003C870	800AE9F8 = 0x80
8003C8A0	create E/PI Thread and handle
	call 8004C540(0x96, 80076F70, 80076F88, 0x32)	# create EPI request thread with priority A0, using queue A1 with A3 msgs at A2
	80112958 = call 8004C960()	# V0 = p->EPI handle for cart, creating if necessary
8003C900	load A2 bytes from hardware A0 to rdram A1
	accepts: A0=hardware offset, A1=p->target, A2=length
	call 80054040(SP+28, SP+40, 1)	# create queue A0 with A2 messages at A1
	SP[12] = 0
	SP+14 = SP+28
	call 80051C90(A1, A2)
	if not A2:
		return
	i = 0
	while i < A2:
		v = min(0x4000, A2 - i)
		SP+18 = A1
		SP+1C = A0
		SP+20 = v
		call 8004C8C0(@80112958, SP+10, 0)	# V0 = errors when completing and sending read or write (A2) E/PI request A1 using EPI handle A0
		call 800541B0(SP+28, SP+40, True)	# read or wait (A2) to write message from queue A0 to A1
		A1 += i
		A0 += i
8003CA30	???; sets up framebuffers and display processing threads
	call 8003DFD4()	# create and start thread 800ADC48 calling 8003DEB0(0)
	call 8003C630(80066C10, 3)	# register A1 framebuffers starting at rdram A0
	800ADBB0 = 80000400	# replacement Z buffer, looks like
	call 8003E040(8003E0A0)	# ???; 80066BCC = p->function A0
	call 8003E1A0(800B2690, 0x20000)	# set fifo buffer A0, size A1
	800AF9D8 = 80066BE0	# microcode table
	call 8003BF84()
	dl = SP+10
	dl.append(DE000000, 00066C20)
	dl.append(E9000000, 00000000)
	dl.append(DF000000, 00000000)
	v = dl - SP+10
	v >>= 3
	v <<= 3
	call 8003C2BC(SP+10, v, 0, 0)	# start graphics task with display list A0, length A1
	call 8003C5E0()	# wait while @800D26B8 nonzero
8003CB80
	SP[10] = call 8003E230()
	call 8003E900()	# V0 = number of connected controllers; initialize SI callback for controller input
	call 8003CCA0()	# add SI callback 80066D40
	call 8003D170()
	return SP[10]
8003CBE0	copy controller A1 button input to A0
	accepts: A0=p->target, A1=channel
	SP[10:12] = A0[0:2]
	call 8003EA98()	# jam msg 0 to queue 801203B0
	v = A1 * 6
	call 80053B30(800AEE38+v, A0, 6)	# V0 = p->A2 bytes copied from A0 to A1; fastcopy
	A0[6:8] = 800AEE38[v:v+2] & ~SP[10:12]
	call 8003EAD8()	# wait for message on queue 801203B0
8003CCA0	add SI callback 80066D40; call 8003E710(80066D40)
8003CCD8	remove SI callback 80066D40; call 8003E840(80066D40)
8003CD10

8003CD9C
	accepts: A0
	v = @A0+C
	i = @v+0
	return call 800575A0(@i+0, v+4)
8003CE04
	accepts: A0
	v = @A0+C
	return call 80056E00(@(@v+0)+0, @(@v+0)+4, v[C], @v+4, @v+8, @v+10, v, @v+0)
8003CE98
8003CFA0
8003D028
8003D09C
	accepts: A0=p->request struct
	j = @A0+0
	i = @A0+C
	return call 800576B0(@j+0, @i+4, @i+8)
8003D110
	v = @A0+C
	return call 80057A80(@v+0)
8003D170
	for i in range(4):
		v = i * 0xA
		800AED10[v+4:v+6] = i
		800AED10[v+6] = 2
		800AED10[v+7] = 0
	# 8003D220
	call 8003E710(80066D70)	# add SI callback for A0
8003D248	remove SI callback 80066D70; call 8003E840(80066D70)
8003D280
	accepts: A0
8003D5B0
8003D858
8003D8EC
8003D9B8
	accepts: A0
	for i in range(4):
		v = i * 0xA
		800AED10[v+7] &= 0x7F
	return 0
8003DA60
8003DB50
8003DBB0	add SI callback for 80066D94; call 8003E710(80066D94)
8003DBE8	remove SI callback 80066D94; call 8003E840(80066D94)
8003DC20	read A2 bytes of data from eeprom address A0 to A1
	accepts: A0, A1, A2
	SP+18 = A1
	SP+18[8] = A0 & 0xFF
	SP+18[A:C] = A2
	return call 8003E2FC(0x402, SP+18)
8003DCA8	write A2 bytes of data A1 to eeprom address A0
	accepts: A0, A1, A2
	SP+18 = A1
	SP+18[8] = A0 & 0xFF
	SP+18[A:C] = A2
	return call 8003E2FC(0x403, SP+18)
8003DD30	V0 = eeprom type or -1
	return call 8003E2FC(0x401, 0)
8003DD78	V0 = eeprom type read using SI queue 801182A8
	return call 8004B950(801182A8)	# V0 = eeprom type read using SI queue A0
8003DDC4	V0 = errors reading eeprom using request struct A0
	accepts: A0=eeprom request struct
	v = @A0+C
	return call 8004BAC0(801182A8, @v+8, v, A0[A:C])	# V0 = errors reading A3 bytes from eeprom address A1 to A2 using queue A0
8003DE38	V0 = errors writing eeprom using request struct A0
	accepts: A0=eeprom request struct
	v = @A0+C
	return call 8004B9D0(801182A8, @v+8, v, A0[A:C])	# V0 = errors writing A3 bytes of data A2 to eeprom address A1 using queue A0
8003DEB0	Thread
	call 80054040(800AEE58, 80077050, 8)	# create queue A0 with A2 messages at A1
	call 8003B028(SP+10, 800AEE58, 3)
	# 8003DF0C
	while True:
		call 800541B0(800AEE58, SP+20, True)	# read or wait (A2) to write message from queue A0 to A1
		v = @SP+20
		if v[0:2] == 1:
			# 8003DF50
			if @80066DA0:
				call @80066DA0(@800D26B8)
		elif v[0:2] == 2:
			# 8003DF80
			if @80066DA4:
				call @80066DA4()
8003DFD4	create and start thread 800ADC48 calling 8003DEB0(0)
	call 80054970(800ADC48, 4, 8003DEB0, 0, 80079070, 0x32)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(800ADC48)	# start thread A0
8003E040	???; 80066BCC = p->function A0
	accepts: A0=p->function
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	80066BCC = A0
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003E0A0	call 80055A60(@A0+C)
8003E0F0	???; wait A0 frames?
	accepts: A0=frame number
	call 80054040(SP+28, SP+20, 1)	# create queue A0 with A2 messages at A1
	call 8003B028(SP+10, SP+28, 1)
	for i in range(A0):
		call 800541B0(SP+28, 0, True)	# read or wait (A2) to write message from queue A0 to A1
	call 8003B15C(SP+10)
8003E1A0	set fifo buffer A0, size A1
	accepts: A0=p->fifo buffer, A1=fifo size
	if A0 & 0xF:
		call 80054018(8006AD70)	# NERFed! print debug message A0: "nuGfxUcodeFifoSet: fifo buffer is NOT 16byte boundaries\n"
	if A1 & 0xF:
		call 80054018(8006ADAC)	# NERFed! print debug message A0: "nuGfxUcodeFifoSet: fifo size is NOT multiple 8 \n"
	80066BC8 = A0
	80066BC4 = A1
8003E230
8003E2FC

8003E41C	Thread: SI callback
	call 80054040(800D26A0, SP+20, 8)	# create queue A0 with A2 messages at A1
	call 8003B028(SP+10, 800D26A0, 1)
	# 8003E474
	while True:
		call 800541B0(800D26A0, SP+40, True)	# read or wait (A2) to write message from queue A0 to A1
		SP+44 = 80066DB0
		if (@SP+40)[0:2] == 1:
			# 8003E4C4
			while @(@SP+44)+0:
				v = @(@SP+44)+0
				v = @v+4
				if @v+0:
					SP+48 = call @v+0(@SP+40)
				if @SP+48:
					break
				SP+44 = @(@SP+44)+0
			continue
		elif (@SP+40)[0:2] == 0x7F00:
			# 8003E544
			call 800542E0(@(@SP+40)+4, 0, True)	# send or jam (A2) msg A1 to queue A0
			call 8003B0F8(SP+10, 0)
			call 80054D30(0)
			call 8003B0F8(SP+10, 1)
			continue
		else:
			# 8003E590
			SP[4C:4E] = (@SP+40)[0:2] & 0xFF00
			SP[4E:50] = (@SP+40)[0:2] & 0xFF
			while @(@SP+44)+0:
				v = @(@SP+44)+0
				if v[8:A] != SP[4C:4E]:
					# 8003E6A8
					SP+44 = @(@SP+44)+0
					continue
				if v[A:C] < SP[4E:50]:
					v = @v+4
					v = @v+(SP[4E:50]<<2)
					(@SP+40)+8 = call @v+0(@SP+40)
				else:
					call 80054018(8006ADE0, SP[4C:4E], SP[4E:50], (@(@SP+44)+0)[A])	# NERFed! print debug message A0: "nuSiMgr: majorNo %#x minorNo %#x is over callback func num(%d).\n"
					(@SP+40)+8 = -1
				# 8003E678
				if @(@SP+40)+4:
					call 800542E0(@(@SP+40)+4, 0, True)	# send or jam (A2) msg A1 to queue A0
			# 8003E6BC
			if not @(@SP+44)+0:
				call 80054018(8006AE24, (@SP+40)[0:2])	# NERFed! print debug message A0: "nuSiMgr: no si callback function mesg %#X\n"
8003E710	add SI callback for A0; nuSiCallBackAdd?
	accepts: A0=p->SI struct
	v = @80066DB0
	while v:
		if v[8:A] == A0[8:A]:
			call 80054018(8006AE50, A0[8:A])	# NERFed! print debug message A0: "nuSiCallBackAdd: CallBack is already added(major no = %#X!!\n"
			return
		v = @v+0
	# 8003E79C
	i = 1
	while True:
		if not @(@A0+4)+(i<<2):
			break
		i += 1
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	v+0 = A0
	A0+0 = 0
	A0[A] = i
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003E840	remove SI callback A0
	accepts: A0=p->SI struct
	v = 80066D80
	while @v+0:
		i = @v+0
		if @i+0 == A0:
			flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
			i+0 = @A0+0
			A0+0 = 0
			call 8004C4A0(flag)	# V0 = flags after masking Status with A0
			return
		# 8003E8D0
		v = @v+0
8003E900	V0 = number of connected controllers; initialize SI callback for controller input
	call 8003EE80()
	call 80054040(8007DAD0, 8007B240, 1)	# create queue A0 with A2 messages at A1
	call 80054040(801203B0, 8007B244, 1)	# create queue A0 with A2 messages at A1
	call 8003E710(80066DD8)	# add SI callback for A0
	call 8003EED0()	# copy result of SI status request to 800ADBB8
	800B1A68 = 0
	j = 0
	for i in range(4):
		if not 800ADBB8[3 + (i<<2)]:
			v = 800ADBB8[(i<<2):(i<<2)+2]
			v &= 0x1F07
			if v == 5:
				800B1A68 += 1
				j |= 1 << i
	# 8003EA38
	return j
8003EA60	remove SI callback 80066DD8; call 8003E840(80066DD8)
8003EA98	jam msg 0 to queue 801203B0
	call 800542E0(801203B0, 0, True)	# send or jam (A2) msg A1 to queue A0
8003EAD8	wait for message on queue 801203B0
	call 800541B0(801203B0, 0, True)	# read or wait (A2) to write message from queue A0 to A1
8003EB18	read controller input to A0
	accepts: A0=p->target, A1=flags
	v = call 80051E90(801182A8)	# send pifram read requests, informing queue A0
	if v:
		return v
	call 800541B0(801182A8, 0, True)	# read or wait (A2) to write message from queue A0 to A1
	if @800ADBB4 & A1:
		return v
	call 8003EA98()	# jam msg 0 to queue 801203B0
	call 80051F18(A0)	# copy result of SI read request to A0
	call 8003EAD8()	# wait for message on queue 801203B0
	return v
8003EBD8	send and copy results of SI status request to 800ADBB8
	v = call 80051DF0(801182A8)	# send pifram status requests, informing queue A0
	if not v:
		call 800541B0(801182A8, 0, True)	# read or wait (A2) to write message from queue A0 to A1
		call 80051E70(800ADBB8)	# copy result of SI status request to A0; calls 8005220C
	return v
8003EC64
	accepts: A0
	if @800ADBB4:
		return 0
	call 800541B0(8007DAD0, 0, False)	# read or wait (A2) to write message from queue A0 to A1
	call 8003EB18(800AEE38, 1)	# read controller input to A0
	if @80066DC0:
		call @80066DC0(A0[0:2])
	call 800542E0(8007DAD0, 0, False)	# send or jam (A2) msg A1 to queue A0
	return 0
8003ED28	read controller input into struct A0
	accepts: A0
	return call 8003EB18(@A0+C, 1)	# read controller input to A0
8003ED78
	accepts: A0
	call 800541B0(8007DAD0, 0, False)	# read or wait (A2) to write message from queue A0 to A1
	v = call 8003EB18(800AEE38, 0)	# read controller input to A0
	if v and @80066DC0:
		call @80066DC0(A0[0:2])
	return v
8003EE30
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	800ADBB4 = 1
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003EE80
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	800ADBB4 = 0
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003EED0	copy result of SI status request to 800ADBB8; call 8003E2FC(0x103, 0)
8003EF10
	call 8003F290(8033F800, 0x50000, 80066E00)
	call 8003EFA0(80066E24, 0x8000, 0)
	call 8003EFA0(80066E24, 0x8000, 1)
	call 8003F020(80066E40)
	call 8003F0F0(8003F130)
	call 8003F050(8003F090)
	call 8003FC94()
8003EFA0
	accepts: A0, A1=length, A2
	A0+C = 8007D898
	v = call 8003FC3C(A1)	# V0 = p->A0 bytes allocated from table 8007D898
	i = A2 * 0x184
	800AEB7C+i = v
	call 80040530(800AEA08+i, A0)
8003F020
	accepts: A0
	A0+8 = 8007D898
	call 800417F0(800AEE80)
8003F050
	accepts: A0=p->function
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	80066E5C = A0
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003F090
	accepts: A0, A1
	if A0 == 1 and A1 == 0x1C:
		80066E68[2:4] = 0
	elif A0 == 2:
		call 8003FD70(0, 0x1C)
		call 8003FD70(1, 0x1C)
8003F0F0
	accepts: A0=p->function
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	80066E60 = A0
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
8003F130
8003F290	set allocation at A0, size A1
	accepts: A0=p->rdram, A1=length, A2=
	80066E68[2] = 1
	v = call 8003BDA4()	# V0 = 801180EC[0]
	k = @801180E8 * @A2+18
	k += v
	k -= 1
	k /= v
	j = 80066E68[0:2] + k + 0xB7
	800ADC40[0:2] = k
	i = j * 0xB21642C9
	i += j
	i >>= 7
	i -= j >> 31
	800ADC40[0:2] = i * 0xB8
	call 8003FC20(8007D898, A0, A1)	# set allocation table A0 for A2 bytes at A1
	801127C4 = call 8003FC3C(@80066E64 << 3)	# V0 = p->A0 bytes allocated from table 8007D898
	8007B250 = call 8003FC3C(@800ADC40 << 2)	# V0 = p->A0 bytes allocated from table 8007D898
	8007B254 = call 8003FC3C(@800ADC40 << 2)	# V0 = p->A0 bytes allocated from table 8007D898
	801182E0 = call 8003FC3C(0x2000)	# V0 = p->A0 bytes allocated from table 8007D898
	A2+10 = 8003F9C4
	A2+14 = 8007D898
	A2+18 = call 8004CFA0(@A2+18)
	call 8003FE60(801129D0, A2)
	# 8003F3EC
	800ADBF0 = 2
	800ADBFC = 8005DB20 - 8005DA50	# 0xD0
	800ADC00 = 8005CDF0
	800ADC08 = 800689C0
	800ADC0C = 0x800
	800ADC34 = 0
	800ADBF8 = 8005DA50
	800ADC10 = 0
	800ADC14 = 0
	800ADC18 = 0
	800ADC1C = 0
	800ADC28 = 0
	800ADC2C = 0
	800AEB84 = 0
	800AED08 = 0
	800AEB7C = 0
	800AED00 = 0
	call 80054970(800AF828, 6, 8003F504, 0, @801182E0+0 + 0x2000, 0x46)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(800AF828)	# start thread A0
	return call 8003FC94()	# V0 = @8007D89C - @8007D898
8003F504	Thread
8003F820	V0 = p->A1 bytes read from hardware A0
	accepts: A0=hardware offset, A1
	k = @80112960
	A1 += A0
	j = 0
	# 8003F854
	while k:
		v = 80066DF0[2:4] + @k+8
		if A0 < @k+8:
			break
		j = k
		if v < A1:
			# 8003F8F4
			k+C = 1
			v = @k+10 + @k+8 + A0
			return call 80052380(v)	# V0 = physical address for A0
		k = @k+0
	# 8003F87C
	k = @80112064
	if not k:
		v = @80112960
		return 80000000 - @v+10
	# 8003F8A8
	80112964 = @k+0
	call 8005097C()
	if j:
		call 8005095C(k, j)
	else:
		# 8003F8CC
		j = @80112960
		if j:
			80112960 = k
			k+0 = j
			k+4 = 0
			j+4 = k
		else:
			80112960 = k
			k+0 = 0
			k+4 = 0
	# 8003F928
	j = A0 & 1
	A0 -= j
	v = @8007B260 * 0x18
	8007B260 += 1
	k+8 = A0
	k+C = 1
	k+10 = k
	(@800AE9FC)[v + 2] = 0
	(@800AE9FC)+4 = 800ADDF8
	(@800AE9FC)+8 = k
	(@800AE9FC)+C = A0
	(@800AE9FC)+10 = 80066DF0[2:4]
	call 8004C8C0(@80112958, @800AE9FC, 0)	# V0 = errors when completing and sending read or write (A2) E/PI request A1 using EPI handle A0
	return call 80052380(k) + j	# V0 = physical address for A0
8003F9C4	V0 = 8003F820
	accepts: A0
	if not 8011295C[0]:
		800B1A64 = call 8003FC3C(80066DF0[0:2] << 2)	# V0 = p->A0 bytes allocated from table 8007D898
		800AE9FC = call 8003FC3C(80066DF0[0:2] * 0x18)	# V0 = p->A0 bytes allocated from table 8007D898
		call 80054040(800ADDF8, @800B1A64, 80066DF0[0:2])	# create queue A0 with A2 messages at A1
		800AEA00 = call 8003FC3C(80066DF0[0:2] * 0x14)	# V0 = p->A0 bytes allocated from table 8007D898
		80112960 = 0
		80112964 = @800AEA00
		v = @800AEA00
		v+0 = 0
		v+4 = 0
		# 8003FA94
		for i in range(80066DF0[0:2])
			call 8005095C(@800AEA00 + (i + 1) * 0x14, @800AEA00 + i * 0x14)
			(@800AEA00)+(i * 0x14)+10 = call 8003FC3C(80066DF0[2:4])	# V0 = p->A0 bytes allocated from table 8007D898
		# 8003FAE4
		(@800AEA00)+(i * 0x14)+10 = call 8003FC3C(80066DF0[2:4])	# V0 = p->A0 bytes allocated from table 8007D898
		8011295C[0] += 1
	# 8003FB20
	8007B260 = 0
	A0+0 = 8011295C
	return 8003F820
8003FB58
	i = @80112960+0
	8007B260 = 0
	while i:
		v = @80112960+C
		80112960+C -= 1
		if not v:
			if @80112960+0 == i:
				80112960+0 = @i+0
			call 8005097C(i)
			if not @80112960+4:
				80112960+4 = i
				i+0 = 0
				i+4 = 0
			else:
				call 8005095C(i, @80112960+4)
		i = @i+0
	# 8003FBE8
	80066E50 += 1
8003FC20	set allocation table A0 for A2 bytes at A1; redirect to 800509B0(A0, A1, A2)
	accepts: A0=p->allocation table, A1, A2
8003FC3C	V0 = p->A0 bytes allocated from table 8007D898; calls 800509F0(0, 0, 8007D898, 1, A0)
	accepts: A0=length
	call 800509F0(0, 0, 8007D898, 1, A0)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
8003FC6C
	v = call 8003FC94()
	return @8007C8A0 - v
8003FC94	V0 = @8007D89C - @8007D898
8003FCB0
8003FD70
8003FE60
	accepts: A0, A1=p->request
	if not @80066E70:
		80066E70 = A0
		if not @80066E74:
			80066E74 = A0
			call 8003FF00(A1)
8003FEA4
	if @80066E70:
		call 8003FEE0()
		80066E70 = 0
		80066E74 = 0
8003FEE0
	v = @80066E74
	v+0 = 0
	v+4 = 0
	v+8 = 0
	v+C = 0
8003FF00
	accepts: A0=p->request
	v = @80066E74
	v+0 = 0
	v+4 = 0
	v+8 = 0
	v+C = 0
	v+28 = 0
	v+2C = 0
	v+30 = @A0+10
	v+44 = @A0+4
	v+4C = @A0+18
	v+50 = 0xB8
	v+54 = 0
	v+58 = 1
	k = call 800509F0(0, 0, @A0+14, 1, 0x44)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	v+40 = k
	k+14 = 0
	k+18 = @A0+4
	k+1C = call 800509F0(0, 0, @A0+14, @A0+4, 4)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	j = call 800509F0(0, 0, @A0+14, 1, 0x14)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	k+3C = j
	if A0[1C]:
		(@v+40)+20 = call 80044DC0(0, A0, @A0+14)
		(@v+3C)+4 = 80044270
	else:
		j+4 = 800429E0
	# 80040044
	v+10 = 0
	v+14 = 0
	v+18 = 0
	v+1C = 0
	v+20 = 0
	v+24 = 0
	j = call 800509F0(0, 0, @A0+14, @A0+4, 0x8C)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	for i in range(@A0+4):
		call 8005095C(j, v+10)
		j+8 = 0
		call 80042E6C(j, @v+30, @A0+14)	# dynamically load image file to A0 using function A1 and allocation table A2
		(@v+1C + @(@v+40)+14)+0 = j
		(@v+40)+14 += 1
		j += 0x8C
	# 800400FC
	j = call 800509F0(0, 0, @A0+14, @A0+8, 0x1C)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	v+38 = 0
	# 80040134
	for i in range(@A0+8):
		j+0 = @v+38
		v+38 = j
		j += 0x1C
	# 80040154
	return @80066E74
8004017C
800402FC

80040530
	accepts: A0, A1
800406A0

800417F0
80041908
80041998
80041DD0
80041E78
80041ED0
80041F4C
80041FE4

80042E6C	dynamically load image file to A0 using function A1 and allocation table A2
	accepts: A0=p->struct, A1=p->function, A2=p->allocation table
	A0+C = call 800509F0(0, 0, A2, 1, 0x20)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	A0+10 = call 800509F0(0, 0, A2, 1, 0x20)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	A0+28 = call A1(A0+2C)
	A0+34 = 0
	A0+38 = A1
	A0+3C = 0
	A0+40 = call 800509F0(0, 0, A2, 1, 0x20)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	A0+44 = 1.0
	A0+48 = 0
	A0+4C = 0
	A0+50 = A1
	A0+54 = call 800509F0(0, 0, A2, 1, 0x50)	# V0 = p->count SP+10 blocks of size A3 allocated from table A2
	A0[58:5A] = 0
	A0[5A:5C] = 1
	A0[5C:5E] = 1
	A0[5E:60] = 1
	A0[60:62] = 0
	A0[62:64] = 0
	A0[64:66] = 0	# set twice
	A0[66:68] = 1	# set twice
	A0[68:6A] = 1
	A0[6E:70] = 1
	A0+70 = 0
	A0+74 = 0
	A0+78 = A1
	A0+7C = 0
	A0+80 = 0
	A0+84 = 0
80042FA0

80047068	initialize Aleck hardware
	accepts: A0=feature flags
	call 80047380()	# set TLB entries for Aleck hardware
	call 8004742C(SP+10)	# write Aleck hardware handles to A0
	8007B270 = call 8004B160(@SP+10, @SP+14)	# V0 = p->initialized Aleck "ram" at A0, size A1
	if A0 & 0x10:	# overlay
		call 800475F0()	# initialize Aleck overlay
	if A0 & 0x20:	# networking
		call 80047F2C()	# initialize Aleck networking
800470F0	allocate entry of size A0 in default aleck memory manager
	return call 8004B534(@8007B270, A0)	# allocate entry of size A1 in aleck memory manager A0
80047140	initialize default aleck memory manager entries for data A0
	call 8004B2DC(@8007B270, A0)	# initialize aleck memory manager entries for data A1 using table A0
80047180	call 8005CBD0(0)
800471C0	write TLB entry with index A0 mapping A1 to A2 using pagemask #A3 using cache mode SP+10
	accepts: A0=index, A1=virtual page, A2=phys.addy, A3=index of pagemask, SP+10=mode (0:uncached, 1:cache noncoherant)
	v = A3 * 0xC
	SP+20 = 80067120+v
	SP+24 = 0
	SP+28 = 3 if SP+10 else 2
	SP+2C = 1
	SP+30 = 1
	SP+34 = 1
	if @80067120+v != A3:
		return 0
	SP+10 = A1 & ~0x3FFF	# EntryHi
	SP+10 |= @SP+24
	SP+14 = (A2 >> 6) | (@SP+28 << 3) | (@SP+2C << 2) | (@SP+30 << 1) | @SP+34	# EntryLo0
	SP+18 = (@80067120+v+4 | A2) >> 6	# EntryLo1
	SP+18 |= (@SP+28 << 3) | (@SP+2C << 2) | (@SP+30 << 1) | @SP+34
	SP+1C = @80067120+v+8	# PageMask (0x7FE000)
	call 8004B890(A0, SP+10)	# write TLB entry @A1 to index A0
	return 1
80047334	V0 = True; read TLB entry A0 to A1
	accepts: A0=index, A1=p->target
	call 8004B7E0(A0, A1)	# read TLB entry A0 to A1
	return 1
80047380	set TLB entries for Aleck hardware
	SP+10 = E0000000	# EntryHi
	SP+14 = 03000007	# EntryLo0
	SP+18 = 03420017	# EntryLo1
	SP+1C = @80067164	# PageMask (0x7FE000)
	call 8004B890(0x10, SP+10)	# write TLB entry @A1 to index A0
	SP+10 = E0800000	# EntryHi
	SP+14 = 03020017	# EntryLo0
	SP+18 = 03030017	# EntryLo1
	SP+1C = @80067128	# PageMask (0)
	call 8004B890(0x11, SP+10)	# write TLB entry @A1 to index A0
	return True
8004742C	write Aleck hardware handles to A0
	A0+0 = E0000000
	A0+4 = 0x400000
	A0+8 = E0800000
	A0+C = 0x400
	A0+10= E0400000
	A0+14= 0x4000
80047498	initialize 32 TLB entries
	SP+24 = 0x80000
	SP+28 = 0
	SP+2C = 0
	SP+30 = 0
	SP+34 = 0
	SP+38 = 0
	SP+3C = 0
	SP+40 = 1
	SP+44 = 0x20
	SP+14 = (@SP+2C << 6) | (@SP+30 << 3) | (@SP+34 << 2) | (@SP+38 << 1) | @SP+3C
	SP+18 = (@SP+2C << 6) | (@SP+30 << 3) | (@SP+34 << 2) | (@SP+38 << 1) | @SP+3C
	SP+1C = @SP+40 << 0xD
	for i in range(0x20):
		SP+10 = (@SP+24 >> 1) << 0xD
		SP+10 += @SP+28
		call 8004B890(i, SP+10)	# write TLB entry @A1 to index A0
		SP+24 += 1
800475F0	initialize Aleck overlay (E0400000)
	call 8004742C(SP+20)	# write Aleck hardware handles to A0
	base = @SP+30	# E0400000
	base[281E:2820] = 1
	while base[2800:2802] & 0x800:
		pass
	base[2802:2804] = 0x66
	base[2804:2806] = 0x2E0
	base[2806:2808] = 0x2F9
	base[2808:280A] = 0x400
	base[280C:280E] = 0x10
	base[280E:2810] = 0xFF
	base[2810:2812] = 0x105
	base[2812:2814] = 0x3EC
	base[2814:2816] = 0xC
	base[2818:281A] = 0
	base[2818:281A] = 0x10	# Not a typo; same offset as line above.
	base[0x1000:0x2000:2] = repeat(0, 0x800)
	base[2816:2818] = 7
	base[0:0x1000:8] = repeat((0, 0, 0, 0x200), 0x200)
	base[2816:2818] = 6
80047810	wait 0x124F ms
	call 80054040(SP+40, SP+58, 8)	# create queue A0 with A2 messages at A1
	call 80054F10(SP+20, -, 0, 0x124F, 0, 0, SP+40, 1)	# create timer A0 for (A2, A3) from (SP+10, SP+14), writing or jamming (SP+1C) queue SP+18
	call 800541B0(SP+40, SP+78, True)	# read or wait (A2) to write message from queue A0 to A1
800478A4
	return E0800008[0:2] & 0xF
800478E0
	accepts: A0, A1
	if A1 >= 0x10 or A1 in (8, 0xB):
		return -1
	flag = call 8004C4A0(~0x800)	# V0 = flags after masking Status with A0
	A0 <<= 2
	E0800100[A0:A0+2]	# this read is thrown away
	E0800100[A0:A0+2] = A1
	v = E0800100[A0:A0+2] & 0xFF
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
	return v
800479E0
	accepts: A0, A1
	if A1[0] < 0x10 or A1[0] == 0x17:
		v = A1[0] * 0x21
		return 8007B288[v+A0]
	else:
		return -1
80047A80	???, tied to networking; set value A2 in word A0 of E0800100 and bank A0, slot A1
	accepts: A0=bank, A1=slot, A2=value
80047CF8
80047F2C	initialize Aleck networking
	call 80047A80(0, 9, 0xC0)
80047F68	???; something slightly more complicated with networking
	call 80047A80(0, 9, 0xC0)
	call 80047810()	# wait 0x124F ms
	...
80048568
800485D0
800486DC
800487E4
80048890
800488CC
80048900
80048944	V0 = byte A1 set in network slot A0
	accepts: A0=slot, A1=byte
	A0 <<= 2
	E0800100[A0:A0+2] = A1
	return E0800100[A0:A0+2] & 0xFF
800489BC
	accepts: A0=slot, A1=byte, A2=byte
	v = (A0 << 5) + A1
	8007B288[v] = A2
	A0 <<= 2
	E0800100[A0:A0+2] = A1
	E0800100[A0:A0+2] = A2	# not a typo!
80048A54
8004987C
80049E70
8004A16C
8004A2DC
8004A3C8
8004A488
8004A890
	accepts: A0
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	v = A0 * 0x60
	if call 800486DC(@8007B2F4+v, SP+18, SP+14):
		call 80053B30(@SP+18, A2, @SP+14)	# V0 = p->A2 bytes copied from A0 to A1; fastcopy
		call 80047140(@SP+18)	# initialize default aleck memory manager entries for data A0
		A3+0 = @SP+14
	else:
		A3+0 = 0
		SP+20 = 2
	# 8004A94C
	call 8004C4A0(flag)	# V0 = flags after masking Status with A0
	A3+0 |= (@8007B2D4+v << 16)
	8007B2D4+v = 0
	return @SP+20
8004A9D8
8004AC00
8004ACBC
8004ADCC
8004AE44

8004B160	V0 = p->initialized Aleck "ram" at A0, size A1
	accepts: A0=address, A1=size
	# Effectively sets up a memory manager for the 0x400000 bytes at E0000000, returning E0000000.
	A0+30 = 0
	A0+8 = A0
	A0+C = 0
	A0+14 = 0
	A0+20 = 0
	A0+10 = A0+20
	A0+24 = A0+10
	call 8004B21C(A0, A0+38, A1 - 0x38)	# create aleck memory manager for A2 bytes at A1 using table A0
	return A0
8004B21C	create aleck memory manager for A2 bytes at A1 using table A0
	accepts: A0=p->table, A1=p->data, A2=size
	A1+8 = ~A1	# for E0000038: 1FFFFFC7
	A1+0 = @A0+24
	A1+4 = @A0+24
	A1+0 = A1 + 0x20
	A0+24 = A1
	A1+C = A2 >> 4
	call 8004B2DC(A0, A1 + 0x10)	# initialize aleck memory manager entries for data A1 using table A0
8004B2DC	initialize aleck memory manager entries for data A1 using table A0
	accepts: A0=p->table, A1=p->data
	flag = call 8004C4A0(1)	# V0 = flags after masking Status with A0
	header = A1 - 0x10
	if @header+8 != ~header:
		call 8004C4A0(flag)	# V0 = flags after masking Status with flags A0
		return
	header+8 = 0
	v = @header+4
	v+0 = @header+0
	v = @header+0
	v+4 = @header+4
	# 8004B390
	while True:
		v = @A0+30
		if (v < header) and (header < @v+8):
			break
		if v >= @v+8:
			if (v < header) or (header < @v+8):
				break
		A0+30 = @v+8
	# 8004B42C
	v = header + (@header+C << 4)
	if v == @v+8:
		# 8004B454
		v = @(@A0+30)+8
		header+C += @(@A0+30)+C
		header+8 = v
	else:
		# 8004B490
		header+8 = @(@A0+30)+8
	# 8004B4A0
	v = @A0+30 + @(@A0+30)+C << 4
	if v == header:
		# 8004B4C4
		(@A0+30)+C += @header+C
		(@A0+30)+8 = @header+8
	else:
		# 8004B4F8
		(@A0+30)+8 = header
	# They assign A0+30 to the buffered copy from earlier.
	call 8004C4A0(flag)	# V0 = flags after masking Status with flags A0
8004B534	allocate entry of size A1 in aleck memory manager A0
	accepts: A0=p->table, A1=size
8004B708	V0 = @A0+10
8004B73C	V0 = @A0+30
8004B770	allocate and initialize entry of size A1 in aleck memory manager A0
	accepts: A0=p->table, A1=size
	v = call 8004B534(A0, A1)
	if v:
		call 80053E50(v, A1)	# initialize A1 bytes at A0
	return v
8004B7E0	read TLB entry A0 to A1
	accepts: A0=index, A1=p->target
8004B890	write TLB entry @A1 to index A0
	accepts: A0=index, A1=p->entry (EntryHi, EntryLo0, EntryLo1, PageMask)
8004B950	V0 = eeprom type read using SI queue A0 (0:none, 1:4k, 2:8k)
	accepts: A0=p->queue
	call 800548D4()	# wait for message on SI lock queue (80120390), creating if necessary
	if not call 80059440(A0, SP+10):	# V0 = errors when reading status of eeprom to A1 using SI queue A0
		v = SP[10:12] & 0xC000
		if v == 0x8000:
			return 1
		elif v == 0xC000:
			return 2
	return 0
8004B9D0	V0 = errors writing A3 bytes of data A2 to eeprom address A1 using queue A0
	accepts: A0=p->queue, A1=address, A2=p->data, A3=length
	v = 0
	while A3 > 0:
		v = call 80059230(A0, A1 & 0xFF, A2)	# V0 = errors when sending SI write eeprom request writing data A2 to address A1 using queue A0
		if v:
			break
		A3 -=8
		A1 += 1
		A2 += 8
		call 80054F10(801130F0, -, 0, 0x89544, 0, 0, 801180F0, 800D26C0)	# create timer A0 for (A2, A3) from (SP+10, SP+14), writing or jamming (SP+1C) queue SP+18
		call 800541B0(801180F0, 0, True)	# read or wait (A2) to write msg from queue A0 to A1
	return v
8004BAC0	V0 = errors reading A3 bytes from eeprom address A1 to A2 using queue A0
	accepts: A0=p->queue, A1=address, A2=p->target, A3=length
	v = 0
	while A3 > 0:
		v = call 80059010(A0, A1 & 0xFF, A2)	# V0 = errors when writing result of SI read eeprom request for address A1 to A2 using queue A0
		if v:
			break
		A3 -= 8
		A1 += 1
		A2 += 8
	return v
8004BB30	master copy of exception handler jump
8004BB40	exception handler
8004C490	redirect to 80054A40()
8004C4A0	V0 = flags after masking Status with flags A0
8004C540	create EPI request thread with priority A0, using queue A1 with A3 msgs at A2
	accepts: A0=priority, A1=p->queue, A2=p->msgs, A3=#msgs
	if @800671F0:
		return
	call 80054040(A1, A2, A3)	# create message queue A0 with A2 messages at A1
	call 80054040(8007C4C0, 8007C4D8, 1)	# create message queue A0 with A2 messages at A1
	if not @80067230:
		call 8004CEA0()	# create and initialize access queue at 800AF7E0
	call 80054410(8, 8007C4C0, 0x22222222)	# create callback for event A0, sending msg A2 to queue A1: PI int
	v = call 80054B20(None)	# V0 = priority of thread A0 or current thread
	if v < A0:
		call 80054B40(None, A0)	# change priority of thread A0 or current thread to A1
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	800671F0+0 = True
	800671F0+4 = 8007B310
	800671F0+8 = A1
	800671F0+C = 8007C4C0
	800671F0+10 = 800AF7E0
	800671F0+14 = 80059700
	800671F0+18 = 8004C6D0
	call 80054970(8007B310, 0, 8004CAE0, 800671F0, 8007C4C0, A0)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	call 80054C10(8007B310)	# start thread A0
	call 80059650(flag)
	if v < A0:
		call 80054B40(None, v)	# change priority of thread A0 or current thread to A1
8004C6D0	read or write (A1) SP+10 bytes between hardware A2 and rdram A3 using EPI handle A0; EPI DMA request handler
	accepts: A0=p->EPI handle, A1=mode, A2=hardware offset, A3=p->rdram, SP+10=size
8004C8C0	V0 = errors when completing and sending read or write (A2) E/PI request A1 using EPI handle A0
	accepts: A0=p->EPI handle, A1=p->request, A2=mode (0:read, 1:write)
	if not @800671F0:
		return -1
	A1+14 = A0
	A1[0:2] = 0xF + mode
	if A1[2] == 1:
		v = call 800597D0()	# V0 = p->E/PI queue if initialized else None
		return call 80054070(v, A1, False)
	else:
		v = call 800597D0()	# V0 = p->E/PI queue if initialized else None
		return call 800542E0(v, A1, False)	# send or jam (A2) msg A1 to queue A0
8004C960	V0 = p->EPI handle for cart, creating if necessary
	call 8004CEF4()
	if @80067220:
		80067220 = 0
		800AEED8[4] = 0
		800AEED8+C = B0000000
		800AEED8[9] = 0
		800AEED8[10] = 0
		call 80053E50(800AEEDC+10, 0x60)	# initialize A1 bytes at A0
		while @A4600010 & 3:
			pass
		org = @A4600014, @A4600018, @A460001C, @A4600020
		v = @800AEED8+C | A0000000
		A4600014 = 0xFF
		A4600018 = 0xFF
		A460001C = 0
		A4600020 = 3
		v = @v+0
		A4600014, A4600018, A460001C, A4600020 = *org
		800AEED8[6] = (v >> 16) & 0xF
		800AEED8[5] = v & 0xFF
		800AEED8[7] = (v >> 20) & 0xF	(v >> 8) & 0xF
		800AEED8[8] = (v >> 8) & 0xFF
		v = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
		800AEED8+0 = @8006720C
		8006720C = 800AEED8
		call 80059650(v)	# Status |= A0
	return 800AEED8
8004CAE0	Thread: E/PI request handler
	accepts: A0=epi struct @ 800671F0

8004CEA0	create and initialize access queue at 800AF7E0
	80067230 = 1
	call 80054040(800AF7E0, 8007C4E0, 1)
	call 800542E0(800AF7E0, 0, False)
8004CEF4



8005095C
	accepts: A0, A1
	A0+4 = A1
	A0+0 = @A1+0
	v = @A1+0
	if v:
		v+4 = A0
	A1+0 = A0
8005097C
	accepts: A0
	v = @A0+0
	if v:
		v+4 = @A0+4
	v = @A0+4
	if v:
		v+0 = @A0+0
800509B0	set allocation table A0 for A2 bytes at A1
	accepts: A0=p->allocation table, A1=p->rdram, A2=size
	v = A1 & 0xF
	v = 0x10 - v
	A0+0 = A1 if v == 0x10 else A1+v
	A0+4 = @A0+0
	A0+8 = A2
	A0+C = 0
800509F0	V0 = p->count SP+10 blocks of size A3 allocated from table A2
	accepts: A0=(unused), A1=(unused), A2=p->allocation table, A3=size, SP+10=count
	v = @SP+10 * A3
	v += 0xF
	v &= ~0xF
	k = @A2+8 + @A2+0	# end of allocation
	i = @A2+4	# start of block
	v += @A2+4	# end of block
	if k < v:
		return None
	A2+4 = v
	return i
80050A40	copy A2 bytes from A0 to A1
80050A80
80050B8C
80050C80
	accepts: A0, A1=p->target
	if not @A0+4:
		return 0
	v = -1
	for i in range(0x10):
		if not (@A0+4 >> i) & 1:
			continue
		if @A0+14:
			A0+B8+(i<<2) -= @A0+10
		if @A0+B8+(i<<2) >= v:
			v = @A0+B8+(i<<2)
	A0+14 = 0
	A1+0 = v
	return 1
80050D00
80050F70
80050FEC
8005108C	V0 = @A0+C
80051094

80051B28
80051B90
80051C30

80051DC0	(check this one!) invalidate 0x2000 of data cache at 80000000
80051DF0	send pifram status requests, informing queue A0
	accepts: A0=p->queue
	call 800548D4()	# wait for message on SI lock queue (80120390), creating if necessary
	if 800D26BC[0]:	# write Status requests if not already in the buffer
		call 800522C0(0)	# fill buffer 8007DAF0 with SI status or reset (A0) commands
		call 800547D0(1, 8007DAF0)	# read or write (A0) between rdram A1 and pifram
		call 800541B0(A0, 0, True)	# read or wait (A2) to write msg from queue A0 to A1
	# 80051E3C
	v = call 800547D0(0, 8007DAF0)	# read or write (A0) between rdram A1 and pifram
	800D26BC[0] = 0
	call 80054940()	# send message 0 to queue 80120390: SI lock queue
	return v
80051E70	copy result of SI status request to A0; calls 8005220C
	accepts: A0
	call 8005220C(SP+10, A0)
80051E90	send pifram read requests, informing queue A0
	accepts: A0=p->queue
	call 800548D4()	# wait for message on SI lock queue (80120390), creating if necessary
	if 800D26BC[0] != 1:
		call 80051FB4()	# fill buffer 8007DAF0 with SI read request commands
		call 800547D0(1, 8007DAF0)	# read or write (A0) between rdram A1 and pifram
		call 800541B0(A0, 0, True)	# read or wait (A2) to write msg from queue A0 to A1
	v = call 800547D0(0, 8007DAF0)	# read or write (A0) between rdram A1 and pifram
	800D26BC[0] = 1
	call 80054940()	# send message 0 to queue 80120390: SI lock queue
80051F18	copy result of SI read request to A0
80051FB4	fill buffer 8007DAF0 with SI read request commands
80052070	initialize and read controller status to A1, presence flags to A2, informing queue A0
	accepts: A0=p->queue, A1=p->target for status, A2=p->target for controller presence flags
8005220C	copy result of SI status request to A1, setting presence flags to A0
	accepts: A0=p->flags, A1=p->results
800522C0	fill buffer 8007DAF0 with SI status or reset (A0) commands
80052380	V0 = physical address for A0
800523E0	F0 = square root of float F12
800523F0
800525A0

80053B30	V0 = p->A2 bytes copied from A0 to A1; fastcopy
80053E50	initialize A1 bytes at A0
80053EF0	V0 = p->char A1 in string A0 or None
	accepts: A0=p->string, A1=char
80053F30	V0 = p->end fo string A0
80053F54	copy A2 bytes from A1 to A0
	accepts: A0=p->target, A1=p->source, A2=count
80053F80	V0 = p->C-string A1 expanded and Null-terminated to A0
	accepts: A0=p->target, A1=p->src, ...
	v = call 80059DD0(80053FD8, A0, A1, p->args)	# expand C-string A2 to A1 using function A0 and p->args A3
	if v >= 0:
		A0[v] = 0
	return v
80053FD8	V0 = p->end of A2 bytes copied from A1 to A0
	call 80053F54(A0, A1, A2)	# copy A2 bytes from A1 to A0
	return A0+A2
80054010	unconditional return
80054018	NERFed! print debug message A0; stores arguments to stack
8005402C	NERFed!; stores arguments to stack
80054040	create message queue A0 with A2 messages at A1
80054070
800541B0	read or wait (A2) to write msg from queue A0 to A1
800542E0	send or jam (A2) msg A1 to queue A0
80054410	create callback for event A0, sending msg A2 to queue A1
	accepts: A0=event index, A1=p->queue, A2=message
	flag = call 800595E0()
	v = 801175A0 + (A0 << 3)
	v+0 = A1
	v+4 = A2
	if A0 == 0xE:
		if @8006881C and not @80067550:
			call 800542E0(A1, A2, False)	# send or jam (A2) msg A1 to queue A0
		80067550+0 = 1
	call 80059650(flag)
800544C0	A410000C = A0; set DP Status to A0
800544D0

800547D0	read or write (A0) between rdram A1 and pifram
80054880	create and initialize queue at 80120390: SI lock queue
	call 80054040(80120390, 8007C550, 1)	# create message queue A0 with A2 messages at A1
	call 800542E0(80120390, 0, False)	# send or jam (A2) msg A1 to queue A0
800548D4	wait for message on SI lock queue (80120390), creating if necessary
	if not @80067580:
		80067560 = 1
		call 80054040(80120390, 8007C550, 1)	# create message queue A0 with A2 messages at A1
		call 800542E0(80120390, 0, False)	# send or jam (A2) msg A1 to queue A0
	call 800541B0(80120390, SP+10, True)	# read or wait (A2) to write message from queue A0 to A1
80054940	send message 0 to queue 80120390: SI lock queue
	call 800542E0(80120390, 0, False)	# send or jam (A2) msg A1 to queue A0
80054970	create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14
	accepts: A0=p->thread, A1=ID, A2=p->function, A3=arg, SP+10=p->SP, SP+14=priority
80054A40

80054B20	V0 = priority of thread A0 or current thread
	accepts: A0=p->thread or None
80054B40	change priority of thread A0 or current thread to A1
	accepts: A0=p->thread or None, A1=priority
80054C10	start thread A0
80054D30
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = 4 if not A0 else A0[10:12]
	if v == 2:
		# 80054DB4
		A0[10:12] = 1
		call 80054DF0(@A0+8, A0)
	elif v in (4, 8):
		# 80054D94
		v = @80067580
		v[10:12] = 1
		call 8004C1AC(0)
	call 80059650(flag)	# Status |= A0
80054DF0
	v = @A0+0
	while v:
		if v == A1:
			A0+0 = @v+0
			return
		A0 = v
		v = @A0+0
80054E30
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @80067580
	v[10:12] = 2
	call 8004C1AC(80067578)
	call 80059650(flag)	# Status |= A0
80054E80	V0, V1 = Count plus timer base (@800AEE70, @800AEE78)
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = call 8005A830()	# V0 = Count
	v -= @8007D914
	call 80059650(flag)	# Status |= A0
	l = v + @800AEE74
	u = @800AEE70 + (u < v)
80054F10	create timer A0 for (A2, A3) from (SP+10, SP+14), writing or jamming (SP+1C) queue SP+18
	accepts: A0=p->timer, A1=(not used), (A2, A3)=end, (SP+10, SP+14)=start, SP+18=p->queue, SP+1C=mode (0:write, 1:jam)
80055040
	v = @80067590
	800AEE70 = 0
	800AEE74 = 0
	8007D914 = 0
	v+0 = v
	v+4 = v
	v+8 = 0
	v+C = 0
	v+10 = 0
	v+14 = 0
	v+18 = 0
	v+1C = 0
80055094

80055420	V0 = ???; @frame manager+4
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E0
	call 80059650(flag)	# Status |= A0
	return @v+4
80055460	V0 = ???; @VI manager struct+4
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	call 80059650(flag)	# Status |= A0
	return @v+4
800554A0	@A4400010
800554B0	create and start VI thread with priority A0
	accepts: A0=priority
	if @800675A0:
		return
	call 80055040()
	800675BC = 0
	call 80054040(8007D720, 8007D738, 5)	# create message queue A0 with A2 messages at A1
	8007D750[0:2] = 0xD
	8007D750[2] = 0
	8007D750+4 = 0
	8007D768[0:2] = 0xE
	8007D768[2] = 0
	8007D768+4 = 0
	call 80054410(7, 8007D720, 8007D750)	# create callback for event A0, sending msg A2 to queue A1: vertical retrace
	call 80054410(3, 8007D720, 8007D768)	# create callback for event A0, sending msg A2 to queue A1: counter
	v = call 80054B20(None)	# V0 = priority of thread A0 or current thread
	if v < A0:
		call 80054B40(None, A0)	# change priority of thread A0 or current thread to A1
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	800675A0+0 = 1
	800675A0+4 = 8007C568
	800675A0+8 = 8007D720
	800675A0+C = 8007D720
	800675A0+10 = 0
	800675A0+14 = 0
	800675A0+18 = 0
	call 80054970(8007C568, 0, 80055650, 800675A0, 8007D720, A0)	# create thread A0, ID A1, calling A2(A3) w/ stack at SP+10 and priority SP+14: VI
	call 8005ABD0()	# initialize VI frame managers
	call 80054C10(8007C568)	# start thread A0
	call 80059650(flag)	# Status |= A0
	if v < A0:
		call 80054B40(None, v)	# change priority of thread A0 or current thread to A1
80055650	Thread: VI
	accepts: A0
800557F0	set VI interrupt callback to queue A0, msg A1, mode A2
	accepts: A0=p->queue, A1=value, A2=mode
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	v+10 = A0
	v+14 = A1
	v[2:4] = A2
	call 80059650(flag)	# Status |= A0
80055850	use VI settings at A0
	accepts: A0=p->VI settings
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	v+8 = A0
	v[0:2] = 1
	v+C = @A0+4
	call 80059650(flag)	# Status |= A0
800558A0	set VI manager settings based on flags A0
	accepts: A0=flags
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	if A0 & 1:
		v+C |= 8
	if A0 & 2:
		v+C &= ~8
	if A0 & 4:
		v+C |= 4
	if A0 & 8:
		v+C &= ~4
	if A0 & 0x10:
		v+C |= 0x10
	if A0 & 0x20:
		v+C &= ~0x10
	if A0 & 0x40:
		v+C |= 0x10000
		v+C &= ~0x300
	if A0 & 0x80:
		v+C &= ~0x10000
		v+C |= @(@v+8)+4 & 0x300
	v[0:2] |= 8
	call 80059650(flag)	# Status |= A0
80055A10	set VI Y scale to F12
	accepts: F12
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	v[0:2] |= 4
	v+24 = F12
	call 80059650(flag)	# Status |= A0
80055A60
	accepts: A0
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	v[0:2] |= 0x10
	v+4 = A0
	call 80059650(flag)	# Status |= A0
80055AB0
80055DC0	blackout screen if A0
	accepts: A0=mode
	flag = call 800595E0()	# disable exceptions; V0 = exceptions flag from Status
	v = @800688E4
	if mode & 0xFF:
		v[0:2] |= 0x20
	else:
		v[0:2] &= ~0x20
	call 80059650(flag)	# Status |= A0
80055E20
80055E80

800576B0
	accepts: A0=p->ctrl handle, A1, A2
	if not @A0 & 1:
		return 5
	v = call 800583F4(A0)	# V0 = error reading mempak using controller handle A0
	if v:
		return v
	if A0[65]:
		v = call 80057CF0(A0, 0)	# V0 = errors writing block of A1 to slot addr 0x400 using controller handle A0
		if v:
			return v
	# 80057728
	j = 0
	for i in range(@A0+50):
		v = call 800587F0(@A0+4, @A0+8, @A0+5C + i, SP+10)	# V0 = errors reading 0x20 block of data from slot A1, address A2, to A3, informing queue A0
		if v:
			return v
		if SP[14:16]:
			j += 0 < @SP+10
	A2 = j
	A1+0 = @A0+50
	return call 80057AE0(@A0+4, @A0+8)
800577B0

80057AE0
80057BD0

80057CF0	V0 = errors writing block of A1 to slot addr 0x400 using controller handle A0
	accepts: A0=p->ctrl handle, A1=value
	SP[18:38] = repeat(A1, 0x20)
	if not call 800589E0(@A0+4, @A0+8, 0x400, SP+18):	# V0 = errors writing 0x20 block of data A3 to slot A1, address A2, informing queue A0
		A0[65] = A1
80057D60

800583F4	V0 = error reading mempak using controller handle A0
	accepts: A0=p->ctrl handle
	if not A0[65]:
		v = call 80057CF0(A0, 0)	# V0 = errors writing block of A1 to slot addr 0x400 using controller handle A0
		if v == 2:
			v = call 80057CF0(A0, 0)	# V0 = errors writing block of A1 to slot addr 0x400 using controller handle A0
		if v:
			return v
	v = call 800587F0(@A0+4, @A0+8, 1, SP+10)	# V0 = errors reading 0x20 block of data from slot A1, address A2, to A3, informing queue A0
	if v == 2:
		v = call 800587F0(@A0+4, @A0+8, 1, SP+10)	# V0 = errors reading 0x20 block of data from slot A1, address A2, to A3, informing queue A0
	if v:
		return v
	v = 0 < call 80059CC0(A0+C, SP+10, 0x20)	# V0 = False if A2 bytes of data A0 and A1 match else True
	return v << 1
800584AC

800587F0	V0 = errors reading 0x20 block of data from slot A1, address A2, to A3, informing queue A0
	accepts: A0=p->queue, A1=slot, A2=address, A3=p->data
800589E0	V0 = errors writing 0x20 block of data A3 to slot A1, address A2, informing queue A0
	accepts: A0=p->queue, A1=slot, A2=address, A3=p->data
80058BF0	no code until 80058C50
80058C50	call 8005A8D0(0)
80058C70	create default EPI handles at 800AF9E4 and 800ADB34
80058D28	initialize system
	80117628 = 1
	v = call 8005A840()	# V0 = Status
	call 8005A870(0x20000000 | v)	# Status = A0
	call 8005A860(0x1000800)	# V0 = COP1 Control; COP1 Control = A0
	call 8005A880(0x4900000)	# WatchLo = A0: A4900000
	while call 8005A990(1FC007FC, SP+10):	# V0 = success of reading word from PIFram offset A0 to A1
		pass
	while call 8005A9E0(1FC007FC, @SP+10 + 8)	# V0 = success of writing word A1 to PIFram offset A0
		pass
	80000000[0:10] = 8004BB30[0:10]
	80000080[0:10] = 8004BB30[0:10]
	80000100[0:10] = 8004BB30[0:10]
	80000180[0:10] = 8004BB30[0:10]
	call 80051D40(80000000, 0x190)
	call 80059AF0(80000000, 0x190)
	# create default EPI handles
	800AF9E4[0] = 7
	800AF9E4[1] = @A4600014	# PI Domain 0 Latency
	800AF9E4[2] = @A460001C	# PI Domain 0 Page Size
	800AF9E4[3] = @A4600020	# PI Domain 0 Release
	800AF9E4[4] = @A4600018	# PI Domain 0 Pulse Width
	800ADB34[0] = 7
	800ADB34[1] = @A4600024	# PI Domain 1 Latency
	800ADB34[2] = @A460002C	# PI Domain 1 Page Size
	800ADB34[3] = @A4600030	# PI Domain 1 Release
	800ADB34[4] = @A4600028	# PI Domain 1 Pulse Width
	call 8005AB80()	# initialize TLB entries 0-1E
	call 8005AB20()	# write TLB entry to index 0x1F mapping 0x1000 @ 80000000 to C0000000
	u, l = @80068810, @80068814
	u <<= 1
	u |= l >> 0x1F
	l *= 3
	l += u < 0
	80068810, 80068814 = call 8005CB70(u, l, 0, 4)	# V0, V1 = (A0, A1) DDIVU (A2, A3)
	if not @8000030C:	# reinit NMI buffer on cold boot
		call 80053E50(8000031C, 0x40)	# initialize A1 bytes at A0
	if @80000300 == 0:	# PAL
		80068818 = 0x2F5B2D2
	elif @80000300 == 2:	# MPAL
		80068818 = 0x2E6025C
	else:	# NTSC
		80068818 = 0x2E6D354
	v = call 8005A820()	# V0 = Cause
	if v & 0x1000:
		while True:
			pass
	A4500008 = 1
	A4500010 = 0x3FFF
	A4500014 = 0xF
80059000	unconditional return
80059010	V0 = errors when writing result of SI read eeprom request for address A1 to A2 using queue A0
	accepts: A0=p->queue, A1=address, A2=p->target
	call 800548D4()	# wait for message on SI lock queue (80120390), creating if necessary
	i = call 80059440(A0, SP+10)	# V0 = errors when reading status of eeprom to A1 using SI queue A0
	if i:
		call 80054940()
		return i
	v = SP[10:12] & 0xC000
	if (v == 0x8000) and (A2 >= 0x40):
		i = -1
	elif v != 0xC000:
		i = 8
	if i:
		call 80054940()
		return i
	while SP[12] & 0x80:
		call 80059440(A0, SP+10)	# V0 = errors when reading status of eeprom to A1 using SI queue A0
	call 800591A8(A1)	# fill buffer 8008F7A0 with SI read eeprom request command for address A0
	call 800547D0(1, 800AF7D0)	# read or write (A0) between rdram A1 and pifram
	call 800541B0(A0, 0, True)	# read or wait (A2) to write message from queue A0 to A1
	call 800547D0(0, 800AF7D0)	# read or write (A0) between rdram A1 and pifram
	800D26BC[0] = 4
	call 800541B0(A0, 0, True)	# read or wait (A2) to write message from queue A0 to A1
	# for j in range(4): 800AF7A0+=1	# ignore controller channels
	SP[18:24] = 800AF7A0[4:10]
	i = (800AF7A0[5] & 0xC0) >> 4
	A2[0:8] = SP[1C:24]
	call 80054940()
	return i
800591A8	fill buffer 8008F7A0 with SI read eeprom request command for address A0
	accepts: A0=address
80059230	V0 = errors when sending SI write eeprom request writing data A2 to address A1 using queue A0
	accepts: A0=p->queue, A1=address, A2=p->data
	call 800548D4()	# wait for message on SI lock queue (80120390), creating if necessary
	i = call 80059440(A0, SP+20)	# V0 = errors when reading status of eeprom to A1 using SI queue A0
	if i:
		call 80054940()
		return i
	v = SP[20:22] & 0xC000
	if (v == 0x8000) and (A2 >= 0x40):
		i = -1
	elif v != 0xC000:
		i = 8
	if i:
		call 80054940()
		return i
	while SP[12] & 0x80:
		call 80059440(A0, SP+20)	# V0 = errors when reading status of eeprom to A1 using SI queue A0
	call 80059398(A1, A2)	# fill buffer 8008F7A0 with SI write eeprom request command for address A0, data A1
	call 800547D0(1, 800AF7D0)	# read or write (A0) between rdram A1 and pifram
	call 800541B0(A0, 0, True)	# read or wait (A2) to write message from queue A0 to A1
	call 800547D0(0, 800AF7D0)	# read or write (A0) between rdram A1 and pifram
	800D26BC[0] = 5
	call 800541B0(A0, 0, True)	# read or wait (A2) to write message from queue A0 to A1
	SP[10:1C] = 800AF7A0[4:10]
	i = (800AF7A0[5] & 0xC0) >> 4
	call 80054940()
	return i
80059398	fill buffer 8008F7A0 with SI write eeprom request command for address A0, data A1
	accepts: A0=address, A1=p->data
80059440	V0 = errors when reading status of eeprom to A1 using SI queue A0
	accepts: A0=p->queue, A1=p->target
800595E0	disable exceptions; V0 = exceptions flag from Status
80059650	Status |= A0
80059670
	v = call 800595E0()
	80068820+0 |= A0
	call 80059650(v)
800596B0
	v = call 800595E0()
	80068820+0 &= (~A0 | 0x401)
	call 80059650(v)
80059700	read or write (A0) A3 bytes between boot device offset A1 and rdram A2; PI DMA request handler
	accepts: A0=mode (0:read, 1:write), A1=hardware address, A2=p->rdram, A3=length
800597D0	V0 = p->E/PI queue if initialized else None
800597F0	V0 = errors when reading word from uncached hardware address A1 to rdram A2 using EPI handle A0
	accepts: A0=p->EPI handle, A1=hardware offset, A2=p->target
80059960	V0 = errors when writing word A2 to uncached hardware address A1 using EPI handle A0
	accepts: A0=p->EPI handle, A1=hardware offset, A2=value
80059AD0

80059CC0	V0 = False if A2 bytes of data A0 and A1 match else True
	accepts: A0=p->data1, A1=p->data2, A2=length
80059DD0	expand C-string A2 to A1 using function A0 and p->args A3
	accepts: A0=p->function, A1=p->target, A2=p->source, A3=p->args
8005A350
8005A820	V0 = Cause
8005A830	V0 = Count
8005A840	V0 = Status
8005A850	Compare = A0
8005A860	V0 = COP1 Control; COP1 Control = A0
8005A870	Status = A0
8005A880	WatchLo = A0
8005A890
	return bool(@A4040010 & 0x1C)
8005A8B0	V0 = @A4040010
8005A8C0	A4040010 = A0
8005A8D0
	if not @A4040010 & 1:
		return -1
	A4080000 = A0
	return 0
8005A900	SP DMA: V0 = success of reading or writing (A0) A3 bytes between SP address A1 and rdram A2
	accepts: A0=mode (0:write, 1:read), A1=SP address, A2=p->rdram, A3=length
	if call 8005A890():
		return -1
	A4040000 = A1
	A4040004 = call 80052380(A2)	# V0 = physical address for A0
	if not A0:
		A404000C = A3
	else:
		A4040008 = A3
	return 0
8005A990	V0 = success of reading word from PIFram offset A0 to A1
8005A9E0	V0 = success of writing word A1 to PIFram offset A0
8005AA30
8005AA9C
8005AB20	write TLB entry to index 0x1F mapping 0x1000 @ 80000000 to C0000000
8005AB80	initialize TLB entries 0-1E
8005ABD0	initialize VI frame managers
8005ACE0	V0 = @800688E0: p->current frame manager
8005AD00

8005C440	V0 = True if SI busy else False
8005C460

8005C620	V0=p->A2 bytes at A0 filled with value A1
	accepts: A0=p->target, A1=value, A2=length
8005C6C0	V0=p->A1 bytes at A0 filled with value A2; call 8005C620(A0, A2, A1)
	accepts: A0=p->target, A1=length, A2=value
8005C6F0
	v = @8007D880 * 0x41C64E6D
	8007D880 = v + 0x3039
	v += 0x303A
	return (v >> 16) & 0x7FFF
8005C724	8007D880 = A0
8005C730	V0 = p->string A0 copied from A1
	accepts: A0=p->target, A1=p->src
8005C804
8005C838	(not sure if these are independant or part of 8005CB70)
8005C934	(not sure if these are independant or part of 8005CB70)
8005CAB0	(not sure if these are independant or part of 8005CB70)
8005CB70	V0, V1 = (A0, A1) DDIVU (A2, A3)
8005CB90
8005CBD0
8005CCF0
8005CDF0	RSP instructions

8005DA50	RSP instructions; 0xD0
8005DB20	code for microcode F3DEX fifo 2.08; 0x1190
8005EEB0	code for microcode L3DEX fifo 2.08; 0x1190
80060040	code for microcode F3DEX.Rej fifo 2.08; 0x1190
800611D0	code for microcode F3DEX.NoN fifo 2.08

80062560	code for microcode F3DLX.Rej fifo 2.08; 0x1190
800636F0	code for microcode S2DEX fifo 2.08

80064FB0	screen flags

80064FBC	screen width
80064FC0	screen height

800667BC	pointers to strings "Slot", "In", "Coin", "PLAY"
800667CC

80066994	char mapping table for ASCII
80066A14

80066B94	NuSys library version	"NuSystem2.07"
80066BA4

80066BC0	number of framebuffers
80066BC4	fifo size
80066BC8	p->fifo buffer
80066BCC	p->function
80066BD0	p->function

80066BE0	microcode table; p->code, p->data
	8005DB20 80068C70	F3DEX fifo 2.08
	800611D0 80069890	F3DEX.NoN fifo 2.08
	80060040 80069480	F3DEX.Rej fifo 2.08
	80062560 80069CB0	F3DLX.Rej fifo 2.08
	8005EEB0 80069090	L3DEX fifo 2.08
	800636F0 8006A0C0	S2DEX fifo 2.08
80066C10	p->framebuffers
80066C20	display list
80066D10

80066D18	function pointers: SI callback for controller pak
	00000000 8003CD10 8003CD9C 8003CE98 8003CE04 8003CFA0 8003D028 8003D09C 8003D110
80066D40	SI callback for controller pak; function pointers at 80066D18
80066D4C
80066D50
80066D54	function pointers
	8003D5B0 8003D858 8003DA60 8003DB50 8003D8EC 8003D9B8
80066D70	SI callback for ???; function pointers at 80066D54
80066D7C
80066D80	function pointers: SI callback for eeprom
	00000000 8003DD78 8003DDC4 8003DE38
80066D94	SI callback for eeprom; function pointers at 80066D80
80066DA0	p->function (processes display lists?)
80066DA4	p->function

80066DC0	p->function; run after reading controller input
80066DC4	function pointers: SI callback for controller input
	8003EC64 8003ED28 8003ED78 8003EBD8
80066DD8	SI callback for controller input; uses pointers at 80066DC4
80066DE4

80066E5C	p->function
80066E60	p->function

800671F0	device manager struct
8006721C
80067220	False if cart EPI handle generated

80067580	p->current thread

800675C0	VI settings table
800687E0

80068810	clock rate
80068818	VI refresh rate (from detected region)
8006881C

800688E0	p->current frame manager
800688E4	p->VI manager struct

80068C70	data for microcode F3DEX fifo 2.08

80069890	data for microcode F3DEX.NoN fifo 2.08

80069480	data for microcode F3DEX.Rej fifo 2.08

80069CB0	data for microcode F3DLX.Rej fifo 2.08

80069090	data for microcode L3DEX fifo 2.08

8006A0C0	data for microcode S2DEX fifo 2.08

8006A518	function pointers for 80029870
	800298B0 800298B0 80029AD4 800299A8 80029ACC 80029AD4 80029AD4
8006A538	function pointers
	80029B28 80029B28 80029C64 80029B80 80029C5C 80029C64 80029C64
8006A558	 ==  EEPROM ERROR == NOT INIT != 0 \n
8006A580	 ==  EEPROM ERROR == NOT INIT != 0xFF \n
8006A5A8	error mode No=%d\n
8006A5C0	function pointers
	8002AA2C 8002AAE0 8002AFCC 8002AE78 8002B024 8002B248 8002B280 8002B2B8
8006A5E0	NO-G
8006A5E5	 REP
8006A5EA	 BIG
8006A5EF
8006A5F4	 REP
8006A600	function pointers
	8002BF6C 8002BF94 8002C068 8002C114 8002C134
8006A614	 BIG
8006A620	function pointers
	8002C314 8002C390 8002C3B8 8002C480 8002C4A0
8006A634
8006A640	function pointers
	8002C734 8002C75C 8002C784 8002C84C 8002C86C
8006A654	00010204060809
8006A65C	 BIG PST = %d\n
8006A66C	 SLOT_TYPE = %x\n
8006A680	 GET SMALL \n
8006A690	 GET NUM = %d\n
8006A6A0	Service Game Last = %d\n
8006A6B8	function pointers
	8002CE5C 8002CFA0 8002D2C0 8002D2C0 8002D2F4 8002D358
8006A6D0	+ CT START +\n
8006A6E0	function pointers
	8002D534 8002D58C 8002D5B4 8002D62C 8002D6CC 8002D738 8002D774 8002D7E0
8006A700	++ BIG START ++\n
8006A714	BIG PLAY!! \n
8006A724	S-0%d
8006A72C	S-%d
8006A734	On
8006A738	OFF
8006A73C	----
8006A744	=--=
8006A74C	====
8006A754	  %4d\n
8006A75C	  %4d-%d\n
8006A768	%f\n
8006A76C	 ----- Test Mode -----\n
8006A784	Mode Select No=%2d , Mode Count=%llu\n
8006A7AC	 == EEPROM ERROR == \n
8006A7C4	  EEPROM = 4K Bit \n
8006A7D8	  EEPROM = 16K Bit \n
8006A7F0	function pointers
	8002EB8C 8002ED34 8002EFB4 8002F118 8002F270 8002F3C8 8002F520 8002F678 8002F7D0 8002F934 8002FA8C 8002FBE4 8002FD48 8002FEA0 8002FFF8 80030150
8006A830	BUTTON SWITCH TEST
8006A844	 SCH
8006A84C	ON = SERVICE SWITCH
8006A864	 C-1
8006A86C	ON = CREDIT TRANCE
8006A880	 C-2
8006A888	ON = CREDIT CREAR
8006A89C	 C-3
8006A8A4	ON = COIN IN
8006A8B4	 C-4
8006A8BC	ON = TEST SWITCH
8006A8D0	 C-5
8006A8D8	ERROR
8006A8E0	 Err
8006A8E8	Aleck Error = CE ERROR
8006A900	  CE
8006A908	Aleck Error = CJ ERROR
8006A920	  CJ
8006A928	Aleck Error = CO ERROR
8006A940	  CO
8006A948	Aleck Error = CR ERROR
8006A960	  Cr
8006A968	Aleck Error = HE ERROR
8006A980	  HE
8006A988	Aleck Error = HJ ERROR
8006A9A0	  HJ
8006A9A8	Aleck Error = EE ERROR
8006A9C0	  EE
8006A9C8	Aleck Error = 6E_COIN ERROR
8006A9E8	  6E
8006A9F0	Aleck Error = 6E_FULL ERROR
8006AA10	(double)
8006AA18	(double)
8006AA20	PLAY
8006AA28	Coin
8006AA30	In
8006AA34	Slot
8006AA3C	%d
8006AA40	%00d
8006AA48
8006AA50	function pointers
	80035B28 80035BF8 80035CCC 80035CE4 80035CFC 80035D14 80035D2C 80035DE0 80035E64 80035FB0 80035F30 80035FE0 80035E64 80035FBC 80035F3C 80035FEC
8006AA90	FULL
8006AA98	function pointers
	80036890 800368A8 800368AC 800368CC 800368D0 800368E8 80036950 8003694C 8003697C 80036994 800369AC
8006AAC4	)\n
8006AAC8	function pointers
	80037FF0 80038040 80038088 800380D4 8003813C 800381BC 800382A0 800382A0 800382A0 800382A0 80038254 80038278 80038390 80038400 800383D4 80038400 8003844C 80038614 80038614 80038614 80038614 80038614 800385D0 800385F4 800389B8 800389D0 800389E8 80038A00 80038A18 80038A30 80038A48 80038A60 80038A78 80038A90 80038AA8 80038AC0 80038C30
8006AB60	function pointers
	80038B08 80038B20 80038B38 80038B50 80038B68 80038B80 80038B98 80038BB0 80038BC8 80038BE0 80038BF8 80038C10 80038C30
8006AB98	function pointers
	80038DD4 80038C6C 80038C80 80038C94 80038CA8 80038CBC 80038CD0 80038CE4 80038CF8 80038DD4 80038DD4 80038D34 80038D48 80038D5C 80038D70 80038D84 80038D98 80038DAC 80038DC0 80038DD4 80038E0C 80038E20 80038E34 80038E48 80038E5C 80038E70 80038E84 80038E98 80038EAC 80038EC0 80038ED4
8006AC18	function pointers
	80038F04 80038F18 80038F2C 80038F40 80038F54 80038F68 80038F7C 80038F90 80038FA4 80038FB8 80038FCC
8006AC48	function pointers
	80038FFC 80039010 80039024 80039038 8003904C 80039060 80039074 80039088 8003909C 800390B0 800390C4
8006AC78	function pointers
	800390F4 80039108 8003911C 80039130 80039144 80039158 8003916C 80039180 80039194 800391A8 800391BC
8006ACA8	function pointers for 8003A7F0
	8003A934 8003A81C 8003A82C 8003A83C 8003A84C 8003A85C 8003A86C 8003A87C 8003A88C 8003A89C 8003A8AC 8003A8BC 8003A8CC 8003A8DC 8003A8EC 8003A8FC 8003A90C 8003A91C 8003A92C
8006ACF8	nuGfxTaskStart: Must set FIFO buffer for fifo-ucode(use nuGfxSetUcodeFifo)\n
8006AD44	nuGfxSetCfb: FrameBuffer Addres Error!!\n
8006AD70	nuGfxUcodeFifoSet: fifo buffer is NOT 16byte boundaries\n
8006ADAC	nuGfxUcodeFifoSet: fifo size is NOT multiple 8 \n
8006ADE0	nuSiMgr: majorNo %#x minorNo %#x is over callback func num(%d).\n
8006AE24	nuSiMgr: no si callback function mesg %#X\n
8006AE50	nuSiCallBackAdd: CallBack is already added(major no = %#X!!\n
8006AE90	(double)
8006AE98	(double)
8006AEA0	(double)
8006AEA8	(double)
8006AEB0	function pointers

8006B590	C-expansion special chars	" +-#0"
8006B598
8006B5B0	C-expansion type special chars	"hlL"
8006B5B8	function pointers
8006B710	(double)
8006B718	(double)
8006B720	(double)
8006B728	(double)
8006B730	(double)
8006B738	(double)
8006B740	(double)
8006B748	(double)
8006B750	(double)
8006B758	C-expansion special float label	"NaN"
8006B75C	C-expansion special float label	"Inf"
8006B760	(double)
8006B768	(double)

8006B780	initialized at runtime

	8006C8A0	copy of controller 1 button input

	8006C9F8	seed for rand()

	8006CA20	thread: main	ID 1, priority 0xA, calling 8003A9A4(0), SP = 8006ED80
	8006CBD0	thread: game	ID 3, priority 0xA, calling 80025C6C(0), SP = 800B1A60
	8006CD80

	*8006ED80	top of main thread stack

	*80070D80	top of thread 80117BC8 stack
	*80072D80	top of thread 80117D78 stack
	*80074D80	top of thread 80117F28 stack

	80074D98	thread	ID 5, priority 0x3C, calling 8003BDE0(0), SP = 80076F50
	80074F48

	*80076F50	top of thread 80074D98 stack

	80076F70	EPI queue w/ 0x32 msgs at 80076F88
	80076F88	messages for queue 80076F70
	80077050

	*80079070	top of thread 800ADC48 stack

	8007B240	message for queue 8007DAD0
	8007B244	message for queue 801203B0

	8007B310	thread: EPI	ID 0, calls 8004CAE0(800671F0), SP = 8007C4C0
	8007B4C0

	*8007C4C0	top of EPI thread stack
	8007C4C0	queue with 1 message at 8007C4D8: event queue
	8007C4D8	message for queue 8007C4C0
	8007C4DC
	8007C4E0	message for queue 800AF7E0
	8007C4E4

	8007C550	message for queue 80120390
	8007C554

	8007C568	thread: VI	ID 0, calling 80055650(800675A0), SP = 8007D720
	8007C718

	*8007D720	top of VI thread stack
	8007D720	queue with 5 messages at 8007D738: vertical retrace and counter callback
	8007D738	5 messages for queue 8007D720
	8007D74C
	8007D750	PI request event: vertical retrace
	8007D768	PI request event: counter
	8007D780

	8007D8B0

	8007DAD0	queue with 1 message at 8007B240
	8007DAE8

	8007DAF0	PIF read cmd buffer
	8007DB30

	*8007DB30	0x20000 initialized by game thread

	*8009DB30	top of game thread allocation

	8009EBB0	blocks of 0x1000 for context function stacks; 16 total
	800A8BB0?

	800ADB34	default EPI handle for domain 1

	800ADC3C[0:2]	True if P1 Start pressed

	800ADC48	thread	ID 4, priority 0x32, calling 8003DEB0(0), SP = 80079070
	800ADDF8	queue with messages at 800B1A64
	800ADE10

	800AE9FC	p->array of E/PI requests; 0x18 each

	800AEA08

	800AEB7C

	800AEB8C

	800AEE50	#connected controllers

	800AEE80

	800AEED8	EPI handle for cart

	800AEF4C	flags indicating which context thingies are filled; from low to high
	800AEF50	16 context thingies for a thread-like doodlie; 0x84 each
	800AF790

	800AF7A0	buffer for eeprom SI status requests
	800AF7E0	queue with 1 message at 8007C4E0: access queue
	800AF7F8

	800AF828	thread	ID 6, priority 0x46, calling 8003F504(0), SP = @801182E0+0 + 0x2000
	800AF9D8	p->microcode table at 80066BE0

	800AF9E4	default EPI handle for domain 0

	*800B1A60	top of boot thread stack + top of game thread stack
	800B1A64	p->array of messages for queue 800ADDF8

	800B2680[0:2]	True if P2 Start pressed

	800D26BC[0]	last type of PIF command copied to 8007DAF0

	800D2750	eeprom buffer
	800D2768

	801127C4	p->0x4000 byte allocation
	801127C8	p->function run in main thread

	80112954	error mode #
	80112958	p->EPI handle for cart

	80112968+0	80112968	E0800000
	80112968+4	8011296C	E0800002
	80112968+8	80112970	E0800004
	80112968+C	80112974	E080000A
	80112968[10:18:2]	80112978	current state; copies of NOR'd values from above four addresses
	80112968[18:20:2]	80112980	previous state; copies of NOR'd values from above four addresses
	80112968[40:42]	801129A8
	80112968[42:44]	801129AA
	80112968[44:46]	801129AC
	80112968[46:48]	801129AE
	80112968[48:4A]	801129B0
	80112968[4A:4C]	801129B2
	80112968[4C:4E]	801129B4
	80112968[4E:50]	801129B6
	80112968[50:52]	801129B8

	80117628	True when system initialized

	80117A74	queue with 8 messages at 80117A8C
	80117A8C	8 messages for queue 80117A74
	80117AAC	queue with 8 messages at 80117AC4
	80117AC4	8 messages for queue 80117AAC
	80117AE4	queue with 8 messages at 80117AFC: VI interrupt and PreNMI callback
	80117AFC	8 messages for queue 80117AE4
	80117B1C	queue with 8 messages at 80117B34: SP task complete callback
	80117B34	8 messages for queue 80117B1C
	80117B54	queue with 8 messages at 80117B6C: DP full sync callback
	80117B6C	8 messages for queue 80117B54
	80117B8C	queue with 8 messages at 80117BA4
	80117BA4	8 messages for queue 80117B8C
	80117BC4
	80117BC8	thread	ID 0x13, priority 0x78, calling 8003AE04(80117A70), SP = 80070D80
	80117D78	thread	ID 0x12, priority 0x6E, calling 8003B2CC(80117A70), SP = 80072D80
	80117F28	thread	ID 0x11, priority 0x64, calling 8003B658(80117A70), SP = 80074D80
	801180D8

	801182F0[A:C]	whatever "slot type" means

	80118300[C:E]	major error code index
		0001	CE
		0002	CJ
		0004	CO
		0008	CR
		0010	HE
		0020	HJ
		0040	EE
		0080	6E
	80118300[E:10]	minor error code index
		0001	coin error
		0002	full error

	80118390	display list buffer

	80120390	queue with 1 message at 8007C550; SI lock queue
	801203A8

	801203B0	queue with 1 message at 8007B244
	801203C8

801203D0	target for file 0x46B80	(pointer correction +800D9850)
	801203D0	46B80.47780.96x32.ci8	クレジット	credit
	80120FD0	ci8 palette for 801203D0
	801211D0	entry for "credit"
	80121200

*8013DDD0	end of file 0x46B80

8033F800	0x50000 allocatable memory
8038F800	framebuffer (320x240 mode)
803B5000	framebuffer (320x240 mode)
803DA800	framebuffer (320x240 mode)
80400000

0x46B80	bin	resources.bin
0x64580